FileDocCategorySizeDatePackage
Compiler.javaAPI DocJava SE 6 API38994Tue Jun 10 00:23:14 BST 2008com.sun.org.apache.xpath.internal.compiler

Compiler

public class Compiler extends OpMap
An instance of this class compiles an XPath string expression into a Expression object. This class compiles the string into a sequence of operation codes (op map) and then builds from that into an Expression tree.
xsl.usage
advanced

Fields Summary
private int
locPathDepth
private static final boolean
DEBUG
private static long
s_nextMethodId
private PrefixResolver
m_currentPrefixResolver
The current prefixResolver for the execution context.
ErrorListener
m_errorHandler
The error listener where errors will be sent. If this is null, errors and warnings will be sent to System.err. May be null.
SourceLocator
m_locator
The source locator for the expression being compiled. May be null.
private FunctionTable
m_functionTable
The FunctionTable for all xpath build-in functions
Constructors Summary
public Compiler(ErrorListener errorHandler, SourceLocator locator, FunctionTable fTable)
Construct a Compiler object with a specific ErrorListener and SourceLocator where the expression is located.

param
errorHandler Error listener where messages will be sent, or null if messages should be sent to System err.
param
locator The location object where the expression lives, which may be null, but which, if not null, must be valid over the long haul, in other words, it will not be cloned.
param
fTable The FunctionTable object where the xpath build-in functions are stored.

    m_errorHandler = errorHandler;
    m_locator = locator;
    m_functionTable = fTable;
public Compiler()
Construct a Compiler instance that has a null error listener and a null source locator.

    m_errorHandler = null;
    m_locator = null;
Methods Summary
protected com.sun.org.apache.xpath.internal.Expressionand(int opPos)
Compile an 'and' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.And} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new And(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionarg(int opPos)
Compile a function argument.

param
opPos The current position in the m_opMap array.
return
reference to the argument expression.
throws
TransformerException if a error occurs creating the Expression.


    // no-op
    return compile(opPos + 2);
public voidassertion(boolean b, java.lang.String msg)
Tell the user of an assertion error, and probably throw an exception.

param
b If false, a runtime exception will be thrown.
param
msg The assertion message, which should be informative.
throws
RuntimeException if the b argument is false.


    if (!b)
    {
      java.lang.String fMsg = XSLMessages.createXPATHMessage(
        XPATHErrorResources.ER_INCORRECT_PROGRAMMER_ASSERTION,
        new Object[]{ msg });

      throw new RuntimeException(fMsg);
    }
protected com.sun.org.apache.xpath.internal.Expressionbool(int opPos)
Compile a 'boolean(...)' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Bool} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileUnary(new com.sun.org.apache.xpath.internal.operations.Bool(), opPos);
public com.sun.org.apache.xpath.internal.Expressioncompile(int opPos)
Execute the XPath object from a given opcode position.

param
opPos The current position in the xpath.m_opMap array.
return
The result of the XPath.
throws
TransformerException if there is a syntax or other error.
xsl.usage
advanced


    int op = getOp(opPos);

    Expression expr = null;
    // System.out.println(getPatternString()+"op: "+op);
    switch (op)
    {
    case OpCodes.OP_XPATH :
      expr = compile(opPos + 2); break;
    case OpCodes.OP_OR :
      expr = or(opPos); break;
    case OpCodes.OP_AND :
      expr = and(opPos); break;
    case OpCodes.OP_NOTEQUALS :
      expr = notequals(opPos); break;
    case OpCodes.OP_EQUALS :
      expr = equals(opPos); break;
    case OpCodes.OP_LTE :
      expr = lte(opPos); break;
    case OpCodes.OP_LT :
      expr = lt(opPos); break;
    case OpCodes.OP_GTE :
      expr = gte(opPos); break;
    case OpCodes.OP_GT :
      expr = gt(opPos); break;
    case OpCodes.OP_PLUS :
      expr = plus(opPos); break;
    case OpCodes.OP_MINUS :
      expr = minus(opPos); break;
    case OpCodes.OP_MULT :
      expr = mult(opPos); break;
    case OpCodes.OP_DIV :
      expr = div(opPos); break;
    case OpCodes.OP_MOD :
      expr = mod(opPos); break;
//    case OpCodes.OP_QUO :
//      expr = quo(opPos); break;
    case OpCodes.OP_NEG :
      expr = neg(opPos); break;
    case OpCodes.OP_STRING :
      expr = string(opPos); break;
    case OpCodes.OP_BOOL :
      expr = bool(opPos); break;
    case OpCodes.OP_NUMBER :
      expr = number(opPos); break;
    case OpCodes.OP_UNION :
      expr = union(opPos); break;
    case OpCodes.OP_LITERAL :
      expr = literal(opPos); break;
    case OpCodes.OP_VARIABLE :
      expr = variable(opPos); break;
    case OpCodes.OP_GROUP :
      expr = group(opPos); break;
    case OpCodes.OP_NUMBERLIT :
      expr = numberlit(opPos); break;
    case OpCodes.OP_ARGUMENT :
      expr = arg(opPos); break;
    case OpCodes.OP_EXTFUNCTION :
      expr = compileExtension(opPos); break;
    case OpCodes.OP_FUNCTION :
      expr = compileFunction(opPos); break;
    case OpCodes.OP_LOCATIONPATH :
      expr = locationPath(opPos); break;
    case OpCodes.OP_PREDICATE :
      expr = null; break;  // should never hit this here.
    case OpCodes.OP_MATCHPATTERN :
      expr = matchPattern(opPos + 2); break;
    case OpCodes.OP_LOCATIONPATHPATTERN :
      expr = locationPathPattern(opPos); break;
    case OpCodes.OP_QUO:
      error(XPATHErrorResources.ER_UNKNOWN_OPCODE,
            new Object[]{ "quo" });  //"ERROR! Unknown op code: "+m_opMap[opPos]);
      break;
    default :
      error(XPATHErrorResources.ER_UNKNOWN_OPCODE,
            new Object[]{ Integer.toString(getOp(opPos)) });  //"ERROR! Unknown op code: "+m_opMap[opPos]);
    }
//    if(null != expr)
//      expr.setSourceLocator(m_locator);

    return expr;
private com.sun.org.apache.xpath.internal.ExpressioncompileExtension(int opPos)
Compile an extension function.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.functions.FuncExtFunction} instance.
throws
TransformerException if a error occurs creating the Expression.


    int endExtFunc = opPos + getOp(opPos + 1) - 1;

    opPos = getFirstChildPos(opPos);

    java.lang.String ns = (java.lang.String) getTokenQueue().elementAt(getOp(opPos));

    opPos++;

    java.lang.String funcName =
      (java.lang.String) getTokenQueue().elementAt(getOp(opPos));

    opPos++;

    // We create a method key to uniquely identify this function so that we
    // can cache the object needed to invoke it.  This way, we only pay the
    // reflection overhead on the first call.

    Function extension = new FuncExtFunction(ns, funcName, String.valueOf(getNextMethodId()));

    try
    {
      int i = 0;

      while (opPos < endExtFunc)
      {
        int nextOpPos = getNextOpPos(opPos);

        extension.setArg(this.compile(opPos), i);

        opPos = nextOpPos;

        i++;
      }
    }
    catch (WrongNumberArgsException wnae)
    {
      ;  // should never happen
    }

    return extension;
com.sun.org.apache.xpath.internal.ExpressioncompileFunction(int opPos)
Compile a built-in XPath function.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.functions.Function} instance.
throws
TransformerException if a error occurs creating the Expression.


    int endFunc = opPos + getOp(opPos + 1) - 1;

    opPos = getFirstChildPos(opPos);

    int funcID = getOp(opPos);

    opPos++;

    if (-1 != funcID)
    {
      Function func = m_functionTable.getFunction(funcID);
      
      /**
       * It is a trick for function-available. Since the function table is an
       * instance field, insert this table at compilation time for later usage
       */
      
      if (func instanceof FuncExtFunctionAvailable)
          ((FuncExtFunctionAvailable) func).setFunctionTable(m_functionTable);

      func.postCompileStep(this);
      
      try
      {
        int i = 0;

        for (int p = opPos; p < endFunc; p = getNextOpPos(p), i++)
        {

          // System.out.println("argPos: "+ p);
          // System.out.println("argCode: "+ m_opMap[p]);
          func.setArg(compile(p), i);
        }

        func.checkNumberArgs(i);
      }
      catch (WrongNumberArgsException wnae)
      {
        java.lang.String name = m_functionTable.getFunctionName(funcID);

        m_errorHandler.fatalError( new TransformerException(
                  XSLMessages.createXPATHMessage(XPATHErrorResources.ER_ONLY_ALLOWS, 
                      new Object[]{name, wnae.getMessage()}), m_locator)); 
              //"name + " only allows " + wnae.getMessage() + " arguments", m_locator));
      }

      return func;
    }
    else
    {
      error(XPATHErrorResources.ER_FUNCTION_TOKEN_NOT_FOUND, null);  //"function token not found.");

      return null;
    }
private com.sun.org.apache.xpath.internal.ExpressioncompileOperation(com.sun.org.apache.xpath.internal.operations.Operation operation, int opPos)
Bottle-neck compilation of an operation with left and right operands.

param
operation non-null reference to parent operation.
param
opPos The op map position of the parent operation.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Operation} instance.
throws
TransformerException if there is a syntax or other error.


    int leftPos = getFirstChildPos(opPos);
    int rightPos = getNextOpPos(leftPos);

    operation.setLeftRight(compile(leftPos), compile(rightPos));

    return operation;
private voidcompilePredicates(int opPos, com.sun.org.apache.xpath.internal.Expression[] predicates)
Compiles predicates in the step.

param
opPos The position of the first predicate the m_opMap array.
param
predicates An empty pre-determined array of {@link com.sun.org.apache.xpath.internal.Expression}s, that will be filled in.
throws
TransformerException


    for (int i = 0; OpCodes.OP_PREDICATE == getOp(opPos); i++)
    {
      predicates[i] = predicate(opPos);
      opPos = getNextOpPos(opPos);
    }
private com.sun.org.apache.xpath.internal.ExpressioncompileUnary(com.sun.org.apache.xpath.internal.operations.UnaryOperation unary, int opPos)
Bottle-neck compilation of a unary operation.

param
unary The parent unary operation.
param
opPos The position in the op map of the parent operation.
return
The unary argument.
throws
TransformerException if syntax or other error occurs.


    int rightPos = getFirstChildPos(opPos);

    unary.setRight(compile(rightPos));

    return unary;
public intcountPredicates(int opPos)
Count the number of predicates in the step.

param
opPos The position of the first predicate the m_opMap array.
return
The number of predicates for this step.
throws
TransformerException if a error occurs creating the Expression.


    int count = 0;

    while (OpCodes.OP_PREDICATE == getOp(opPos))
    {
      count++;

      opPos = getNextOpPos(opPos);
    }

    return count;
protected com.sun.org.apache.xpath.internal.Expressiondiv(int opPos)
Compile a 'div' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Div} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Div(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionequals(int opPos)
Compile a '=' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Equals} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Equals(), opPos);
public voiderror(java.lang.String msg, java.lang.Object[] args)
Tell the user of an error, and probably throw an exception.

param
msg An error msgkey that corresponds to one of the constants found in {@link com.sun.org.apache.xpath.internal.res.XPATHErrorResources}, which is a key for a format string.
param
args An array of arguments represented in the format string, which may be null.
throws
TransformerException if the current ErrorListoner determines to throw an exception.


    java.lang.String fmsg = XSLMessages.createXPATHMessage(msg, args);
    

    if (null != m_errorHandler)
    {
      m_errorHandler.fatalError(new TransformerException(fmsg, m_locator));
    }
    else
    {

      // System.out.println(te.getMessage()
      //                    +"; file "+te.getSystemId()
      //                    +"; line "+te.getLineNumber()
      //                    +"; column "+te.getColumnNumber());
      throw new TransformerException(fmsg, (SAXSourceLocator)m_locator);
    }
public com.sun.org.apache.xpath.internal.Expression[]getCompiledPredicates(int opPos)
Compile a zero or more predicates for a given match pattern.

param
opPos The position of the first predicate the m_opMap array.
return
reference to array of {@link com.sun.org.apache.xpath.internal.Expression} instances.
throws
TransformerException if a error occurs creating the Expression.


    int count = countPredicates(opPos);

    if (count > 0)
    {
      Expression[] predicates = new Expression[count];

      compilePredicates(opPos, predicates);

      return predicates;
    }

    return null;
com.sun.org.apache.xpath.internal.compiler.FunctionTablegetFunctionTable()
Get the function table

    return m_functionTable;
public intgetLocationPathDepth()
Get the level of the location path or union being constructed.

return
0 if it is a top-level path.

  
                          
    
  
    return locPathDepth;
public com.sun.org.apache.xml.internal.utils.PrefixResolvergetNamespaceContext()
Get the current namespace context for the xpath.

return
The current prefix resolver, *may* be null, though hopefully not.


                        
    
  
    return m_currentPrefixResolver;
private synchronized longgetNextMethodId()
Get the next available method id


           
     
  
    if (s_nextMethodId == Long.MAX_VALUE)
      s_nextMethodId = 0;
    
    return s_nextMethodId++;
public intgetWhatToShow(int opPos)
Get a {@link org.w3c.dom.traversal.NodeFilter} bit set that tells what to show for a given node test.

param
opPos the op map position for the location step.
return
{@link org.w3c.dom.traversal.NodeFilter} bit set that tells what to show for a given node test.


    int axesType = getOp(opPos);
    int testType = getOp(opPos + 3);

    // System.out.println("testType: "+testType);
    switch (testType)
    {
    case OpCodes.NODETYPE_COMMENT :
      return DTMFilter.SHOW_COMMENT;
    case OpCodes.NODETYPE_TEXT :
//      return DTMFilter.SHOW_TEXT | DTMFilter.SHOW_COMMENT;
      return DTMFilter.SHOW_TEXT | DTMFilter.SHOW_CDATA_SECTION ;
    case OpCodes.NODETYPE_PI :
      return DTMFilter.SHOW_PROCESSING_INSTRUCTION;
    case OpCodes.NODETYPE_NODE :
//      return DTMFilter.SHOW_ALL;
      switch (axesType)
      {
      case OpCodes.FROM_NAMESPACE:
        return DTMFilter.SHOW_NAMESPACE;
      case OpCodes.FROM_ATTRIBUTES :
      case OpCodes.MATCH_ATTRIBUTE :
        return DTMFilter.SHOW_ATTRIBUTE;
      case OpCodes.FROM_SELF:
      case OpCodes.FROM_ANCESTORS_OR_SELF:
      case OpCodes.FROM_DESCENDANTS_OR_SELF:
        return DTMFilter.SHOW_ALL;
      default:
        if (getOp(0) == OpCodes.OP_MATCHPATTERN)
          return ~DTMFilter.SHOW_ATTRIBUTE
                  & ~DTMFilter.SHOW_DOCUMENT
                  & ~DTMFilter.SHOW_DOCUMENT_FRAGMENT;
        else
          return ~DTMFilter.SHOW_ATTRIBUTE;
      }
    case OpCodes.NODETYPE_ROOT :
      return DTMFilter.SHOW_DOCUMENT | DTMFilter.SHOW_DOCUMENT_FRAGMENT;
    case OpCodes.NODETYPE_FUNCTEST :
      return NodeTest.SHOW_BYFUNCTION;
    case OpCodes.NODENAME :
      switch (axesType)
      {
      case OpCodes.FROM_NAMESPACE :
        return DTMFilter.SHOW_NAMESPACE;
      case OpCodes.FROM_ATTRIBUTES :
      case OpCodes.MATCH_ATTRIBUTE :
        return DTMFilter.SHOW_ATTRIBUTE;

      // break;
      case OpCodes.MATCH_ANY_ANCESTOR :
      case OpCodes.MATCH_IMMEDIATE_ANCESTOR :
        return DTMFilter.SHOW_ELEMENT;

      // break;
      default :
        return DTMFilter.SHOW_ELEMENT;
      }
    default :
      // System.err.println("We should never reach here.");
      return DTMFilter.SHOW_ALL;
    }
protected com.sun.org.apache.xpath.internal.Expressiongroup(int opPos)
Compile an expression group.

param
opPos The current position in the m_opMap array.
return
reference to the contained expression.
throws
TransformerException if a error occurs creating the Expression.


    // no-op
    return compile(opPos + 2);
protected com.sun.org.apache.xpath.internal.Expressiongt(int opPos)
Compile a '>' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Gt} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Gt(), opPos);
protected com.sun.org.apache.xpath.internal.Expressiongte(int opPos)
Compile a '>=' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Gte} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Gte(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionliteral(int opPos)
Compile a literal string value.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.objects.XString} instance.
throws
TransformerException if a error occurs creating the Expression.


    opPos = getFirstChildPos(opPos);

    return (XString) getTokenQueue().elementAt(getOp(opPos));
public com.sun.org.apache.xpath.internal.ExpressionlocationPath(int opPos)
Compile a location path. The LocPathIterator itself may create {@link com.sun.org.apache.xpath.internal.axes.AxesWalker} children.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.axes.LocPathIterator} instance.
throws
TransformerException if a error occurs creating the Expression.

    locPathDepth++;
    try
    {
      DTMIterator iter = WalkerFactory.newDTMIterator(this, opPos, (locPathDepth == 0));
      return (Expression)iter; // cast OK, I guess.
    }
    finally
    {
      locPathDepth--;
    }
public com.sun.org.apache.xpath.internal.ExpressionlocationPathPattern(int opPos)
Compile a location match pattern unit expression.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.patterns.StepPattern} instance.
throws
TransformerException if a error occurs creating the Expression.


    opPos = getFirstChildPos(opPos);

    return stepPattern(opPos, 0, null);
protected com.sun.org.apache.xpath.internal.Expressionlt(int opPos)
Compile a '<' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Lt} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Lt(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionlte(int opPos)
Compile a '<=' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Lte} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Lte(), opPos);
protected com.sun.org.apache.xpath.internal.ExpressionmatchPattern(int opPos)
Compile an entire match pattern expression.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.patterns.UnionPattern} instance.
throws
TransformerException if a error occurs creating the Expression.

    locPathDepth++;
    try
    {
      // First, count...
      int nextOpPos = opPos;
      int i;

      for (i = 0; getOp(nextOpPos) == OpCodes.OP_LOCATIONPATHPATTERN; i++)
      {
        nextOpPos = getNextOpPos(nextOpPos);
      }

      if (i == 1)
        return compile(opPos);

      UnionPattern up = new UnionPattern();
      StepPattern[] patterns = new StepPattern[i];

      for (i = 0; getOp(opPos) == OpCodes.OP_LOCATIONPATHPATTERN; i++)
      {
        nextOpPos = getNextOpPos(opPos);
        patterns[i] = (StepPattern) compile(opPos);
        opPos = nextOpPos;
      }

      up.setPatterns(patterns);

      return up;
    }
    finally
    {
      locPathDepth--;
    }
protected com.sun.org.apache.xpath.internal.Expressionminus(int opPos)
Compile a '-' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Minus} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Minus(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionmod(int opPos)
Compile a 'mod' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Mod} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Mod(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionmult(int opPos)
Compile a '*' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Mult} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Mult(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionneg(int opPos)
Compile a unary '-' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Neg} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileUnary(new Neg(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionnotequals(int opPos)
Compile a '!=' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.NotEquals} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new NotEquals(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionnumber(int opPos)
Compile a 'number(...)' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Number} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileUnary(new com.sun.org.apache.xpath.internal.operations.Number(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionnumberlit(int opPos)
Compile a literal number value.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.objects.XNumber} instance.
throws
TransformerException if a error occurs creating the Expression.


    opPos = getFirstChildPos(opPos);

    return (XNumber) getTokenQueue().elementAt(getOp(opPos));
protected com.sun.org.apache.xpath.internal.Expressionor(int opPos)
Compile an 'or' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Or} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Or(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionplus(int opPos)
Compile a '+' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Plus} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileOperation(new Plus(), opPos);
public com.sun.org.apache.xpath.internal.Expressionpredicate(int opPos)
Compile a location step predicate expression.

param
opPos The current position in the m_opMap array.
return
the contained predicate expression.
throws
TransformerException if a error occurs creating the Expression.

    return compile(opPos + 2);
public voidsetNamespaceContext(com.sun.org.apache.xml.internal.utils.PrefixResolver pr)
Set the current namespace context for the xpath.

param
pr The resolver for prefixes in the XPath expression.

    m_currentPrefixResolver = pr;
protected com.sun.org.apache.xpath.internal.patterns.StepPatternstepPattern(int opPos, int stepCount, com.sun.org.apache.xpath.internal.patterns.StepPattern ancestorPattern)
Compile a step pattern unit expression, used for both location paths and match patterns.

param
opPos The current position in the m_opMap array.
param
stepCount The number of steps to expect.
param
ancestorPattern The owning StepPattern, which may be null.
return
reference to {@link com.sun.org.apache.xpath.internal.patterns.StepPattern} instance.
throws
TransformerException if a error occurs creating the Expression.


                                                              
    
               
             
  

    int startOpPos = opPos;
    int stepType = getOp(opPos);

    if (OpCodes.ENDOP == stepType)
    {
      return null;
    }
    
    boolean addMagicSelf = true;

    int endStep = getNextOpPos(opPos);

    // int nextStepType = getOpMap()[endStep];
    StepPattern pattern;
    
    // boolean isSimple = ((OpCodes.ENDOP == nextStepType) && (stepCount == 0));
    int argLen;

    switch (stepType)
    {
    case OpCodes.OP_FUNCTION :
      if(DEBUG)
        System.out.println("MATCH_FUNCTION: "+m_currentPattern); 
      addMagicSelf = false;
      argLen = getOp(opPos + OpMap.MAPINDEX_LENGTH);
      pattern = new FunctionPattern(compileFunction(opPos), Axis.PARENT, Axis.CHILD);
      break;
    case OpCodes.FROM_ROOT :
      if(DEBUG)
        System.out.println("FROM_ROOT, "+m_currentPattern);
      addMagicSelf = false;
      argLen = getArgLengthOfStep(opPos);
      opPos = getFirstChildPosOfStep(opPos);
      pattern = new StepPattern(DTMFilter.SHOW_DOCUMENT | 
                                DTMFilter.SHOW_DOCUMENT_FRAGMENT,
                                Axis.PARENT, Axis.CHILD);
      break;
    case OpCodes.MATCH_ATTRIBUTE :
     if(DEBUG)
        System.out.println("MATCH_ATTRIBUTE: "+getStepLocalName(startOpPos)+", "+m_currentPattern);
      argLen = getArgLengthOfStep(opPos);
      opPos = getFirstChildPosOfStep(opPos);
      pattern = new StepPattern(DTMFilter.SHOW_ATTRIBUTE,
                                getStepNS(startOpPos),
                                getStepLocalName(startOpPos),
                                Axis.PARENT, Axis.ATTRIBUTE);
      break;
    case OpCodes.MATCH_ANY_ANCESTOR :
      if(DEBUG)
        System.out.println("MATCH_ANY_ANCESTOR: "+getStepLocalName(startOpPos)+", "+m_currentPattern);
      argLen = getArgLengthOfStep(opPos);
      opPos = getFirstChildPosOfStep(opPos);
      int what = getWhatToShow(startOpPos);
      // bit-o-hackery, but this code is due for the morgue anyway...
      if(0x00000500 == what)
        addMagicSelf = false;
      pattern = new StepPattern(getWhatToShow(startOpPos),
                                        getStepNS(startOpPos),
                                        getStepLocalName(startOpPos),
                                        Axis.ANCESTOR, Axis.CHILD);
      break;
    case OpCodes.MATCH_IMMEDIATE_ANCESTOR :
      if(DEBUG)
        System.out.println("MATCH_IMMEDIATE_ANCESTOR: "+getStepLocalName(startOpPos)+", "+m_currentPattern);
      argLen = getArgLengthOfStep(opPos);
      opPos = getFirstChildPosOfStep(opPos);
      pattern = new StepPattern(getWhatToShow(startOpPos),
                                getStepNS(startOpPos),
                                getStepLocalName(startOpPos),
                                Axis.PARENT, Axis.CHILD);
      break;
    default :
      error(XPATHErrorResources.ER_UNKNOWN_MATCH_OPERATION, null);  //"unknown match operation!");

      return null;
    }

    pattern.setPredicates(getCompiledPredicates(opPos + argLen));
    if(null == ancestorPattern)
    {
      // This is the magic and invisible "." at the head of every 
      // match pattern, and corresponds to the current node in the context 
      // list, from where predicates are counted.
      // So, in order to calculate "foo[3]", it has to count from the 
      // current node in the context list, so, from that current node, 
      // the full pattern is really "self::node()/child::foo[3]".  If you 
      // translate this to a select pattern from the node being tested, 
      // which is really how we're treating match patterns, it works out to 
      // self::foo/parent::node[child::foo[3]]", or close enough.
	/*      if(addMagicSelf && pattern.getPredicateCount() > 0)
      {
        StepPattern selfPattern = new StepPattern(DTMFilter.SHOW_ALL, 
                                                  Axis.PARENT, Axis.CHILD);
        // We need to keep the new nodetest from affecting the score...
        XNumber score = pattern.getStaticScore();
        pattern.setRelativePathPattern(selfPattern);
        pattern.setStaticScore(score);
        selfPattern.setStaticScore(score);
	}*/
    }
    else
    {
      // System.out.println("Setting "+ancestorPattern+" as relative to "+pattern);
      pattern.setRelativePathPattern(ancestorPattern);
    }

    StepPattern relativePathPattern = stepPattern(endStep, stepCount + 1,
                                        pattern);

    return (null != relativePathPattern) ? relativePathPattern : pattern;
protected com.sun.org.apache.xpath.internal.Expressionstring(int opPos)
Compile a 'string(...)' operation.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.String} instance.
throws
TransformerException if a error occurs creating the Expression.

    return compileUnary(new com.sun.org.apache.xpath.internal.operations.String(), opPos);
protected com.sun.org.apache.xpath.internal.Expressionunion(int opPos)
Compile a location path union. The UnionPathIterator itself may create {@link com.sun.org.apache.xpath.internal.axes.LocPathIterator} children.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.axes.LocPathIterator} instance.
throws
TransformerException if a error occurs creating the Expression.

    locPathDepth++;
    try
    {
      return UnionPathIterator.createUnionIterator(this, opPos);
    }
    finally
    {
      locPathDepth--;
    }
protected com.sun.org.apache.xpath.internal.Expressionvariable(int opPos)
Compile a variable reference.

param
opPos The current position in the m_opMap array.
return
reference to {@link com.sun.org.apache.xpath.internal.operations.Variable} instance.
throws
TransformerException if a error occurs creating the Expression.


    Variable var = new Variable();

    opPos = getFirstChildPos(opPos);

    int nsPos = getOp(opPos);
    java.lang.String namespace 
      = (OpCodes.EMPTY == nsPos) ? null 
                                   : (java.lang.String) getTokenQueue().elementAt(nsPos);
    java.lang.String localname 
      = (java.lang.String) getTokenQueue().elementAt(getOp(opPos+1));
    QName qname = new QName(namespace, localname);

    var.setQName(qname);

    return var;
public voidwarn(java.lang.String msg, java.lang.Object[] args)
Warn the user of an problem.

param
msg An error msgkey that corresponds to one of the constants found in {@link com.sun.org.apache.xpath.internal.res.XPATHErrorResources}, which is a key for a format string.
param
args An array of arguments represented in the format string, which may be null.
throws
TransformerException if the current ErrorListoner determines to throw an exception.


    java.lang.String fmsg = XSLMessages.createXPATHWarning(msg, args);

    if (null != m_errorHandler)
    {
      m_errorHandler.warning(new TransformerException(fmsg, m_locator));
    }
    else
    {
      System.out.println(fmsg
                          +"; file "+m_locator.getSystemId()
                          +"; line "+m_locator.getLineNumber()
                          +"; column "+m_locator.getColumnNumber());
    }