import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public void copyPartialDependencyStructure(DependencyStructure sourceGraph, DependencyStructure targetGraph) throws MaltChainedException {
	SymbolTable partHead = cachedSource.getSymbolTables().getSymbolTable("PARTHEAD");
	SymbolTable partDeprel = cachedSource.getSymbolTables().getSymbolTable("PARTDEPREL");
	if (partHead == null || partDeprel == null) {
		return;
	}
	SymbolTable deprel = cachedTarget.getSymbolTables().getSymbolTable("DEPREL");
	for (int index : sourceGraph.getTokenIndices()) {
		DependencyNode snode = sourceGraph.getTokenNode(index);
		DependencyNode tnode = targetGraph.getTokenNode(index);
		if (snode != null && tnode != null) {
			int spartheadindex = Integer.parseInt(snode.getLabelSymbol(partHead));
			String spartdeprel = snode.getLabelSymbol(partDeprel);
			if (spartheadindex > 0) {
				Edge tedge = targetGraph.addDependencyEdge(spartheadindex, snode.getIndex());
				tedge.addLabel(deprel, spartdeprel);
			}
		}
	}
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public LWDeterministicParser(LWSingleMalt lwSingleMalt, SymbolTableHandler symbolTableHandler, FeatureModel _featureModel) throws MaltChainedException {
	this.manager = lwSingleMalt;
	this.registry = new ParserRegistry();
	this.registry.setSymbolTableHandler(symbolTableHandler);
	this.registry.setDataFormatInstance(manager.getDataFormatInstance());
	this.registry.setAbstractParserFeatureFactory(manager.getParserFactory());
	this.registry.setAlgorithm(this);
	this.transitionSystem = manager.getParserFactory().makeTransitionSystem();
	this.transitionSystem.initTableHandlers(lwSingleMalt.getDecisionSettings(), symbolTableHandler);
	
	this.tableHandlers = transitionSystem.getTableHandlers();
	this.kBestSize = lwSingleMalt.getkBestSize();
	this.decisionTables = new ArrayList<TableContainer>();
	this.actionTables = new ArrayList<TableContainer>();
	initDecisionSettings(lwSingleMalt.getDecisionSettings(), lwSingleMalt.getClassitem_separator());
	this.transitionSystem.initTransitionSystem(this);
	this.config = manager.getParserFactory().makeParserConfiguration();
	this.featureModel = _featureModel;
	this.currentAction = new ComplexDecisionAction(this);
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public Edge moveDependencyEdge(DependencyNode newHead, DependencyNode dependent) throws MaltChainedException {
	if (dependent == null || !dependent.hasHead() || newHead.getBelongsToGraph() != this || dependent.getBelongsToGraph() != this) {
		return null;
	}
	Edge headEdge = dependent.getHeadEdge();

	LabelSet labels = null;
	if (headEdge.isLabeled()) { 
		labels = checkOutNewLabelSet();
		for (SymbolTable table : headEdge.getLabelTypes()) {
			labels.put(table, headEdge.getLabelCode(table));
		}
	}
	headEdge.clear();
	headEdge.setBelongsToGraph(this);
	headEdge.setEdge((Node)newHead, (Node)dependent, Edge.DEPENDENCY_EDGE);
	if (labels != null) {
		headEdge.addLabel(labels);
		labels.clear();
		checkInLabelSet(labels);
	}
	return headEdge;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public void initialize(Object[] arguments) throws MaltChainedException {
	if (arguments.length != 2) {
		throw new SyntaxGraphException("Could not initialize OutputColumnFeature: number of arguments are not correct. ");
	}
	if (!(arguments[0] instanceof String)) {
		throw new SyntaxGraphException("Could not initialize OutputColumnFeature: the first argument is not a string. ");
	}
	if (!(arguments[1] instanceof AddressFunction)) {
		throw new SyntaxGraphException("Could not initialize OutputColumnFeature: the second argument is not an address function. ");
	}
	ColumnDescription column = dataFormatInstance.getColumnDescriptionByName((String)arguments[0]);
	if (column == null) {
		throw new SyntaxGraphException("Could not initialize OutputColumnFeature: the output column type '"+(String)arguments[0]+"' could not be found in the data format specification. ' ");
	}
	setColumn(column);
	setSymbolTable(tableHandler.getSymbolTable(column.getName()));
	setAddressFunction((AddressFunction)arguments[1]);
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public int addSymbol(String symbol) throws MaltChainedException {
	if (nullValues == null || !nullValues.isNullValue(symbol)) {
		if (symbol == null || symbol.length() == 0) {
			throw new SymbolException("Symbol table error: empty string cannot be added to the symbol table");
		}

		if (this.type == SymbolTable.REAL) {
			addSymbolValue(symbol);
		}
		if (!symbolCodeMap.containsKey(symbol)) {
			int code = valueCounter;
			symbolCodeMap.put(symbol, code);
			codeSymbolMap.put(code, symbol);
			valueCounter++;
			return code;
		} else {
			return symbolCodeMap.get(symbol);
		}
	} else {
		return nullValues.symbolToCode(symbol);
	}
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
private FeatureModelManager loadFeatureModelManager(int optionContainer, McoModel mcoModel) throws MaltChainedException {
	final FeatureEngine system = new FeatureEngine();
	system.load("/appdata/features/ParserFeatureSystem.xml");
	system.load(PluginLoader.instance());
	FeatureModelManager featureModelManager = new FeatureModelManager(system);
	String featureModelFileName = OptionManager.instance().getOptionValue(optionContainer, "guide", "features").toString().trim();
	try {
		if (featureModelFileName.endsWith(".par")) {
			String markingStrategy = OptionManager.instance().getOptionValue(optionContainer, "pproj", "marking_strategy").toString().trim();
			String coveredRoot = OptionManager.instance().getOptionValue(optionContainer, "pproj", "covered_root").toString().trim();
			featureModelManager.loadParSpecification(mcoModel.getMcoEntryURL(featureModelFileName), markingStrategy, coveredRoot);
		} else {
			featureModelManager.loadSpecification(mcoModel.getMcoEntryURL(featureModelFileName));
		}
	} catch(IOException e) {
		throw new MaltChainedException("Couldn't read file "+featureModelFileName+" from mco-file ", e);
	}
	return featureModelManager;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
protected GuideUserAction updateActionContainers(int transition, LabelSet arcLabels) throws MaltChainedException {	
	transActionContainer.setAction(transition);

	if (arcLabels == null) {
		for (int i = 0; i < arcLabelActionContainers.length; i++) {
			arcLabelActionContainers[i].setAction(-1);	
		}
	} else {
		for (int i = 0; i < arcLabelActionContainers.length; i++) {
			arcLabelActionContainers[i].setAction(arcLabels.get(arcLabelActionContainers[i].getTable()).shortValue());
		}		
	}
	GuideUserAction oracleAction = history.getEmptyGuideUserAction();
	oracleAction.addAction(actionContainers);
	return oracleAction;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public void initialize(Object[] arguments) throws MaltChainedException {
	if (arguments.length != 3) {
		throw new FeatureException("Could not initialize InputArcFeature: number of arguments are not correct. ");
	}
	// Checks that the two arguments are address functions

	if (!(arguments[0] instanceof String)) {
		throw new FeatureException("Could not initialize InputArcFeature: the first argument is not a string. ");
	}
	if (!(arguments[1] instanceof AddressFunction)) {
		throw new SyntaxGraphException("Could not initialize InputArcFeature: the second argument is not an address function. ");
	}
	if (!(arguments[2] instanceof AddressFunction)) {
		throw new SyntaxGraphException("Could not initialize InputArcFeature: the third argument is not an address function. ");
	}
	setAddressFunction1((AddressFunction)arguments[1]);
	setAddressFunction2((AddressFunction)arguments[2]);
	
	setColumn(dataFormatInstance.getColumnDescriptionByName((String)arguments[0]));
	setSymbolTable(tableHandler.addSymbolTable("ARC_"+column.getName(),ColumnDescription.INPUT, ColumnDescription.STRING, "one"));
	table.addSymbol("LEFT");
	table.addSymbol("RIGHT");
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
@Override
public ComparableNode getRightmostProperDescendant() throws MaltChainedException {
	ComparableNode candidate = null;
	List<DependencyNode> dependents = graph.getListOfDependents(index);
	for (int i = 0; i < dependents.size(); i++) {
		final DependencyNode dep = dependents.get(i);
		if (candidate == null || dep.getIndex() > candidate.getIndex()) {
			candidate = dep;
		}
		final ComparableNode tmp = dep.getRightmostProperDescendant();
		if (tmp == null) {
			continue;
		}
		if (candidate == null || tmp.getIndex() > candidate.getIndex()) {
			candidate = tmp;
		}
	}
	return candidate;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
private boolean deprojectivizeWithHeadAndPath(DependencyStructure pdg, DependencyNode node, boolean[] nodeLifted, boolean[] nodePath, String[] synacticHeadDeprel, SymbolTable deprelSymbolTable) throws MaltChainedException {
	boolean success = true, childSuccess = false;
	int i, childAttempts = 2;
	DependencyNode possibleSyntacticHead;
	if (node.hasHead() && node.getHeadEdge().isLabeled() && nodeLifted[node.getIndex()] && nodePath[node.getIndex()]) {
		possibleSyntacticHead = breadthFirstSearchSortedByDistanceForHeadAndPath(pdg, node.getHead(), node, synacticHeadDeprel[node.getIndex()], nodePath, deprelSymbolTable);
		if (possibleSyntacticHead != null) {
			pdg.moveDependencyEdge(possibleSyntacticHead.getIndex(), node.getIndex());
			nodeLifted[node.getIndex()] = false;
		} else {
			success = false;
		}
	}
	if (node.hasHead() && node.getHeadEdge().isLabeled() && nodeLifted[node.getIndex()]) {
		possibleSyntacticHead = breadthFirstSearchSortedByDistanceForHeadAndPath(pdg, node.getHead(), node, synacticHeadDeprel[node.getIndex()], nodePath, deprelSymbolTable);
		if (possibleSyntacticHead != null) {
			pdg.moveDependencyEdge(possibleSyntacticHead.getIndex(), node.getIndex());
			nodeLifted[node.getIndex()] = false;
		} else {
			success = false;
		}
	}
	while (!childSuccess && childAttempts > 0) {
		childSuccess = true;
		List<DependencyNode> children = node.getListOfDependents();
		for (i = 0; i < children.size(); i++) {
			if (!deprojectivizeWithHeadAndPath(pdg, children.get(i), nodeLifted, nodePath, synacticHeadDeprel, deprelSymbolTable)) {
				childSuccess = false;
			}
		}
		childAttempts--;
	}
	return childSuccess && success;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public Edge addSecondaryEdge(ComparableNode source, ComparableNode target) throws MaltChainedException {
	if (source == null || target == null || source.getBelongsToGraph() != this || target.getBelongsToGraph() != this) {
		throw new SyntaxGraphException("Head or dependent node is missing.");
	} else if (!target.isRoot()) {
		Edge e = edgePool.checkOut();
		e.setBelongsToGraph(this);
		e.setEdge((Node)source, (Node)target, Edge.SECONDARY_EDGE);
		graphEdges.add(e);
		return e;
	}
	return null;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public synchronized void checkInAll() throws MaltChainedException {
	for (T t : inuse) {
		resetObject(t);
		if (available.size() < keepThreshold) {
			available.add(t);
		}
	}
	inuse.clear();
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
/**
 * Sets the usage of the option.
 * 
 * @param usage	the usage of the option.
 * @throws OptionException
 */
public void setUsage(int usage) throws MaltChainedException {
	if (usage >= 0 && usage <= 4) {
		this.usage = usage;
	} else {
		throw new OptionException("Illegal use of the usage attibute value: "+usage+" for the '"+getName()+"' option. ");
	}
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public int getCode(String symbol) throws MaltChainedException {
	if (cachedSymbol == null || !cachedSymbol.equals(symbol)) {
		clearCache();
		cachedSymbol.append(symbol);
		cachedCode = table.getSymbolStringToCode(symbol);
		split();
	}
	return cachedCode;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public void writeSentence(TokenStructure syntaxGraph) throws MaltChainedException {
	if (syntaxGraph == null || dataFormatInstance == null || !(syntaxGraph instanceof PhraseStructure) || !syntaxGraph.hasTokens()) {
		return;
	}
	PhraseStructure phraseStructure = (PhraseStructure)syntaxGraph;
	sentenceCount++;
	try {
		writer.write("#BOS ");
		if (phraseStructure.getSentenceID() != 0) {
			writer.write(Integer.toString(phraseStructure.getSentenceID()));
		} else {
			writer.write(Integer.toString(sentenceCount));
		}
		writer.write('\n');

		if (phraseStructure.hasNonTerminals()) {
			calculateIndices(phraseStructure);
			writeTerminals(phraseStructure);
			writeNonTerminals(phraseStructure);
		} else {
			writeTerminals(phraseStructure);
		}
		writer.write("#EOS ");
		if (phraseStructure.getSentenceID() != 0) {
			writer.write(Integer.toString(phraseStructure.getSentenceID()));
		} else {
			writer.write(Integer.toString(sentenceCount));
		}
		writer.write('\n');
	} catch (IOException e) {
		throw new DataFormatException("Could not write to the output file. ", e);
	}
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public TrieSymbolTable(String _name, Trie _trie, int _category, String nullValueStrategy) throws MaltChainedException { 
	this.name = _name;
	this.trie = _trie;
	this.category = _category;
	codeTable = new TreeMap<Integer, TrieNode>();
	if (this.category != SymbolTable.OUTPUT) {
		nullValues = new OutputNullValues(nullValueStrategy, this);
	} else {
		nullValues = new InputNullValues(nullValueStrategy, this);
	}
	valueCounter = nullValues.getNextCode();
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public ParseSymbolTable(String name, SymbolTableHandler parentSymbolTableHandler) throws MaltChainedException {
	this.name = name;
	this.type = SymbolTable.STRING;
	this.parentSymbolTable = parentSymbolTableHandler.addSymbolTable(name);
	this.symbolCodeMap = new HashMap<String, Integer>();
	this.codeSymbolMap = new HashMap<Integer, String>();
	this.symbolValueMap = new HashMap<String, Double>();
	this.valueCounter = -1;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
public void update() throws MaltChainedException {
	// Retrieve the address value 
	final AddressValue arg1 = addressFunction1.getAddressValue();
	final AddressValue arg2 = addressFunction2.getAddressValue();
	if (arg1.getAddress() != null && arg1.getAddressClass() == org.maltparser.core.syntaxgraph.node.DependencyNode.class &&
	    arg2.getAddress() != null && arg2.getAddressClass() == org.maltparser.core.syntaxgraph.node.DependencyNode.class) {
	    DependencyNode node1 = (DependencyNode)arg1.getAddress();
	    DependencyNode node2 = (DependencyNode)arg2.getAddress();
	    try {
	    SymbolTable symbolTable = tableHandler.getSymbolTable(column.getName());
		int head1 = Integer.parseInt(node1.getLabelSymbol(symbolTable));
		int head2 = Integer.parseInt(node2.getLabelSymbol(symbolTable));
		if (!node1.isRoot() && head1 == node2.getIndex()) {
		    featureValue.setIndexCode(table.getSymbolStringToCode("LEFT"));
		    featureValue.setSymbol("LEFT");
		    featureValue.setNullValue(false);
		} else if (!node2.isRoot() && head2 == node1.getIndex()) {
		    featureValue.setIndexCode(table.getSymbolStringToCode("RIGHT"));
		    featureValue.setSymbol("RIGHT");
		    featureValue.setNullValue(false);			
		} else {
		    featureValue.setIndexCode(table.getNullValueCode(NullValueId.NO_NODE));
		    featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
		    featureValue.setNullValue(true);
		}
	    } catch (NumberFormatException e) {
	    	throw new FeatureException("The index of the feature must be an integer value. ", e);
	    }
	} else {
	    featureValue.setIndexCode(table.getNullValueCode(NullValueId.NO_NODE));
	    featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
	    featureValue.setNullValue(true);
	}
	featureValue.setValue(1);
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
private boolean attachCoveredRoots(DependencyStructure pdg, DependencyNode deepest) throws MaltChainedException {
	int i;
	boolean foundCoveredRoot = false;
	DependencyNode coveredRootHead;
	for (i = Math.min(deepest.getIndex(), deepest.getHead().getIndex()) + 1; i < Math.max(deepest.getIndex(), deepest.getHead()
			.getIndex()); i++) {
		int leftMostIndex = pdg.getDependencyNode(i).getLeftmostProperDescendantIndex();
		if (leftMostIndex == -1) {
			leftMostIndex = i;
		}
		int rightMostIndex = pdg.getDependencyNode(i).getRightmostProperDescendantIndex();
		if (rightMostIndex == -1) {
			rightMostIndex = i;
		}
		if (!nodeLifted.get(i) && pdg.getDependencyNode(i).getHead().isRoot() && !deepest.getHead().isRoot()
				&& Math.min(deepest.getIndex(), deepest.getHead().getIndex()) < leftMostIndex
				&& rightMostIndex < Math.max(deepest.getIndex(), deepest.getHead().getIndex())) {
			if (rootAttachment == CoveredRootAttachment.LEFT) {
				if (deepest.getHead().getIndex() < deepest.getIndex()) {
					coveredRootHead = deepest.getHead();
				} else {
					coveredRootHead = deepest;
				}
			} else if (rootAttachment == CoveredRootAttachment.RIGHT) {
				if (deepest.getIndex() < deepest.getHead().getIndex()) {
					coveredRootHead = deepest.getHead();
				} else {
					coveredRootHead = deepest;
				}
			} else {
				coveredRootHead = deepest.getHead();
			}
			pdg.moveDependencyEdge(coveredRootHead.getIndex(), pdg.getDependencyNode(i).getIndex());
			setCoveredRoot(pdg.getDependencyNode(i));
			foundCoveredRoot = true;
		}
	}
	return foundCoveredRoot;
}
 

import org.maltparser.core.exception.MaltChainedException; //导入依赖的package包/类
private void initialize() throws MaltChainedException {
	if (OptionManager.instance().getOptionDescriptions().getOptionGroupNameSet().size() > 0) {
		return; // OptionManager is already initialized
	}
	OptionManager.instance().loadOptionDescriptionFile();
	OptionManager.instance().generateMaps();
}