public void testJx177()

    {

        doTest("name", "ROOT name");

        doTest("/x/name", "X name");

        doTest("$__root/x/name", "X name");

    }

public class TreeCompiler implements Compiler {

    private static final QName QNAME_NAME = new QName(null, "name");

        return new QName(prefix, name);

        return new VariableReference((QName) qName);

        return new LocationPath(absolute, toStepArray(steps));

        return new ExpressionPath(

        return new NodeNameTest((QName) qname);

        return new Step(

        Expression[] expArray = null;

        if (array != null) {

            expArray = new Expression[array.length];

            for (int i = 0; i < expArray.length; i++) {

        return expArray;

        Step[] stepArray = null;

        if (array != null) {

            stepArray = new Step[array.length];

            for (int i = 0; i < stepArray.length; i++) {

                stepArray[i] = (Step) array[i];

        return stepArray;

    protected JXPathContextFactory () {

    }

            factoryImpl = (JXPathContextFactory) clazz.newInstance();

        }

        return factoryImpl;

    private static boolean debug = false;

            debug = System.getProperty("jxpath.debug") != null;

        }

    }

            String systemProp = System.getProperty(property);

            if (systemProp != null) {

       }

            String javah = System.getProperty("java.home");

            String configFile =

            File f = new File(configFile);

            if (f.exists()) {

        }

        String serviceId = "META-INF/services/" + property;

            ClassLoader cl = JXPathContextFactory.class.getClassLoader();

            InputStream is = null;

            if (cl == null) {

                is = cl.getResourceAsStream(serviceId);

            if (is != null) {

        }

        return defaultFactory;

    private int availableRegister = 0;

    public static final Object UNKNOWN_VALUE = new Object();

        super(null);

        this.jxpathContext = jxpathContext;

        this.pointer = pointer;

        if (pointer != null) {

            pointer.setNamespaceResolver(jxpathContext.getNamespaceResolver());

    }

        return this;

        return jxpathContext.getAbsoluteRootContext();

        return pointer;

        return new InitialContext(

    protected int index = WHOLE_COLLECTION;

    private boolean attribute = false;

        NodePointer pointer = null;

        if (bean == null) {

        NodePointerFactory[] factories =

        for (int i = 0; i < factories.length; i++) {

            pointer = factories[i].createNodePointer(name, bean, locale);

            if (pointer != null) {

                return pointer;

        NodePointerFactory[] factories =

        for (int i = 0; i < factories.length; i++) {

            NodePointer pointer =

            if (pointer != null) {

                return pointer;

    protected NodePointer(NodePointer parent) {

        this.parent = parent;

    }

    protected NodePointer(NodePointer parent, Locale locale) {

        this.parent = parent;

        this.locale = locale;

    }

        this.namespaceResolver = namespaceResolver;

    }

        return parent;

        this.attribute = attribute;

    }

        return index;

        NodePointer ivp = getImmediateValuePointer();

        return ivp == this ? this : ivp.getValuePointer();

        return this;

        return index == WHOLE_COLLECTION || index >= 0 && index < getLength();

        return getValuePointer().getImmediateNode();

        if (prefix == null) {

            return true;

            NodePointer ptr = (NodePointer) super.clone();

            if (parent != null) {

                ptr.parent = (NodePointer) parent.clone();

            return ptr;

        super(parent);

        this.name = name;

        this.bean = bean;

        this.beanInfo = beanInfo;

    }

        return bean;

    protected int propertyIndex = UNSPECIFIED_PROPERTY;

        super(parent);

    }

        if (bean == null) {

            bean = getImmediateParentPointer().getNode();

        return bean;

        return new QName(null, getPropertyName());

        if (!isActualProperty()) {

        return super.isActual();

    private static final Object UNINITIALIZED = new Object();

    private Object value = UNINITIALIZED;

        Object value = getBaseValue();

        return value != null && ValueUtils.isCollection(value);

        return NodePointer.newChildNodePointer(

        private VariableContextWrapper(JXPathContext context) {

            this.context = context;

        }

            return context;

    private static XPathParser parser = new XPathParser(new StringReader(""));

        synchronized (parser) {

            parser.setCompiler(compiler);

            Object expr = null;

                parser.ReInit(new StringReader(expression));

                expr = parser.parseExpression();

            }

            return expr;

public class DynamicPointerFactory implements NodePointerFactory {

        return DYNAMIC_POINTER_FACTORY_ORDER;

        JXPathBeanInfo bi = JXPathIntrospector.getBeanInfo(bean.getClass());

        if (bi.isDynamic()) {

            DynamicPropertyHandler handler =

            return new DynamicPointer(name, bean, handler, locale);

        return null;

        if (bean == null) {

        JXPathBeanInfo bi = JXPathIntrospector.getBeanInfo(bean.getClass());

        if (bi.isDynamic()) {

            DynamicPropertyHandler handler =

            return new DynamicPointer(parent, name, bean, handler);

        return null;

    private static final PackageFunctions GENERIC_FUNCTIONS =

    private boolean lenientSet = false;

    private boolean lenient = false;

        return getContextFactory().newContext(null, contextBean);

        return contextFactory;

    protected JXPathContext(JXPathContext parentContext, Object contextBean) {

        this.parentContext = parentContext;

        this.contextBean = contextBean;

    }

        this.vars = vars;

    }

        if (vars == null) {

        return vars;

        if (locale == null) {

            if (parentContext != null) {

            locale = Locale.getDefault();

        return locale;

        if (!lenientSet && parentContext != null) {

        return lenient;

        super(null);

        this.variables = variables;

        this.name = name;

        actual = true;

    }

        if (!actual) {

        return variables.getVariable(name.toString());

        Object value = getBaseValue();

        return index == WHOLE_COLLECTION ? ValueUtils.getValue(value)

        if (valuePointer == null) {

            Object value = null;

            if (actual) {

                value = getImmediateNode();

                valuePointer =

        return valuePointer;

    private boolean basicKnown = false;

        super(steps);

        this.expression = expression;

        this.predicates = predicates;

    }

        return predicates;

        if (!basicKnown) {

            basicKnown = true;

            basic = isSimplePath() && areBasicPredicates(getPredicates());

        return basic;

        return expressionPath(context, true);

        Object value = expression.compute(evalContext);

        if (value instanceof InitialContext) {

            context = (InitialContext) value;

        if (firstMatch

            EvalContext ctx = context;

            NodePointer ptr = (NodePointer) ctx.getSingleNodePointer();

            if (ptr != null

                return SimplePathInterpreter.interpretSimpleExpressionPath(

  public  java.io.PrintStream debugStream = System.out;

   switch (pos)

         return -1;

            return 12;

   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);

   jjmatchedKind = kind;

   jjmatchedPos = pos;

   return pos + 1;

   switch(curChar)

         return jjStopAtPos(0, 17);

         jjmatchedKind = 6;

         return jjMoveStringLiteralDfa1_0(0x80L, 0x0L);

         return jjMoveNfa_0(0, 0);

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

   return jjStartNfa_0(0, active0, active1);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         if ((active0 & 0x80000000L) != 0L)

         else if ((active0 & 0x80000000000000L) != 0L)

            jjmatchedKind = 55;

            jjmatchedPos = 3;

         return jjMoveStringLiteralDfa4_0(active0, 0x40116000000000L, active1, 0L);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   catch(java.io.IOException e) {

      jjStopStringLiteralDfa_0(3, active0, active1);

      return 4;

   if (jjrounds[state] != jjround)

      jjstateSet[jjnewStateCnt++] = state;

      jjrounds[state] = jjround;

}

static final long[] jjbitVec0 = {

static final long[] jjbitVec2 = {

static final long[] jjbitVec3 = {

static final long[] jjbitVec4 = {

static final long[] jjbitVec5 = {

static final long[] jjbitVec6 = {

static final long[] jjbitVec7 = {

static final long[] jjbitVec8 = {

static final long[] jjbitVec9 = {

static final long[] jjbitVec10 = {

static final long[] jjbitVec11 = {

static final long[] jjbitVec12 = {

static final long[] jjbitVec13 = {

static final long[] jjbitVec14 = {

static final long[] jjbitVec15 = {

static final long[] jjbitVec16 = {

static final long[] jjbitVec17 = {

static final long[] jjbitVec18 = {

static final long[] jjbitVec19 = {

static final long[] jjbitVec20 = {

static final long[] jjbitVec21 = {

static final long[] jjbitVec22 = {

static final long[] jjbitVec23 = {

static final long[] jjbitVec24 = {

static final long[] jjbitVec25 = {

static final long[] jjbitVec26 = {

static final long[] jjbitVec27 = {

static final long[] jjbitVec28 = {

static final long[] jjbitVec29 = {

static final long[] jjbitVec30 = {

static final long[] jjbitVec31 = {

static final long[] jjbitVec32 = {

static final long[] jjbitVec33 = {

static final long[] jjbitVec34 = {

static final long[] jjbitVec35 = {

static final long[] jjbitVec36 = {

static final long[] jjbitVec37 = {

static final long[] jjbitVec38 = {

static final long[] jjbitVec39 = {

static final long[] jjbitVec40 = {

static final long[] jjbitVec41 = {

   int startsAt = 0;

   jjnewStateCnt = 13;

   int i = 1;

   jjstateSet[0] = startState;

   int j, kind = 0x7fffffff;

      if (++jjround == 0x7fffffff)

      if (curChar < 64)

         long l = 1L << curChar;

            switch(jjstateSet[--i])

                  if ((0x3ff600000000000L & l) == 0L)

                     break;

         } while(i != startsAt);

      }

      else if (curChar < 128)

         long l = 1L << (curChar & 077);

            switch(jjstateSet[--i])

                  if ((0x7fffffe87fffffeL & l) == 0L)

                  jjCheckNAdd(12);

                  break;

         } while(i != startsAt);

      }

      if (kind != 0x7fffffff)

         jjmatchedKind = kind;

         jjmatchedPos = curPos;

         kind = 0x7fffffff;

      ++curPos;

      if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))

         return curPos;

      try { curChar = input_stream.readChar(); }

      catch(java.io.IOException e) { return curPos; }

static final int[] jjnextStates = {

public static final String[] jjstrLiteralImages = {

public static final String[] lexStateNames = {

static final long[] jjtoToken = {

static final long[] jjtoSkip = {

private final int[] jjrounds = new int[13];

private final int[] jjstateSet = new int[26];

{

   input_stream = stream;

}

   jjmatchedPos = jjnewStateCnt = 0;

   curLexState = defaultLexState;

   input_stream = stream;

   ReInitRounds();

}

   jjround = 0x80000001;

   for (i = 13; i-- > 0;)

      jjrounds[i] = 0x80000000;

}

   Token t = Token.newToken(jjmatchedKind);

   t.kind = jjmatchedKind;

   String im = jjstrLiteralImages[jjmatchedKind];

   t.image = (im == null) ? input_stream.GetImage() : im;

   t.beginLine = input_stream.getBeginLine();

   t.beginColumn = input_stream.getBeginColumn();

   t.endLine = input_stream.getEndLine();

   t.endColumn = input_stream.getEndColumn();

   return t;

int curLexState = 0;

int defaultLexState = 0;

  Token specialToken = null;

  int curPos = 0;

      curChar = input_stream.BeginToken();

   catch(java.io.IOException e)

      jjmatchedKind = 0;

      matchedToken = jjFillToken();

      return matchedToken;

   }

   try { input_stream.backup(0);

      while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)

   catch (java.io.IOException e1) { continue EOFLoop; }

   jjmatchedKind = 0x7fffffff;

   jjmatchedPos = 0;

   curPos = jjMoveStringLiteralDfa0_0();

   if (jjmatchedKind != 0x7fffffff)

      if (jjmatchedPos + 1 < curPos)

         input_stream.backup(curPos - jjmatchedPos - 1);

      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

         matchedToken = jjFillToken();

         return matchedToken;

public class Token {

     switch(ofKind)

       default : return new Token();

    protected HashMap namespaceMap = new HashMap();

    protected HashMap reverseMap = new HashMap();

    public NamespaceResolver(NamespaceResolver parent) {

        this.parent = parent;

    }

        this.pointer = pointer;

    }

        sealed = true;

        if (parent != null) {

    }

    private static final Object UNINITIALIZED = new Object();

    private Object value = UNINITIALIZED;

        super(parent, locale);

    }

        super(parent);

    }

        if (value == UNINITIALIZED) {

            value = index == WHOLE_COLLECTION ? ValueUtils.getValue(getBaseValue())

        return value;

        return isDefaultNamespace(name.getPrefix());

        registerAtomicClass(Class.class);

        registerAtomicClass(Boolean.TYPE);

        registerAtomicClass(Boolean.class);

        registerAtomicClass(Byte.TYPE);

        registerAtomicClass(Byte.class);

        registerAtomicClass(Character.TYPE);

        registerAtomicClass(Character.class);

        registerAtomicClass(Short.TYPE);

        registerAtomicClass(Short.class);

        registerAtomicClass(Integer.TYPE);

        registerAtomicClass(Integer.class);

        registerAtomicClass(Long.TYPE);

        registerAtomicClass(Long.class);

        registerAtomicClass(Float.TYPE);

        registerAtomicClass(Float.class);

        registerAtomicClass(Double.TYPE);

        registerAtomicClass(Double.class);

        registerAtomicClass(String.class);

        registerAtomicClass(Date.class);

        registerAtomicClass(java.sql.Date.class);

        registerAtomicClass(java.sql.Time.class);

        registerAtomicClass(java.sql.Timestamp.class);

        registerDynamicClass(Map.class, MapDynamicPropertyHandler.class);

    }

    }

        JXPathBasicBeanInfo bi =

        if (beanClass.isInterface()) {

    }

        JXPathBeanInfo beanInfo = (JXPathBeanInfo) byClass.get(beanClass);

        if (beanInfo == null) {

            beanInfo = findDynamicBeanInfo(beanClass);

            if (beanInfo == null) {

                beanInfo = findInformant(beanClass);

                if (beanInfo == null) {

                    beanInfo = new JXPathBasicBeanInfo(beanClass);

        return beanInfo;

        JXPathBeanInfo beanInfo = null;

        if (beanClass.isInterface()) {

            beanInfo = (JXPathBeanInfo) byInterface.get(beanClass);

            if (beanInfo != null && beanInfo.isDynamic()) {

                return beanInfo;

        Class[] interfaces = beanClass.getInterfaces();

        if (interfaces != null) {

            for (int i = 0; i < interfaces.length; i++) {

                beanInfo = findDynamicBeanInfo(interfaces[i]);

                if (beanInfo != null && beanInfo.isDynamic()) {

                    return beanInfo;

        Class sup = beanClass.getSuperclass();

        if (sup != null) {

            beanInfo = (JXPathBeanInfo) byClass.get(sup);

            if (beanInfo != null && beanInfo.isDynamic()) {

            return findDynamicBeanInfo(sup);

        return null;

        String name = beanClass.getName() + "XBeanInfo";

        catch (Exception ex) { //NOPMD

            if (JXPathBeanInfo.class.isAssignableFrom(beanClass)) {

        }

        return null;

        ClassLoader cl = sibling.getClassLoader();

        if (cl != null) {

            catch (Exception ex) { //NOPMD

    private boolean basicKnown = false;

    public Path(Step[] steps) {

        this.steps = steps;

    }

        return steps;

        if (!basicKnown) {

            basicKnown = true;

            basic = true;

            Step[] steps = getSteps();

            for (int i = 0; i < steps.length; i++) {

                if (!isSimpleStep(steps[i])) {

        return basic;

        if (step.getAxis() == Compiler.AXIS_SELF) {

        if (step.getAxis() == Compiler.AXIS_CHILD

            NodeTest nodeTest = step.getNodeTest();

            if (!(nodeTest instanceof NodeNameTest)) {

            if (((NodeNameTest) nodeTest).isWildcard()) {

            return areBasicPredicates(step.getPredicates());

        if (predicates != null && predicates.length != 0) {

        return true;

        if (steps.length == 0) {

        if (isSimplePath()) {

            NodePointer ptr = (NodePointer) context.getSingleNodePointer();

            return SimplePathInterpreter.interpretSimpleLocationPath(

    public QName(String prefix, String localName) {

        this.prefix = prefix;

        this.name = localName;

        this.qualifiedName = prefix == null ? localName : prefix + ':' + localName;

    }

        return prefix;

        return name;

        return qualifiedName;

    public VariableReference(QName varName) {

        this.varName = varName;

    }

        return computeValue(context);

        return context.getRootContext().getVariableContext(varName);

public class CollectionPointerFactory implements NodePointerFactory {

        return COLLECTION_POINTER_FACTORY_ORDER;

        return ValueUtils.isCollection(bean) ? new CollectionPointer(bean, locale) : null;

        return ValueUtils.isCollection(bean) ? new CollectionPointer(parent, bean) : null;

    private static final Comparator PROPERTY_DESCRIPTOR_COMPARATOR = new Comparator() {

    private boolean atomic = false;

    public JXPathBasicBeanInfo(Class clazz) {

        this.clazz = clazz;

    }

    public JXPathBasicBeanInfo(Class clazz, boolean atomic) {

        this.clazz = clazz;

        this.atomic = atomic;

    }

    public JXPathBasicBeanInfo(Class clazz, Class dynamicPropertyHandlerClass) {

        this.clazz = clazz;

        this.atomic = false;

        this.dynamicPropertyHandlerClass = dynamicPropertyHandlerClass;

    }

        return dynamicPropertyHandlerClass != null;

        return dynamicPropertyHandlerClass;

            Arrays.sort(nodeFactoryArray, new Comparator() {

                    int orderA = ((NodePointerFactory) a).getOrder();

                    int orderB = ((NodePointerFactory) b).getOrder();

                    return orderA - orderB;

    private static final Comparator PROPERTY_DESCRIPTOR_COMPARATOR = new Comparator() {

public class ContainerPointerFactory implements NodePointerFactory {

        return CONTAINER_POINTER_FACTORY_ORDER;

        return bean instanceof Container ? new ContainerPointer(

        return bean instanceof Container ? new ContainerPointer(parent,

    public JXPathContextFactoryReferenceImpl() {

    }

        return new JXPathContextReferenceImpl(parentContext, contextBean);

            this.compiler = compiler;

        }

    switch (jj_nt.kind) {

      NCName_Without_CoreFunctions();

      break;

      jj_consume_token(FUNCTION_NAME);

      break;

        {if (true) return token.image;}

    switch (jj_nt.kind) {

      jj_consume_token(NCName);

      break;

        {if (true) return token.image;}

 String nc1, nc2 = null;

    nc1 = NCName();

    switch (jj_nt.kind) {

      jj_la1[3] = jj_gen;

        if (nc2 == null){

            {if (true) return compiler.qname(null, nc1);}

    ex = Expression();

    jj_consume_token(0);

        {if (true) return ex;}

 Object ex = null;

    switch (jj_nt.kind) {

      ex = RelativeLocationPath();

      break;

      ex = AbsoluteLocationPath();

      break;

        {if (true) return ex;}

    ArrayList steps = new ArrayList();

    if (jj_2_2(2147483647)) {

      LocationStep(steps);

        switch (jj_nt.kind) {

          break;

          jj_la1[6] = jj_gen;

          break label_1;

        LocationStep(steps);

        {if (true) return compiler.locationPath(true, steps.toArray());}

    ArrayList steps = new ArrayList();

    NodeTest(steps);

      switch (jj_nt.kind) {

        jj_la1[8] = jj_gen;

        break label_2;

        {if (true) return compiler.locationPath(false, steps.toArray());}

    switch (jj_nt.kind) {

      jj_consume_token(SLASH);

      break;

    NodeTest(steps);

  }

    int type = -1;

    String instruction = null;

    Object name = null;

    ArrayList ps = new ArrayList();

    switch (jj_nt.kind) {

      axis = AxisSpecifier();

      if (jj_2_3(2147483647)) {

      } else if (jj_2_4(2147483647)) {

        switch (jj_nt.kind) {

          name = WildcardName();

          break;

      switch (jj_nt.kind) {

        jj_la1[12] = jj_gen;

        break label_3;

        if (name != null){

            s = compiler.nodeNameTest(name);

        steps.add(compiler.step(axis, s, ps.toArray()));

  }

    switch (jj_nt.kind) {

      jj_la1[13] = jj_gen;

      axis = AbbreviatedAxisSpecifier();

        {if (true) return axis;}

    int axis = Compiler.AXIS_CHILD;

    switch (jj_nt.kind) {

      jj_la1[15] = jj_gen;

        {if (true) return axis;}

    ex = OrExpr();

        {if (true) return ex;}

    Object ex = null;

    switch (jj_nt.kind) {

      ex = VariableReference();

      break;

        {if (true) return ex;}

    ArrayList list = null;

    ex = PathExpr();

      switch (jj_nt.kind) {

        jj_la1[20] = jj_gen;

        break label_5;

        if (list != null){

        {if (true) return ex;}

    Object ex = null;

    if (jj_2_6(2147483647)) {

      ex = FilterExpr();

      switch (jj_nt.kind) {

        ex = LocationPath();

        break;

        {if (true) return ex;}

    ArrayList ps = new ArrayList();

    boolean path = false;

    ArrayList steps = new ArrayList();

    ex = PrimaryExpr();

      switch (jj_nt.kind) {

        jj_la1[22] = jj_gen;

        break label_6;

      switch (jj_nt.kind) {

        break;

        jj_la1[23] = jj_gen;

        break label_7;

      LocationStep(steps);

                path = true;

        if (path){

            {if (true) return compiler.expressionPath(ex, ps.toArray(), steps.toArray());}

    ArrayList list = null;

    ex = AndExpr();

      switch (jj_nt.kind) {

        jj_la1[24] = jj_gen;

        break label_8;

        if (list != null){

        {if (true) return ex;}

    ArrayList list = null;

    ex = EqualityExpr();

      switch (jj_nt.kind) {

        jj_la1[25] = jj_gen;

        break label_9;

        if (list != null){

        {if (true) return ex;}

    ex = RelationalExpr();

      switch (jj_nt.kind) {

        jj_la1[26] = jj_gen;

        break label_10;

        {if (true) return ex;}

    ex = AdditiveExpr();

      switch (jj_nt.kind) {

        jj_la1[28] = jj_gen;

        break label_11;

        {if (true) return ex;}

    ArrayList list = null;

    ex = SubtractiveExpr();

      switch (jj_nt.kind) {

        jj_la1[30] = jj_gen;

        break label_12;

        if (list != null){

        {if (true) return ex;}

    Object ex, r = null;

    ex = MultiplicativeExpr();

      switch (jj_nt.kind) {

        jj_la1[31] = jj_gen;

        break label_13;

        {if (true) return ex;}

    ex = UnaryExpr();

      switch (jj_nt.kind) {

        jj_la1[32] = jj_gen;

        break label_14;

        {if (true) return ex;}

    switch (jj_nt.kind) {

      ex = UnionExpr();

      break;

        {if (true) return ex;}

    jj_consume_token(VARIABLE);

    ex = QName();

        {if (true) return compiler.variableReference(ex);}

    String nc1, nc2 = null;

    switch (jj_nt.kind) {

      NCName();

      break;

                           nc1 = token.image;

    switch (jj_nt.kind) {

      jj_la1[37] = jj_gen;

        if (nc2 != null){

            qn = compiler.qname(null, nc1);

        {if (true) return qn;}

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    return false;

    return false;

    return false;

    return false;

    return false;

    xsp = jj_scanpos;

    if (jj_3R_20()) {

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    return false;

    if (jj_scan_token(COMMENT)) return true;

    if (jj_scan_token(NODE)) return true;

    if (jj_scan_token(TEXT)) return true;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    if (jj_3R_15()) return true;

    if (jj_3R_15()) return true;

    return false;

    if (jj_3R_18()) return true;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    xsp = jj_scanpos;

    return false;

    return false;

    if (jj_scan_token(VARIABLE)) return true;

    return false;

    if (jj_scan_token(FUNCTION_FORMAT_NUMBER)) return true;

    if (jj_scan_token(FUNCTION_KEY)) return true;

    if (jj_scan_token(FUNCTION_ROUND)) return true;

    if (jj_scan_token(FUNCTION_CEILING)) return true;

    if (jj_scan_token(FUNCTION_FLOOR)) return true;

    if (jj_scan_token(FUNCTION_SUM)) return true;

    if (jj_scan_token(FUNCTION_NUMBER)) return true;

    if (jj_scan_token(FUNCTION_LANG)) return true;

    return false;

    if (jj_scan_token(FUNCTION_FALSE)) return true;

    if (jj_scan_token(FUNCTION_TRUE)) return true;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    return false;

    if (jj_scan_token(FUNCTION_STRING_LENGTH)) return true;

    if (jj_scan_token(FUNCTION_SUBSTRING)) return true;

    if (jj_scan_token(FUNCTION_SUBSTRING_AFTER)) return true;

    if (jj_scan_token(FUNCTION_SUBSTRING_BEFORE)) return true;

    if (jj_scan_token(FUNCTION_CONTAINS)) return true;

    if (jj_scan_token(FUNCTION_STARTS_WITH)) return true;

    if (jj_scan_token(FUNCTION_CONCAT)) return true;

    if (jj_scan_token(FUNCTION_STRING)) return true;

    if (jj_scan_token(FUNCTION_NAME)) return true;

    return false;

    if (jj_scan_token(FUNCTION_NAMESPACE_URI)) return true;

    if (jj_scan_token(FUNCTION_LOCAL_NAME)) return true;

    return false;

  public boolean lookingAhead = false;

  final private int[] jj_la1 = new int[39];

      jj_la1_0();

      jj_la1_1();

      jj_la1_2();

   }

      jj_la1_0 = new int[] {0xf8000000,0x78000000,0x0,0x0,0x78000000,0xf80000c0,0xc0,0x40,0xc0,0xc0,0xf8000000,0xf8000000,0x0,0x0,0x0,0x0,0x160000,0xf8000000,0x0,0xf81604c0,0x100,0xf80000c0,0x0,0xc0,0x8000000,0x10000000,0x1800,0x1800,0x1e000,0x1e000,0x200,0x400,0x60000000,0x60000000,0xf81604c0,0xf8000000,0xf8000000,0x0,0x80000000,};

   }

      jj_la1_1 = new int[] {0xffff0007,0x0,0xffff0000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffff0007,0xffffffff,0x0,0xfff8,0xfff8,0x0,0x0,0xffff0007,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffff0007,0xffff0007,0x0,0x7,};

   }

   }

  final private JJCalls[] jj_2_rtns = new JJCalls[6];

  private boolean jj_rescan = false;

  private int jj_gc = 0;

  public XPathParser(java.io.Reader stream) {

    jj_input_stream = new SimpleCharStream(stream, 1, 1);

    token_source = new XPathParserTokenManager(jj_input_stream);

    token = new Token();

    token.next = jj_nt = token_source.getNextToken();

    jj_gen = 0;

    for (int i = 0; i < 39; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

    jj_input_stream.ReInit(stream, 1, 1);

    token_source.ReInit(jj_input_stream);

    token = new Token();

    token.next = jj_nt = token_source.getNextToken();

    jj_gen = 0;

    for (int i = 0; i < 39; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

    Token oldToken = token;

    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;

    else jj_nt = jj_nt.next = token_source.getNextToken();

    if (token.kind == kind) {

      jj_gen++;

      if (++jj_gc > 100) {

      return token;

    if (jj_scanpos == jj_lastpos) {

      jj_la--;

      if (jj_scanpos.next == null) {

        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();

        jj_lastpos = jj_scanpos = jj_scanpos.next;

      jj_scanpos = jj_scanpos.next;

    if (jj_rescan) {

  private java.util.Vector jj_expentries = new java.util.Vector();

  private int jj_kind = -1;

  private int[] jj_lasttokens = new int[100];

    JJCalls p = jj_2_rtns[index];

    while (p.gen > jj_gen) {

    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;

  }

    private static final Object[] EMPTY_ARRAY = new Object[0];

    public PackageFunctions(String classPrefix, String namespace) {

        this.classPrefix = classPrefix;

        this.namespace = namespace;