import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
@SuppressWarnings({"unchecked"})
private void addXPath(Expression compiledExpr) throws SAXPathException{
    expressions.add(compiledExpr);

    switch(compiledExpr.scope()){
        case Scope.DOCUMENT:
            searchDocExpressions(compiledExpr, compiledExpr);
            break;
        case Scope.GLOBAL:
            assert compiledExpr instanceof Literal;
            globalExpressions.add(compiledExpr);
            break;
        default:
            throw new ImpossibleException("scope of "+compiledExpr.getXPath()+" can't be"+compiledExpr.scope());
    }
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
@Override
public void startNameStep(int axis, String prefix, String localName) throws SAXPathException{
    Constraint constraint;

    boolean star = localName.equals("*");
    if(star && prefix.length()==0)
        constraint = Star.INSTANCE;
    else{
        String uri = !allowDefaultPrefixMapping && prefix.length()==0 ? "" : nsContext.getNamespaceURI(prefix);
        if(uri==null)
            throw new SAXPathException("undeclared prefix: " + prefix);
        if(star)
            constraint = namespaceURIStub.get(uri);
        else{
            if("*".equals(uri))
                constraint = localNameStub.get(localName);
            else
                constraint = qnameStub.get(uri, localName);
        }
    }
    startStep(axis, constraint);
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
@Override
public void endFunction() throws SAXPathException{
    ArrayDeque params = popFrame();
    javax.xml.namespace.QName name = (javax.xml.namespace.QName)params.pollFirst();
    if(name.getNamespaceURI().length()==0)
        push(createFunction(name.getLocalPart(), params).simplify());
    else{
        int noOfParams = params.size();
        XPathFunction function = functionResolver.resolveFunction(name, noOfParams);
        if(function==null)
            throw new SAXPathException("Unknown Function: "+name);
        FunctionCall functionCall = new FunctionCall(new Functions.UserFunction(name.getNamespaceURI(), name.getLocalPart(), function), noOfParams);
        for(int i=0; i<noOfParams; i++)
            functionCall.addMember(params.pollFirst(), i);
        push(functionCall);
    }
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
/** Create an <code>XPathReader</code> using the value of
 *  the <code>org.saxpath.driver</code> system property.
 *
 *  @return an instance of the <code>XPathReader</code> specified
 *          by the <code>org.saxpath.driver</code> property
 *
 *  @throws SAXPathException if the property is  not set, or if
 *          the class can not be instantiated for some reason,
 *          or if the class doesn't implement the <code>XPathReader</code>
 *          interface
 */
public static XPathReader createReader() throws SAXPathException
{
    String className = null;

    try
    {
        className = System.getProperty( DRIVER_PROPERTY );
    }
    catch (SecurityException e)
    {
        // we'll use the default
    }

    if ( className == null
         ||
         className.length() == 0 )
    {
        className = DEFAULT_DRIVER;
    }

    return createReader( className );
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
public void parse(String xpath) throws SAXPathException
{
    setUpParse( xpath );

    getXPathHandler().startXPath();

    expr();

    getXPathHandler().endXPath();

    if ( LA(1) != TokenTypes.EOF )
    {
        XPathSyntaxException ex = createSyntaxException( "Unexpected '" + LT(1).getTokenText() + "'" );
        throw ex;
    }

    lexer  = null;
    tokens = null;
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
private void variableReference() throws SAXPathException
{
    match( TokenTypes.DOLLAR );

    String prefix       = null;
    String variableName = null;

    if ( LA(2) == TokenTypes.COLON )
    {
        prefix = match( TokenTypes.IDENTIFIER ).getTokenText();
        match( TokenTypes.COLON );
    }
    else
    {
        prefix = "";
    }

    variableName = match( TokenTypes.IDENTIFIER ).getTokenText();

    getXPathHandler().variableReference( prefix,
                                         variableName );
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
private void relativeLocationPath() throws SAXPathException
{
    getXPathHandler().startRelativeLocationPath();

    switch ( LA(1) )
    {
        case TokenTypes.SLASH:
        {
            match( TokenTypes.SLASH );
            break;
        }
        case TokenTypes.DOUBLE_SLASH:
        {
            getXPathHandler().startAllNodeStep( Axis.DESCENDANT_OR_SELF );
            getXPathHandler().endAllNodeStep();

            match( TokenTypes.DOUBLE_SLASH );

            break;
        }
    }

    steps();

    getXPathHandler().endRelativeLocationPath();
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
private void abbrStep() throws SAXPathException
{
    switch ( LA(1) )
    {
        case TokenTypes.DOT:
        {
            match( TokenTypes.DOT );
            getXPathHandler().startAllNodeStep( Axis.SELF );
            predicates();
            getXPathHandler().endAllNodeStep();
            break;
        }
        case TokenTypes.DOT_DOT:
        {
            match( TokenTypes.DOT_DOT );
            getXPathHandler().startAllNodeStep( Axis.PARENT );
            predicates();
            getXPathHandler().endAllNodeStep();
            break;
        }
    }
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
private void orExpr() throws SAXPathException
{
    getXPathHandler().startOrExpr();
    
    andExpr();

    boolean create = false;

    switch ( LA(1) )
    {
        case TokenTypes.OR:
        {
            create = true;
            match( TokenTypes.OR );
            orExpr();
            break;
        }
    }

    getXPathHandler().endOrExpr( create );
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
private void andExpr() throws SAXPathException
{
    getXPathHandler().startAndExpr();

    equalityExpr();

    boolean create = false;

    switch ( LA(1) )
    {
        case TokenTypes.AND:
        {
            create = true;
            match( TokenTypes.AND );
            andExpr();
            break;
        }
    }

    getXPathHandler().endAndExpr( create );
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
private void unaryExpr() throws SAXPathException
{
    switch ( LA(1) )
    {
        case TokenTypes.MINUS:
        {
            getXPathHandler().startUnaryExpr();
            match( TokenTypes.MINUS );
            unaryExpr();
            getXPathHandler().endUnaryExpr( Operator.NEGATIVE );
            break;
        }
        default:
        {
            unionExpr();
            break;
        }
    }

    
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
private void unionExpr() throws SAXPathException
{
    getXPathHandler().startUnionExpr();

    pathExpr();

    boolean create = false;

    switch ( LA(1) )
    {
        case TokenTypes.PIPE:
        {
            match( TokenTypes.PIPE );
            create = true;
            expr();
            break;
        }
    }

    getXPathHandler().endUnionExpr( create );
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
protected void testPriority(String expr, double priority, short nodeType) 
 throws JaxenException, SAXPathException  
{
    
    Pattern pattern = PatternParser.parse( expr );
    double d = pattern.getPriority();
    short nt = pattern.getMatchType();
    
    assertEquals( "expr: " + expr,
                  new Double( priority ),
                  new Double( d ) );

    assertEquals( "nodeType: " + expr,
                  nodeType, 
                  nt );
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
public void testBogusPaths() throws SAXPathException
{

    for( int i = 0; i < bogusPaths.length; ++i )
    {
        final String[] bogusPath = bogusPaths[i];

        try
        {
            reader.parse( bogusPath[0] );
            fail( "Should have thrown XPathSyntaxException for " + bogusPath[0]);
        }
        catch( XPathSyntaxException e )
        {
            assertEquals( bogusPath[1], e.getMessage() );
        }
    }
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
static Query getPathQuery(String path) throws SAXPathException
{
    ApplicationContext ac = ApplicationContextHelper.getApplicationContext();
    XPathReader reader = new XPathReader();
    LuceneXPathHandler handler = new LuceneXPathHandler();
    handler.setNamespacePrefixResolver((NamespaceService) ac.getBean("namespaceService"));
    handler.setDictionaryService((DictionaryService) ac.getBean("dictionaryService"));
    reader.setXPathHandler(handler);
    reader.parse(path);
    PathQuery pathQuery = handler.getQuery();
    pathQuery.setRepeats(false);
    return pathQuery;
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
/**
 * @param args String[]
 * @throws SAXPathException
 */
public static void main(String[] args) throws SAXPathException
{
    XPathReader reader = new XPathReader();
    reader.setXPathHandler(new DebugXPathHandler());
    reader
            .parse("/ns:one[@woof='dog']/two/./../two[functionTest(@a, @b, $woof:woof)]/three/*/four//*/five/six[@exists1 and @exists2]");
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
public CachedVariableContext(Collection<Variable> variables, XPath xpath, XmlElement contextNode) throws SAXPathException {
    for (Variable variable : variables) {
        if (variable.getName().length() == 0) {
            continue;
        } 
        final String expression = variable.getExpression();
        // empty expression evaluates to empty nodeset
        final XPath xPath = xpath.getNavigator().parseXPath(expression.length() == 0 ? "/.." : expression);
        myMap.put(variable.getName(), xPath.evaluate(contextNode));
    }
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
public Expression addForEach(String forEach, String xpath) throws SAXPathException{
    Expression forEachExpr = parser.parse(forEach, true);
    LocationPath union = new LocationPath(Scope.LOCAL, 0);
    if(forEachExpr instanceof LocationExpression)
        union.addToContext(((LocationExpression)forEachExpr).locationPath);
    else
        union.addToContext(((PathExpression)forEachExpr).union);

    Expression relativeExpr = parser.parse(xpath, false);
    PathExpression compiledExpr = new PathExpression(union, relativeExpr, true);
    compiledExpr.setXPath("#for-each "+forEach+" #eval "+xpath);
    addXPath(compiledExpr);
    return compiledExpr;
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
public Expression parse(String xpath, boolean documentContext) throws SAXPathException{
    this.documentContext = documentContext; 
    frames.clear();
    peekFrame = null;
    stepStack.clear();
    predicateDepth = 0;
    expr = null;

    reader.parse(xpath);
    return expr;
}
 

import org.jaxen.saxpath.SAXPathException; //导入依赖的package包/类
@Override
public void startFunction(String prefix, String name) throws SAXPathException{
    String uri = prefix.length()==0 ? "": nsContext.getNamespaceURI(prefix);
    if(uri==null)
        throw new SAXPathException("undeclared prefix: " + prefix);

    if(uri.length()>0 && functionResolver==null)
        throw new SAXPathException("FunctionResolver is required");
    
    pushFrame();
    push(new javax.xml.namespace.QName(uri, name));
}