import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public static XPathPathExpr getPathExpr (String nodeset) {
	XPathExpression path;
	boolean validNonPathExpr = false;

	try {
	path = XPathParseTool.parseXPath(nodeset);
	if (!(path instanceof XPathPathExpr)) {
		validNonPathExpr = true;
		throw new XPathSyntaxException();
	}

	} catch (XPathSyntaxException xse) {
		//make these checked exceptions?
		if (validNonPathExpr) {
			throw new XPathTypeMismatchException("Expected XPath path, got XPath expression: [" + nodeset + "]," + xse.getMessage());
		} else {
			xse.printStackTrace();
			throw new XPathException("Parse error in XPath path: [" + nodeset + "]." + (xse.getMessage() == null ? "" : "\n" + xse.getMessage()));
		}
	}

	return (XPathPathExpr)path;
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
private void testXPathValid (String expr, String expected) {
	//debug
	//System.out.println("+[ " + expr + " ]");
	
	try {
		XPathExpression xpe = XPathParseTool.parseXPath(expr);
		String result = (xpe != null ? xpe.toString() : null);
		
		//debug
		//System.out.println("[ " + result + " ]");
		
		if (result == null || !result.equals(expected)) {
			fail("XPath Parse Failed! Incorrect parse tree." +
						"\n    expression:[" + expr + "]" +
						"\n    expected:[" + expected + "]" +
						"\n    result:[" + result + "]");
		}
		
		//test serialization of parse tree
		ExternalizableTest.testExternalizable(new ExtWrapTagged(xpe), new ExtWrapTagged(), pf, this, "XPath");
	} catch (XPathSyntaxException xse) {
		fail("XPath Parse Failed! Unexpected syntax error." + 
					"\n    expression:[" + expr + "]");
	}
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public static XPathPathExpr getPathExpr(String nodeset) {
    XPathExpression path;
    boolean validNonPathExpr = false;

    try {
        path = XPathParseTool.parseXPath(nodeset);
        if (!(path instanceof XPathPathExpr)) {
            validNonPathExpr = true;
            throw new XPathSyntaxException();
        }

    } catch (XPathSyntaxException xse) {
        //make these checked exceptions?
        if (validNonPathExpr) {
            throw new XPathTypeMismatchException("Expected XPath path, got XPath expression: [" + nodeset + "]," + xse.getMessage());
        } else {
            xse.printStackTrace();
            throw new XPathException("Parse error in XPath path: [" + nodeset + "]." + (xse.getMessage() == null ? "" : "\n" + xse.getMessage()));
        }
    }

    return (XPathPathExpr)path;
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
private static void testXPathValid(String expr, String expected) {
    try {
        XPathExpression xpe = XPathParseTool.parseXPath(expr);
        String result = (xpe != null ? xpe.toString() : null);

        if (result == null || !result.equals(expected)) {
            fail("XPath Parse Failed! Incorrect parse tree." +
                    "\n    expression:[" + expr + "]" +
                    "\n    expected:[" + expected + "]" +
                    "\n    result:[" + result + "]");
        }

        //test serialization of parse tree
        ExternalizableTest.testExternalizable(new ExtWrapTagged(xpe), new ExtWrapTagged(), pf, "XPath");
    } catch (XPathSyntaxException xse) {
        fail("XPath Parse Failed! Unexpected syntax error." +
                "\n    expression:[" + expr + "]");
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public OrderedHashtable<String, XPathExpression> getVariableDeclarations() {
    if (variablesCompiled == null) {
        variablesCompiled = new OrderedHashtable<String, XPathExpression>();
        for (Enumeration en = variables.keys(); en.hasMoreElements(); ) {
            String key = (String)en.nextElement();
            //TODO: This is stupid, parse this stuff at XML Parse time.
            try {
                variablesCompiled.put(key, XPathParseTool.parseXPath(variables.get(key)));
            } catch (XPathSyntaxException e) {
                e.printStackTrace();
                throw new RuntimeException(e.getMessage());
            }
        }
    }
    return variablesCompiled;
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
@Override
public CalloutData evaluate(EvaluationContext context) {
    Hashtable<String, String> evaluatedExtras = new Hashtable<String, String>();

    Enumeration keys = extras.keys();

    while (keys.hasMoreElements()) {
        String key = (String)keys.nextElement();
        try {
            String evaluatedKey = XPathFuncExpr.toString(XPathParseTool.parseXPath(extras.get(key)).eval(context));
            evaluatedExtras.put(key, evaluatedKey);
        } catch (XPathSyntaxException e) {
            // do nothing
        }
    }

    // emit a CalloutData with the extras evaluated. used for the detail screen.
    return new CalloutData(actionName, image, displayName, evaluatedExtras, responses, type);
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public Text getAssertionFailure(EvaluationContext ec) {
    try {
        for (int i = 0; i < xpathExpressions.size(); ++i) {
            XPathExpression expression = XPathParseTool.parseXPath(xpathExpressions.elementAt(i));
            try {
                Object val = expression.eval(ec);
                if (!XPathFuncExpr.toBoolean(val).booleanValue()) {
                    return messages.elementAt(i);
                }
            } catch (Exception e) {
                return messages.elementAt(i);
            }
        }
        return null;
    } catch (XPathSyntaxException xpe) {
        throw new XPathException("Assertion somehow failed to parse after validating : " + xpe.getMessage());
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
/**
 * Get a performed step to pass on to an actual frame
 *
 * @param ec Context to evaluate any parameters with
 * @return A step that can be added to a session frame
 */
public StackFrameStep defineStep(EvaluationContext ec) {
    String finalValue;
    if (!valueIsXpath) {
        finalValue = value;
    } else {
        try {
            finalValue = XPathFuncExpr.toString(XPathParseTool.parseXPath(value).eval(ec));
        } catch (XPathSyntaxException e) {
            //This error makes no sense, since we parse the input for
            //validation when we create it!
            throw new XPathException(e.getMessage());
        }
    }

    //figure out how to structure the step
    if (elementType.equals(SessionFrame.STATE_DATUM_VAL)) {
        return new StackFrameStep(SessionFrame.STATE_DATUM_VAL, id, finalValue);
    } else if (elementType.equals(SessionFrame.STATE_COMMAND_ID)) {
        return new StackFrameStep(SessionFrame.STATE_COMMAND_ID, finalValue, null);
    } else if (elementType.equals(SessionFrame.STATE_FORM_XMLNS)) {
        throw new RuntimeException("Form Definitions in Steps are not yet supported!");
    } else {
        throw new RuntimeException("Invalid step [" + elementType + "] declared when constructing a new frame step");
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public void setComputedDatum(EvaluationContext ec) throws XPathException {
    SessionDatum datum = getNeededDatum();
    XPathExpression form;
    try {
        form = XPathParseTool.parseXPath(datum.getValue());
    } catch (XPathSyntaxException e) {
        e.printStackTrace();
        throw new RuntimeException(e.getMessage());
    }
    if (datum instanceof FormIdDatum) {
        setXmlns(XPathFuncExpr.toString(form.eval(ec)));
        setDatum("", "awful");
    } else if (datum instanceof ComputedDatum) {
        setDatum(datum.getDataId(), XPathFuncExpr.toString(form.eval(ec)));
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public OrderedHashtable<String, XPathExpression> getVariableDeclarations() {
    if (variablesCompiled == null) {
        variablesCompiled = new OrderedHashtable<>();
        for (Enumeration en = variables.keys(); en.hasMoreElements(); ) {
            String key = (String)en.nextElement();
            //TODO: This is stupid, parse this stuff at XML Parse time.
            try {
                variablesCompiled.put(key, XPathParseTool.parseXPath(variables.get(key)));
            } catch (XPathSyntaxException e) {
                e.printStackTrace();
                throw new RuntimeException(e.getMessage());
            }
        }
    }
    return variablesCompiled;
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
@Override
public CalloutData evaluate(EvaluationContext context) {
    Hashtable<String, String> evaluatedExtras = new Hashtable<>();
    Enumeration keys = extras.keys();
    while (keys.hasMoreElements()) {
        String key = (String)keys.nextElement();
        boolean overridePlainTextAssumption = key.startsWith(OVERRIDE_PLAIN_TEXT_ASSUMPTION_PREFIX);
        key = key.replace(OVERRIDE_PLAIN_TEXT_ASSUMPTION_PREFIX, "");
        String rawValue = extras.get(key);

        if (assumePlainTextValues && !overridePlainTextAssumption) {
            evaluatedExtras.put(key, rawValue);
        } else {
            try {
                String evaluatedValue =
                        FunctionUtils.toString(XPathParseTool.parseXPath(rawValue).eval(context));
                evaluatedExtras.put(key, evaluatedValue);
            } catch (XPathSyntaxException e) {
                // do nothing
            }
        }
    }

    // emit a CalloutData with the extras evaluated. used for the detail screen.
    return new CalloutData(actionName, image, displayName, evaluatedExtras, responses, type);
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public Text getAssertionFailure(EvaluationContext ec) {
    try {
        for (int i = 0; i < xpathExpressions.size(); ++i) {
            XPathExpression expression = XPathParseTool.parseXPath(xpathExpressions.elementAt(i));
            try {
                Object val = expression.eval(ec);
                if (!FunctionUtils.toBoolean(val)) {
                    return messages.elementAt(i);
                }
            } catch (Exception e) {
                return messages.elementAt(i);
            }
        }
        return null;
    } catch (XPathSyntaxException xpe) {
        throw new XPathException("Assertion somehow failed to parse after validating : " + xpe.getMessage());
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public void setComputedDatum(EvaluationContext ec) throws XPathException {
    SessionDatum datum = getNeededDatum();
    XPathExpression form;
    try {
        form = XPathParseTool.parseXPath(datum.getValue());
    } catch (XPathSyntaxException e) {
        e.printStackTrace();
        throw new RuntimeException(e.getMessage());
    }
    if (datum instanceof FormIdDatum) {
        setXmlns(FunctionUtils.toString(form.eval(ec)));
        setDatum("", "awful");
    } else if (datum instanceof ComputedDatum) {
        setDatum(datum.getDataId(), FunctionUtils.toString(form.eval(ec)));
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
@Test
public void testInstanceAccumulatingAnalyzer() throws XPathSyntaxException {
    testInstanceAnalysis(NO_INSTANCES_EXPR,
            new String[]{});
    testInstanceAnalysis(ONE_INSTANCE_EXPR,
            new String[]{"casedb"});
    testInstanceAnalysis(DUPLICATED_INSTANCE_EXPR,
            new String[]{"commcaresession"});
    testInstanceAnalysis(EXPR_WITH_INSTANCE_IN_PREDICATE,
            new String[]{"casedb", "commcaresession"});
    testInstanceAnalysis(RIDICULOUS_RELEVANCY_CONDITION_FROM_REAL_APP,
            new String[]{"casedb", "commcaresession", "schedule:m5:p2:f2"});

    // Test the length of the result with list accumulation, just to ensure it gets them all
    List<String> parsedInstancesList =
            (new InstanceNameAccumulatingAnalyzer()).accumulateAsList(
                    XPathParseTool.parseXPath(RIDICULOUS_RELEVANCY_CONDITION_FROM_REAL_APP));
    Assert.assertEquals(27, parsedInstancesList.size());
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
private void testInstanceAnalysis(String expressionString, String[] expectedInstances,
                                  String baseContextString)
        throws XPathSyntaxException {

    InstanceNameAccumulatingAnalyzer analyzer;

    if (baseContextString != null) {
        TreeReference baseContextRef =
                ((XPathPathExpr)XPathParseTool.parseXPath(baseContextString)).getReference();
        analyzer = new InstanceNameAccumulatingAnalyzer(baseContextRef);
    } else {
        analyzer = new InstanceNameAccumulatingAnalyzer();
    }

    Set<String> expectedInstancesSet = null;
    if (expectedInstances != null) {
        expectedInstancesSet = new HashSet<>();
        for (String s : expectedInstances) {
            expectedInstancesSet.add(s);
        }
    }

    Set<String> parsedInstancesSet =
            analyzer.accumulate(XPathParseTool.parseXPath(expressionString));
    Assert.assertEquals(expectedInstancesSet, parsedInstancesSet);
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
private static void testXPathValid(String expr, String expected) {
    try {
        XPathExpression xpe = XPathParseTool.parseXPath(expr);
        String result = (xpe != null ? xpe.toString() : null);

        if (result == null || !result.equals(expected)) {
            fail("XPath Parse Failed! Incorrect parse tree." +
                    "\n    expression:[" + expr + "]" +
                    "\n    expected:[" + expected + "]" +
                    "\n    result:  [" + result + "]");
        }

        //test serialization of parse tree
        ExternalizableTest.testExternalizable(new ExtWrapTagged(xpe), new ExtWrapTagged(), new LivePrototypeFactory(), "XPath");
    } catch (XPathSyntaxException xse) {
        fail("XPath Parse Failed! Unexpected syntax error." +
                "\n    expression:[" + expr + "]");
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public static XPathFuncExpr getSearchXPathExpression(String appearance) {
    if (appearance == null) {
        appearance = "";
    }
    appearance = appearance.trim();

    Matcher matcher = SEARCH_FUNCTION_REGEX.matcher(appearance);
    if (matcher.find()) {
        String function = matcher.group(0);
        try {
            XPathExpression xPathExpression = XPathParseTool.parseXPath(function);
            if (XPathFuncExpr.class.isAssignableFrom(xPathExpression.getClass())) {
                XPathFuncExpr xPathFuncExpr = (XPathFuncExpr) xPathExpression;
                if (xPathFuncExpr.id.name.equalsIgnoreCase(ExternalDataHandlerSearch.HANDLER_NAME)) {
                    // also check that the args are either 1, 4 or 6.
                    if (xPathFuncExpr.args.length == 1 || xPathFuncExpr.args.length == 4 || xPathFuncExpr.args.length == 6) {
                        return xPathFuncExpr;
                    } else {
                        throw new InvalidSyntaxException(Collect.getInstance().getString(R.string.ext_search_wrong_arguments_error));
                    }
                } else {
                    // this might mean a problem in the regex above. Unit tests required.
                    throw new InvalidSyntaxException(Collect.getInstance().getString(R.string.ext_search_wrong_function_error, xPathFuncExpr.id.name));
                }
            } else {
                // this might mean a problem in the regex above. Unit tests required.
                throw new InvalidSyntaxException(Collect.getInstance().getString(R.string.ext_search_bad_function_error, function));
            }
        } catch (XPathSyntaxException e) {
            throw new InvalidSyntaxException(Collect.getInstance().getString(R.string.ext_search_generic_error, appearance), e);
        }
    } else {
        return null;
    }
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
public void registerModule() {
	String[] classes = {
			"org.javarosa.model.xform.XPathReference",
			"org.javarosa.xpath.XPathConditional"
	};
	
	PrototypeManager.registerPrototypes(classes);
	PrototypeManager.registerPrototypes(XPathParseTool.xpathClasses);
	RestoreUtils.xfFact = new IXFormyFactory () {
		public TreeReference ref (String refStr) {
			return FormInstance.unpackReference(new XPathReference(refStr));
		}
		
		public IDataPayload serializeInstance (FormInstance dm) {
			try {
				return (new XFormSerializingVisitor()).createSerializedPayload(dm);
			} catch (IOException e) {
				return null;
			}
		}

		public FormInstance parseRestore(byte[] data, Class restorableType) {
			return XFormParser.restoreDataModel(data, restorableType);
		}
		
		public IAnswerData parseData (String textVal, int dataType, TreeReference ref, FormDef f) {
			return XFormAnswerDataParser.getAnswerData(textVal, dataType, XFormParser.ghettoGetQuestionDef(dataType, f, ref));
		}

		public String serializeData(IAnswerData data) {
			return (String)(new XFormAnswerDataSerializer().serializeAnswerData(data));
		}

		public IConditionExpr refToPathExpr(TreeReference ref) {
			return new XPathConditional(XPathPathExpr.fromRef(ref));
		}
	};
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
private void attemptConstraintCompile() {
	xPathConstraintMsg = null;
	try {
		if(constraintMsg != null) {
			xPathConstraintMsg = XPathParseTool.parseXPath("string(" + constraintMsg + ")");
		}
	} catch(Exception e) {
		//Expected in probably most cases.
	}
}
 

import org.javarosa.xpath.XPathParseTool; //导入依赖的package包/类
private void testXPathInvalid (String expr) {
	//debug
	//System.out.println("+[ " + expr + " ]");
	
	try {
		XPathExpression xpe = XPathParseTool.parseXPath(expr);
		String result = (xpe != null ? xpe.toString() : null);
		
		fail("XPath Parse Failed! Did not get syntax error as expected." + 
					"\n    expression:[" + expr + "]" +
					"\n    result:[" + (result == null ? "(null)" : result) + "]");
	} catch (XPathSyntaxException xse) {
		//success: syntax error as expected
	}
}