public void testIssue172_propertyDoesNotExist()

    {

        final JXPathContext context = getContext(null, false);

        final Object bRet = context.selectSingleNode("unexisting");

        assertNull(bRet);

        final Pointer pointer = context.getPointer("unexisting");

        assertEquals(DynamicPropertyPointer.class, pointer.getClass());

        assertNull(pointer.getValue());

    }

public class MapDynamicPropertyHandler implements DynamicPropertyHandler {

        return ((Map) object).get(propertyName);

    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 JXPathContextFactoryReferenceImpl() {

    }

        return new JXPathContextReferenceImpl(parentContext, contextBean);

    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 pointer;

    protected Step(int axis, NodeTest nodeTest, Expression[] predicates) {

        this.axis = axis;

        this.nodeTest = nodeTest;

        this.predicates = predicates;

    }

        return axis;

        return nodeTest;

        return predicates;

public class ContainerPointerFactory implements NodePointerFactory {

        return CONTAINER_POINTER_FACTORY_ORDER;

        return bean instanceof Container ? new ContainerPointer(

        return bean instanceof Container ? new ContainerPointer(parent,

    private String propertyName = "*";

    private boolean byNameAttribute = false;

        super(parent);

    }

        return new NullPointer(this,  new QName(getPropertyName()));

        return false;

        return propertyName;

        this.propertyName = propertyName;

    }

public class TreeCompiler implements Compiler {

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

        return new QName(prefix, name);

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

        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;

        super(null, locale);

        this.name = name;

        this.bean = bean;

        this.beanInfo = beanInfo;

    }

        super(parent);

        this.name = name;

        this.bean = bean;

        this.beanInfo = beanInfo;

    }

        return new BeanPropertyPointer(this, beanInfo);

        return bean;

        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

public class VariablePointerFactory implements NodePointerFactory {

    public static final class VariableContextWrapper {

        if (object instanceof VariableContextWrapper) {

        return null;

        return createNodePointer(name, object, null);

        return VARIABLE_POINTER_FACTORY_ORDER;

    private static Map dynamicPropertyHandlerMap = new HashMap();

        value = getValue(value);

        if (value == null) {

            return false;

        if (value.getClass().isArray()) {

        if (value instanceof Collection) {

        return false;

            Method method =

            if (method == null) {

            value = method.invoke(bean, new Object[0]);

        }

        return value;

        while (object instanceof Container) {

        return object;

        DynamicPropertyHandler handler =

        if (handler == null) {

                handler = (DynamicPropertyHandler) clazz.newInstance();

            }

            dynamicPropertyHandlerMap.put(clazz, handler);

        return handler;

        if (method == null) {

        if (!Modifier.isPublic(method.getModifiers())) {

        Class clazz = method.getDeclaringClass();

        if (Modifier.isPublic(clazz.getModifiers())) {

            return (method);

    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());

    protected int propertyIndex = UNSPECIFIED_PROPERTY;

        super(parent);

    }

        return propertyIndex;

        if (bean == null) {

            bean = getImmediateParentPointer().getNode();

        return bean;

        return new QName(null, getPropertyName());

        if (!isActualProperty()) {

            return false;

        return super.isActual();

    private static final Object UNINITIALIZED = new Object();

    private Object value = UNINITIALIZED;

        return NodePointer.newChildNodePointer(

    private static final PackageFunctions GENERIC_FUNCTIONS =

    private boolean lenientSet = false;

    private boolean lenient = false;

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

        return contextFactory;

    protected JXPathContext(JXPathContext parentContext, Object contextBean) {

        this.parentContext = parentContext;

        this.contextBean = contextBean;

    }

        if (locale == null) {

            if (parentContext != null) {

            locale = Locale.getDefault();

        return locale;

        this.lenient = lenient;

        lenientSet = true;

    }

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

        return lenient;

        Pointer pointer = getPointer(xpath);

        return pointer == null ? null : pointer.getNode();

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

   switch(curChar)

         return jjMoveNfa_0(0, 0);

   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)

                  jjstateSet[jjnewStateCnt++] = 12;

                  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)))

      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)

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

         matchedToken = jjFillToken();

         return matchedToken;

            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 abstract class Expression {

    protected static final Double ZERO = new Double(0);

    protected static final Double ONE = new Double(1);

    protected static final Double NOT_A_NUMBER = new Double(Double.NaN);

    private boolean contextDependencyKnown = false;

    public static class ValueIterator implements Iterator {

    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(

        super(message);

    }

            this.compiler = compiler;

        }

    switch (jj_nt.kind) {

      NCName_Without_CoreFunctions();

      break;

        {if (true) return token.image;}

    switch (jj_nt.kind) {

      jj_consume_token(NCName);

      break;

        {if (true) return token.image;}

    ex = Expression();

    jj_consume_token(0);

        {if (true) return ex;}

 Object ex = null;

    switch (jj_nt.kind) {

      ex = RelativeLocationPath();

      break;

        {if (true) return ex;}

    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());}

    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;}

    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)) {

      switch (jj_nt.kind) {

        ex = LocationPath();

        break;

        {if (true) return ex;}

    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;}

    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;

    return false;

    return false;

    xsp = jj_scanpos;

    if (jj_3R_20()) {

    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_18()) return true;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    return false;

    if (jj_scan_token(VARIABLE)) return true;

    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;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    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;

    if (jj_scan_token(FUNCTION_NAMESPACE_URI)) return true;

    if (jj_scan_token(FUNCTION_LOCAL_NAME)) return true;

  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;

  }

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) {

            return new NullPointer(parent, name);

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

        if (bi.isDynamic()) {

        return null;

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

        NodePointer pointer = doStep(context, root, steps, 0);

        return pointer;

        if (parent == null) {

        if (currentStep == steps.length) {

        parent = valuePointer(parent);

        Step step = steps[currentStep];

        Expression[] predicates = step.getPredicates();

        if (parent instanceof PropertyOwnerPointer) {

            if (predicates == null || predicates.length == 0) {

                return doStepNoPredicatesPropertyOwner(

        Step step = steps[currentStep];

        NodePointer childPointer =

        if (childPointer == null) {

        if (!childPointer.isActual()) {

            return createNullPointer(

        if (currentStep == steps.length - 1) {

            return childPointer;

        int axis = step.getAxis();

        if (axis == Compiler.AXIS_CHILD || axis == Compiler.AXIS_ATTRIBUTE) {

            QName name = ((NodeNameTest) step.getNodeTest()).getNodeName();

            if (axis == Compiler.AXIS_ATTRIBUTE && isLangAttribute(name)) {

            if (parentPointer.isValidProperty(name)) {

                NodePointer childPointer = parentPointer.getPropertyPointer();

                ((PropertyPointer) childPointer).setPropertyName(

                childPointer.setAttribute(axis == Compiler.AXIS_ATTRIBUTE);

                return childPointer;

        return pointer == null ? null : pointer.getValuePointer();

        if (currentStep == steps.length) {

            return parent;

        parent = valuePointer(parent);

        Step step = steps[currentStep];

        int axis = step.getAxis();

        if (axis == Compiler.AXIS_CHILD || axis == Compiler.AXIS_ATTRIBUTE) {

            NullPropertyPointer pointer = new NullPropertyPointer(parent);

            QName name = ((NodeNameTest) step.getNodeTest()).getNodeName();

            pointer.setPropertyName(name.toString());

            pointer.setAttribute(axis == Compiler.AXIS_ATTRIBUTE);

            parent = pointer;

        Expression[] predicates = step.getPredicates();

        return createNullPointerForPredicates(

        for (int i = currentPredicate; i < predicates.length; i++) {

        return createNullPointer(

    protected int position = 0;

    private boolean startedSetIteration = false;

    private boolean done = false;

    private boolean hasPerformedIteratorStep = false;

    public EvalContext(EvalContext parentContext) {

        this.parentContext = parentContext;

    }

    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 valuePointer = getValuePointer();

        if (valuePointer != this) {

            return valuePointer.getValue();

        return getNode();

        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;

    private static final Object UNINITIALIZED = new Object();

    private Object baseValue = UNINITIALIZED;

    private Object value = UNINITIALIZED;

        super(parent);

        this.beanInfo = beanInfo;

    }

        setPropertyIndex(UNSPECIFIED_PROPERTY);

        this.propertyName = propertyName;

    }

        if (propertyIndex != index) {

    }

        if (baseValue == UNINITIALIZED) {

            PropertyDescriptor pd = getPropertyDescriptor();

            if (pd == null) {

            baseValue = ValueUtils.getValue(getBean(), pd);

        return baseValue;

        if (value == UNINITIALIZED) {

            if (index == WHOLE_COLLECTION) {

                value = ValueUtils.getValue(getBaseValue());

        return value;

        return getPropertyDescriptor() != null;

        if (propertyName == null) {

        return propertyName != null ? propertyName : "*";

        if (propertyDescriptor == null) {

            int inx = getPropertyIndex();

            if (inx == UNSPECIFIED_PROPERTY) {

                propertyDescriptor =

        return propertyDescriptor;

public class DynaBeanPointerFactory implements NodePointerFactory {

        return DYNA_BEAN_POINTER_FACTORY_ORDER;

        return bean instanceof DynaBean ? new DynaBeanPointer(name, (DynaBean) bean, locale) : null;

        return bean instanceof DynaBean ? new DynaBeanPointer(parent, name, (DynaBean) bean) : null;

public class DOMPointerFactory implements NodePointerFactory {

        return DOM_POINTER_FACTORY_ORDER;

        return bean instanceof Node ? new DOMNodePointer((Node) bean, locale) : null;

        return bean instanceof Node ? new DOMNodePointer(parent, (Node) bean) : null;

public class JDOMPointerFactory implements NodePointerFactory {

        return JDOM_POINTER_FACTORY_ORDER;

        if (bean instanceof Document) {

        if (bean instanceof Element) {

        return null;

        if (bean instanceof Document) {

        if (bean instanceof Element) {

        return null;

public abstract class NodeTest {

public class BeanPointerFactory implements NodePointerFactory {

        return BEAN_POINTER_FACTORY_ORDER;

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

        return new BeanPointer(name, bean, bi, locale);

        if (bean == null) {

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

        return new BeanPointer(parent, name, bean, bi);

    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;

        if (propertyDescriptors == null) {

            if (clazz == Object.class) {

                    BeanInfo bi = null;

                    if (clazz.isInterface()) {

                        bi = Introspector.getBeanInfo(clazz, Object.class);

                    PropertyDescriptor[] pds = bi.getPropertyDescriptors();

                    PropertyDescriptor[] descriptors = new PropertyDescriptor[pds.length];

                    System.arraycopy(pds, 0, descriptors, 0, pds.length);

                    Arrays.sort(descriptors, PROPERTY_DESCRIPTOR_COMPARATOR);

                    propertyDescriptors = descriptors;

                }

        if (propertyDescriptors.length == 0) {

        PropertyDescriptor[] result = new PropertyDescriptor[propertyDescriptors.length];

        System.arraycopy(propertyDescriptors, 0, result, 0, propertyDescriptors.length);

        return result;

        if (propertyDescriptorMap == null) {

            propertyDescriptorMap = new HashMap();

            PropertyDescriptor[] pds = getPropertyDescriptors();

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

                propertyDescriptorMap.put(pds[i].getName(), pds[i]);

        return (PropertyDescriptor) propertyDescriptorMap.get(propertyName);

        return dynamicPropertyHandlerClass;

    public QName(String qualifiedName) {

        this.qualifiedName = qualifiedName;

        int index = qualifiedName.indexOf(':');

        prefix = index < 0 ? null : qualifiedName.substring(0, index);

        name = index < 0 ? qualifiedName : qualifiedName.substring(index + 1);

    }

    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;

    private static final Compiler COMPILER = new TreeCompiler();

    private static Map compiled = new HashMap();

    private static int cleanupCount = 0;

    private static NodePointerFactory[] nodeFactoryArray = null;

    private static final Vector nodeFactories = new Vector();

        nodeFactories.add(new CollectionPointerFactory());

        nodeFactories.add(new BeanPointerFactory());

        nodeFactories.add(new DynamicPointerFactory());

        nodeFactories.add(new VariablePointerFactory());

        Object domFactory = allocateConditionally(

        if (domFactory != null) {

            nodeFactories.add(domFactory);

        Object jdomFactory = allocateConditionally(

        if (jdomFactory != null) {

            nodeFactories.add(jdomFactory);

        Object dynaBeanFactory =

        if (dynaBeanFactory != null) {

            nodeFactories.add(dynaBeanFactory);

        nodeFactories.add(new ContainerPointerFactory());

        createNodeFactoryArray();

    }

        if (nodeFactoryArray == null) {

            nodeFactoryArray =

            Arrays.sort(nodeFactoryArray, new Comparator() {

    }

        return nodeFactoryArray;

        this(parentContext, contextBean, null);

    }

        super(parentContext, contextBean);

        synchronized (nodeFactories) {

            createNodeFactoryArray();

        }