private String getNameSpaceURI(VTDNav vn) { if (argCount1 == 0) { try { int i = vn.getCurrentIndex(); int type = vn.getTokenType(i); if (vn.ns && (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME)) { int a = vn.lookupNS(); if (a == 0) return ""; else return vn.toString(a); } return ""; } catch (Exception e) { return ""; } } else if (argCount1 == 1 && argumentList.e.NodeSet) { vn.push2(); int size = vn.contextStack2.size; int a = -1; try { a = argumentList.e.evalNodeSet(vn); } catch (Exception e) { } String s = ""; // return a; try { if (a == -1 || vn.ns == false) { } else { int type = vn.getTokenType(a); if (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME) s = vn.toString(vn.lookupNS()); } } catch (Exception e) { }; vn.contextStack2.size = size; argumentList.e.reset(vn); vn.pop2(); return s; } else throw new System.ArgumentException ("namespace-uri()'s argument count is invalid"); }
private bool matchLocalName(VTDNav vn) { if (argCount1 == 1) { try { int index = vn.getCurrentIndex(); int type = vn.getTokenType(index); String s1 = argumentList.e.evalString(vn); if (vn.ns && (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME)) { int offset = vn.getTokenOffset(index); int length = vn.getTokenLength(index); if (length < 0x10000 || (length >> 16) == 0) { return (vn.compareRawTokenString(index, s1) == 0);//vn.toRawString(index); } else { int preLen = length >> 16; int QLen = length & 0xffff; if (preLen != 0) { return (vn.compareRawTokenString(offset + preLen + 1, QLen - preLen - 1, s1) == 0); } } } else if (type == VTDNav.TOKEN_PI_NAME) { return vn.compareRawTokenString(index, s1) == 0; } else return "".Equals(s1); } catch (NavException e) { return false; // this will never occur } } else if (argCount1 == 2) { int a = evalFirstArgumentListNodeSet2(vn); String s1 = argumentList.next.e.evalString(vn); if (a == -1 || vn.ns == false) return "".Equals(s1); int type = vn.getTokenType(a); if (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME) { //return "".equals(s1); try { int offset = vn.getTokenOffset(a); int length = vn.getTokenLength(a); if (length < 0x10000 || (length >> 16) == 0) return vn.compareRawTokenString(a, s1) == 0; else { int preLen = length >> 16; int QLen = length & 0xffff; if (preLen != 0) return vn.compareRawTokenString(offset + preLen + 1, QLen - preLen - 1, s1) == 0; /*else { return vn.toRawString(offset, QLen); }*/ } } catch (NavException e) { return "".Equals(s1); // this will almost never occur } } else if (type == VTDNav.TOKEN_PI_NAME) { try { return vn.compareRawTokenString(a, s1) == 0; } catch (NavException e) { return "".Equals(s1); } } return "".Equals(s1); } else throw new ArgumentException ("match-local-name()'s argument count is invalid"); return false; }
private String getLocalName(VTDNav vn) { if (argCount1 == 0) { try { int index = vn.getCurrentIndex(); int type = vn.getTokenType(index); if (vn.ns && (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME)) { int offset = vn.getTokenOffset(index); int length = vn.getTokenLength(index); if (length < 0x10000) { if (vn.localNameIndex != index) { vn.localNameIndex = index; vn.localName = vn.toRawString(index); } return vn.localName; } else { int preLen = length >> 16; int QLen = length & 0xffff; if (preLen != 0) { if (vn.localNameIndex != index) { vn.localNameIndex = index; vn.localName = vn.toRawString(offset + preLen + 1, QLen - preLen - 1); } return vn.localName; } else { if (vn.localNameIndex != index) { vn.localNameIndex = index; vn.localName = vn.toRawString(offset, QLen); } return vn.localName; } } } else return ""; } catch (NavException e) { return ""; // this will almost never occur } } else if (argCount1 == 1) { int a = evalFirstArgumentListNodeSet2(vn); if (a == -1 || vn.ns == false) return ""; int type = vn.getTokenType(a); if (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME) { try { int offset = vn.getTokenOffset(a); int length = vn.getTokenLength(a); if (length < 0x10000) return vn.toRawString(a); else { int preLen = length >> 16; int QLen = length & 0xffff; if (preLen != 0) return vn.toRawString(offset + preLen + 1, QLen - preLen - 1); else { return vn.toRawString(offset, QLen); } } } catch (NavException e) { return ""; // this will almost never occur } } else if (type == VTDNav.TOKEN_PI_NAME) { try { return vn.toRawString(a); } catch (NavException e) { return ""; } } else return ""; } else throw new System.ArgumentException ("local-name()'s argument count is invalid"); }
private System.String normalizeSpace(VTDNav vn) { if (argCount1 == 0) { String s = null; try { if (vn.atTerminal) { int ttype = vn.getTokenType(vn.LN); if (ttype == VTDNav.TOKEN_CDATA_VAL) s = vn.toRawString(vn.LN); else if (ttype == VTDNav.TOKEN_ATTR_NAME || ttype == VTDNav.TOKEN_ATTR_NS) { s = vn.toString(vn.LN + 1); } else s = vn.toString(vn.LN); } else { int i = vn.getCurrentIndex(); int t = vn.getTokenType(i); if (t == VTDNav.TOKEN_STARTING_TAG || t == VTDNav.TOKEN_DOCUMENT) { s = vn.toNormalizedXPathString(i); } else s = vn.toNormalizedString(i); } return normalize(s); } catch (NavException e) { return ""; // this will almost never occur } } else if (argCount1 == 1) { String s = ""; if (argumentList.e.NodeSet) { //boolean b = false; int a = evalFirstArgumentListNodeSet(vn); if (a == -1) return ""; else { try { int t = vn.getTokenType(a); if (t == VTDNav.TOKEN_STARTING_TAG || t == VTDNav.TOKEN_DOCUMENT) { s = vn.toNormalizedXPathString(a); } else s = vn.toNormalizedString(a); } catch (Exception e) { } return s; } } else { s = argumentList.e.evalString(vn); return normalize(s); } } throw new System.ArgumentException("normalize-space()'s argument count is invalid"); //return null; }
private bool matchName(VTDNav vn) { int a; if (argCount1 == 1) { a = vn.getCurrentIndex(); int type = vn.getTokenType(a); String s1 = argumentList.e.evalString(vn); if (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME || type == VTDNav.TOKEN_PI_NAME) { try { return vn.matchRawTokenString(a, s1); } catch (Exception e) { return false; } } else return false; } else if (argCount1 == 2) { a = evalFirstArgumentListNodeSet2(vn); String s1 = argumentList.next.e.evalString(vn); try { if (a == -1 || vn.ns == false) return s1.CompareTo("")==0; else { int type = vn.getTokenType(a); if (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME || type == VTDNav.TOKEN_PI_NAME) return vn.matchRawTokenString(a, s1); return false; } } catch (Exception e) { } return false; } else throw new System.ArgumentException( "matchName()'s argument count is invalid"); }
protected int process_DDFP2(VTDNav vn) { AutoPilot ap; bool b = false, b1 = false; Predicate t = null; int result; switch (state) { case START: case FORWARD: /*if (vn.atTerminal) { if (state == START) state = END; else { // no need to set_ft to true // no need to resetP state = BACKWARD; currentStep = currentStep.prevS; } break; }*/ t = currentStep.p; while (t != null) { if (t.requireContext) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize=(i); } t = t.nextP; } if (b1) { if (state == START) state = END; else { currentStep = currentStep.prevS; state = BACKWARD; } break; } String helper = null; /*if (currentStep.nt.testType == NodeTest.NAMETEST) { helper = currentStep.nt.nodeName; } else if (currentStep.nt.testType == NodeTest.NODE) { helper = "*"; } else throw new XPathEvalException( "can't run descendant " + "following, or following-sibling axis over comment(), pi(), and text()");*/ if (currentStep.o == null) currentStep.o = ap = new AutoPilot(vn); else { ap = (AutoPilot) currentStep.o; ap.bind(vn); } if (currentStep.ft) { /*if (currentStep.axis_type == AxisType.DESCENDANT_OR_SELF) if (currentStep.nt.testType == NodeTest.NODE) ap.setSpecial(true); else ap.setSpecial(false);*/ // currentStep.o = ap = new AutoPilot(vn); if (currentStep.axis_type == AxisType.DESCENDANT_OR_SELF) ap.selectNode(); else if (currentStep.axis_type == AxisType.DESCENDANT) ap.selectDescendantNode(); else if (currentStep.axis_type == AxisType.PRECEDING) ap.selectPrecedingNode(); else ap.selectFollowingNode(); currentStep.ft = false; } if (state == START) state = END; vn.push2(); // not the most efficient. good for now // System.out.println(" --++ push in //"); b = false; while (ap.iterate2()) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { b = true; break; } } if (b == false) { vn.pop2(); // System.out.println(" --++ pop in //"); currentStep.ft = true; if (currentStep.hasPredicate) currentStep.resetP(vn); if (state == FORWARD) { state = BACKWARD; currentStep = currentStep.prevS; } } else { if (currentStep.nextS != null) { state = FORWARD; currentStep = currentStep.nextS; } else { // vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } break; case END: currentStep = null; // reset(); return -1; case BACKWARD: if(currentStep.out_of_range){ currentStep.out_of_range = false; transition_DDFP(vn); break; } // currentStep = currentStep.prevS; ap = (AutoPilot) currentStep.o; // vn.push(); //b = false; while (ap.iterate2()) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { b = true; break; } } if (b ) { //if (currentStep.nextS != null) { // vn.push(); // System.out.println(" --++ push in //"); state = FORWARD; currentStep = currentStep.nextS; //} else { // state = TERMINAL; // result = vn.getCurrentIndex(); // if (isUnique(result)) // return result; //} } else transition_DDFP(vn); break; case TERMINAL: if(currentStep.out_of_range){ currentStep.out_of_range = false; transition_DDFP(vn); break; } ap = (AutoPilot) currentStep.o; b = false; while (ap.iterate2()) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { b = true; break; } } if (b) { //if (currentStep.evalPredicates(vn)) { result = vn.getCurrentIndex(); if (isUnique(result)) return result; //} } else{ transition_DDFP(vn); } break; default: throw new XPathEvalException("unknown state"); } return -2; }
protected internal int process_ancestor2( VTDNav vn) { int result; bool b = false, b1 = false; //int contextSize; Predicate t= null; switch(state){ case START: t = currentStep.p; while (t != null) { if (t.requireContext) { int i = computeContextSize( t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize=(i); } t = t.nextP; } if (b1) { state = END; break; } state = END; //if (vn.getCurrentDepth() != -1) { vn.push2(); while (vn.toNode(VTDNav.P)) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { if (currentStep.nextS != null) { state = FORWARD; currentStep = currentStep.nextS; break; } else { //vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } } if (state == END) { if (currentStep.hasPredicate) currentStep.resetP(vn); vn.pop2(); } // } break; case END: currentStep =null; // reset(); return -1; case FORWARD: t = currentStep.p; while(t!=null){ if (t.requireContext){ int i = computeContextSize(t,vn); if (i==0){ b1 = true; break; }else t.ContextSize=(i); } t = t.nextP; } if (b1){ currentStep = currentStep.prevS; state = BACKWARD; break; } state = BACKWARD; vn.push2(); while(vn.toNode(VTDNav.P)){ if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))){ if (currentStep.nextS != null){ state = FORWARD; currentStep = currentStep.nextS; break; } else { //vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if ( isUnique(result)) return result; } } } if ( state == BACKWARD){ if (currentStep.hasPredicate) currentStep.resetP(vn); vn.pop2(); currentStep=currentStep.prevS; } break; case BACKWARD: b = false; vn.push2(); while (vn.toNode(VTDNav.P)) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { if (currentStep.nextS!= null) { state = FORWARD; currentStep = currentStep.nextS; b = true; break; } else { //vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if ( isUnique(result)) return result; } } } if (b==false){ vn.pop2(); if (currentStep.prevS!=null) { if (currentStep.hasPredicate) currentStep.resetP(vn); state = BACKWARD; currentStep = currentStep.prevS; } else { state = END; } } break; case TERMINAL: while (vn.toNode(VTDNav.P)) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { result = vn.getCurrentIndex(); if ( isUnique(result)) return result; } } vn.pop2(); if (currentStep.prevS!=null) { if (currentStep.hasPredicate) currentStep.resetP(vn); state = BACKWARD; currentStep = currentStep.prevS; } else { state = END; } break; default: throw new XPathEvalException("unknown state"); } return -2; }
private String getString(VTDNav vn){ if (argCount() == 0) try { if (vn.atTerminal) { if (vn.getTokenType(vn.LN) == VTDNav.TOKEN_CDATA_VAL) return vn.toRawString(vn.LN); return vn.toString(vn.LN); } return vn.toString(vn.getCurrentIndex()); } catch (NavException e) { return null; // this will almost never occur } else if (argCount() == 1) { return argumentList.e.evalString(vn); } else throw new System.ArgumentException("String()'s argument count is invalid"); }
private String getLocalName(VTDNav vn) { if (argCount() == 0) { try { int index = vn.getCurrentIndex(); int type = vn.getTokenType(index); if (vn.ns && (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME)) { long offset = vn.getTokenOffset(index); int length = vn.getTokenLength(index); if (length < 0x10000) return vn.toRawString(index); else { int preLen = length >> 16; int QLen = length & 0xffff; if (preLen != 0) return vn.toRawString(offset + preLen + 1, QLen - preLen - 1); else { return vn.toRawString(offset, QLen); } } } else return ""; } catch (NavException e) { return ""; // this will almost never occur } } else if (argCount() == 1) { int a = -1; vn.push2(); try { a = argumentList.e.evalNodeSet(vn); argumentList.e.reset(vn); vn.pop2(); } catch (Exception e) { argumentList.e.reset(vn); vn.pop2(); } if (a == -1 || vn.ns == false) return ""; int type = vn.getTokenType(a); if (type != VTDNav.TOKEN_STARTING_TAG && type != VTDNav.TOKEN_ATTR_NAME) return ""; try { long offset = vn.getTokenOffset(a); int length = vn.getTokenLength(a); if (length < 0x10000) return vn.toRawString(a); else { int preLen = length >> 16; int QLen = length & 0xffff; if (preLen != 0) return vn.toRawString(offset + preLen + 1, QLen - preLen - 1); else { return vn.toRawString(offset, QLen); } } } catch (NavException e) { return ""; // this will almost never occur } } else throw new System.ArgumentException ("local-name()'s argument count is invalid"); }
private int process_DDFP(VTDNav vn) { AutoPilot ap; bool b = false, b1 = false; //int contextSize; Predicate t = null; int result; switch (state) { case START: case FORWARD: if (vn.atTerminal) { if (state == START) state = END; else { // no need to set_ft to true // no need to resetP state = BACKWARD; currentStep = currentStep.PrevStep; } break; } t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize = i; } t = t.nextP; } if (b1) { if (state == START) state = END; else { currentStep = currentStep.PrevStep; state = BACKWARD; } break; } System.String helper = null; if (currentStep.nt.testType == NodeTest.NODE) { helper = "*"; } else { helper = currentStep.nt.nodeName; } if (currentStep.o == null) currentStep.o = ap = new AutoPilot(vn); else { ap = (AutoPilot) currentStep.o; ap.bind(vn); } if (currentStep.get_ft() == true) { if (currentStep.axis_type == AxisType.DESCENDANT_OR_SELF) if (currentStep.nt.testType == NodeTest.NODE) ap.Special = true; else ap.Special = false; //currentStep.o = ap = new AutoPilot(vn); if (currentStep.axis_type == AxisType.DESCENDANT_OR_SELF) ap.selectElement(helper); else if (currentStep.axis_type == AxisType.DESCENDANT) ap.selectElement_D(helper); else if (currentStep.axis_type == AxisType.PRECEDING) ap.selectElement_P(helper); else ap.selectElement_F(helper); currentStep.set_ft(false); } if (state == START) state = END; vn.push2(); // not the most efficient. good for now //System.out.println(" --++ push in //"); b = false; while (ap.iterate()) { if (currentStep.evalPredicates(vn)) { b = true; break; } } if (b == false) { vn.pop2(); //System.out.println(" --++ pop in //"); currentStep.set_ft(true); currentStep.resetP(vn); if (state == FORWARD) { state = BACKWARD; currentStep = currentStep.PrevStep; } } else { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; } else { //vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } break; case END: currentStep = null; // reset(); return - 1; case BACKWARD: //currentStep = currentStep.getPrevStep(); ap = (AutoPilot) currentStep.o; //vn.push(); b = false; while (ap.iterate()) { if (currentStep.evalPredicates(vn)) { b = true; break; } } if (b == false) { vn.pop2(); currentStep.set_ft(true); currentStep.resetP(vn); //System.out.println(" --++ pop in //"); if (currentStep.PrevStep != null) { state = BACKWARD; currentStep = currentStep.PrevStep; } else state = END; } else { if (currentStep.NextStep != null) { //vn.push(); //System.out.println(" --++ push in //"); state = FORWARD; currentStep = currentStep.NextStep; } else { state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } break; case TERMINAL: ap = (AutoPilot) currentStep.o; b = false; while (ap.iterate()) { if (currentStep.evalPredicates(vn)) { b = true; break; } } if (b == true) { if (currentStep.evalPredicates(vn)) { result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } else if (currentStep.PrevStep == null) { currentStep.resetP(vn); vn.pop2(); state = END; } else { vn.pop2(); currentStep.set_ft(true); currentStep.resetP(vn); //System.out.println(" --++ pop in //"); state = BACKWARD; //currentStep.ft = true; currentStep = currentStep.PrevStep; } break; default: throw new XPathEvalException("unknown state"); } return - 2; }
private int process_parent(VTDNav vn) { bool b1 = false; //int contextSize; Predicate t = null; int result; switch (state) { case START: case FORWARD: t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize = i; } t = t.nextP; } if (b1) { if (state == FORWARD) { state = BACKWARD; currentStep = currentStep.PrevStep; } else state = END; break; } if (vn.getCurrentDepth() == - 1) { if (state == START) state = END; else { //vn.pop(); state = BACKWARD; currentStep = currentStep.PrevStep; } } else { vn.push2(); vn.toElement(VTDNav.P); // must return true if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; } else { state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } else { vn.pop2(); currentStep.resetP(vn); if (state == START) state = END; else { state = BACKWARD; currentStep = currentStep.PrevStep; } } } break; case END: currentStep = null; // reset(); return - 1; case BACKWARD: case TERMINAL: if (currentStep.PrevStep == null) { vn.pop2(); state = END; break; } else { vn.pop2(); state = BACKWARD; currentStep = currentStep.PrevStep; break; } //goto default; default: throw new XPathEvalException("unknown state"); } return - 2; }
private int process_child(VTDNav vn) { int result; bool b = false, b1 = false; //int contextSize; Predicate t = null; switch (state) { case START: if (currentStep.nt.testType != NodeTest.TEXT) { // first search for any predicate that // requires contextSize // if so, compute its context size // if size > 0 // set context // if size ==0 // immediately set the state to backward or end t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize = i; } t = t.nextP; } if (b1) { state = END; break; } b = vn.toElement(VTDNav.FIRST_CHILD); state = END; if (b == true) { do { if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { //currentStep.position++; state = FORWARD; currentStep = currentStep.NextStep; } else { state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) { return result; } } break; } } while (vn.toElement(VTDNav.NS)); if (state == END) vn.toElement(VTDNav.PARENT); } } else { if (vn.AtTerminal == true) { state = END; } else { // compute context size; t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize=i; } t = t.nextP; } // b1 false indicate context size is zero. no need to go any further... if (b1) { state = END; break; } // get textIter TextIter ti = null; if (currentStep.o != null) { ti = (TextIter)currentStep.o; } else { ti = new TextIter(); currentStep.o = ti; } ti.touch(vn); state = END; while ((result = ti.getNext()) != -1) { if (currentStep.evalPredicates(vn)) { break; } } // old code //result = vn.getText(); if (result != -1) { vn.AtTerminal=true; //currentStep.resetP(vn); vn.LN = result; if (currentStep.NextStep != null) { vn.LN = result; state = FORWARD; currentStep = currentStep.NextStep; } else { //vn.pop(); state = TERMINAL; if (isUnique(result)) { vn.LN = result; return result; } } } else { //currentStep.set_ft(true); currentStep.resetP(vn); vn.AtTerminal=false; } } } break; case END: currentStep = null; // reset(); return - 1; case FORWARD: if (currentStep.nt.testType != NodeTest.TEXT) { t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize = i; } t = t.nextP; } if (b1) { currentStep = currentStep.PrevStep; state = BACKWARD; break; } state = BACKWARD; if (vn.toElement(VTDNav.FC)) { do { if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; } else { state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } //UPGRADE_NOTE: Labeled break statement was changed to a goto statement. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1012'" goto forward_brk; } } while (vn.toElement(VTDNav.NS)); vn.toElement(VTDNav.P); currentStep.resetP(vn); currentStep = currentStep.PrevStep; } else { //vn.toElement(VTDNav.P); currentStep = currentStep.PrevStep; } //UPGRADE_NOTE: Label 'forward_brk' was added. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1011'" forward_brk: ; } else { // predicate at an attribute is not evaled if (vn.AtTerminal == true) { state = BACKWARD; currentStep = currentStep.PrevStep; } else { // compute context size; t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize=i; } t = t.nextP; } // b1 false indicate context size is zero. no need to go any further... if (b1) { state = BACKWARD; break; } // get textIter TextIter ti = null; if (currentStep.o != null) { ti = (TextIter)currentStep.o; } else { ti = new TextIter(); currentStep.o = ti; } ti.touch(vn); //result = ti.getNext(); while ((result = ti.getNext()) != -1) { if (currentStep.evalPredicates(vn)) { break; } } if (result == -1) { //currentStep.set_ft(true); //currentStep.resetP(vn); vn.AtTerminal=false; if (state == FORWARD) { state = BACKWARD; currentStep = currentStep.PrevStep; } } else { vn.AtTerminal=true; if (currentStep.NextStep != null) { vn.LN = result; state = FORWARD; currentStep = currentStep.NextStep; } else { //vn.pop(); state = TERMINAL; if (isUnique(result)) { vn.LN = result; return result; } } } } } break; case BACKWARD: if (currentStep.nt.testType != NodeTest.TEXT) { //currentStep = currentStep.getPrevStep(); b = false; while (vn.toElement(VTDNav.NS)) { if (currentStep.eval(vn)) { b = true; break; } } if (b == true) { state = FORWARD; currentStep = currentStep.NextStep; } else if (currentStep.PrevStep == null) { currentStep.resetP(vn); vn.toElement(VTDNav.P); state = END; } else { currentStep.resetP(vn); state = BACKWARD; vn.toElement(VTDNav.P); currentStep = currentStep.PrevStep; } } else { vn.AtTerminal = false; if (currentStep.PrevStep == null) state = END; else { state = BACKWARD; //vn.setAtTerminal(false); currentStep = currentStep.PrevStep; } } break; case TERMINAL: if (currentStep.nt.testType != NodeTest.TEXT) { while (vn.toElement(VTDNav.NS)) { if (currentStep.eval(vn)) { // state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } currentStep.resetP(vn); if (currentStep.PrevStep == null) { state = END; vn.toElement(VTDNav.P); } else { vn.toElement(VTDNav.P); state = BACKWARD; currentStep = currentStep.PrevStep; } } else { TextIter ti = (TextIter)currentStep.o; while ((result = ti.getNext()) != -1) { if (currentStep.evalPredicates(vn)) { if (isUnique(result)) return result; } } currentStep.resetP(vn); vn.AtTerminal=false; if (currentStep.PrevStep == null) state = END; else { state = BACKWARD; currentStep = currentStep.PrevStep; } } break; default: throw new XPathEvalException("unknown state"); } return - 2; }
private int process_self(VTDNav vn) { bool b1 = false; //int contextSize; Predicate t = null; int result; switch (state) { case START: case FORWARD: t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize = i; } t = t.nextP; } if (b1) { if (state == FORWARD) { state = BACKWARD; currentStep = currentStep.PrevStep; } else state = END; break; } if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; } else { state = TERMINAL; if (vn.atTerminal == true) result = vn.LN; else result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } else { currentStep.resetP(vn); if (state == START) state = END; else state = BACKWARD; } break; case END: currentStep = null; // reset(); return - 1; case BACKWARD: case TERMINAL: if (currentStep.PrevStep != null) { state = BACKWARD; currentStep = currentStep.PrevStep; } else { state = END; } break; default: throw new XPathEvalException("unknown state"); } return - 2; }
private int process_ancestor_or_self(VTDNav vn) { bool b = false, b1 = false; //int contextSize; Predicate t = null; int result; switch (state) { case START: t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize = i; } t = t.nextP; } if (b1) { state = END; break; } state = END; vn.push2(); if (currentStep.get_ft() == true) { currentStep.set_ft(false); if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; break; } else { //vn.pop(); state = TERMINAL; if (vn.atTerminal) result = vn.LN; else result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } } while (vn.toElement(VTDNav.P)) { if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; break; } else { //vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } } if (state == END) { currentStep.resetP(vn); vn.pop2(); } break; case FORWARD: t = currentStep.p; while (t != null) { if (t.requireContextSize()) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize = i; } t = t.nextP; } if (b1) { currentStep = currentStep.PrevStep; state = BACKWARD; break; } state = BACKWARD; vn.push2(); if (currentStep.get_ft() == true) { currentStep.set_ft(false); if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; break; } else { //vn.pop(); state = TERMINAL; if (vn.atTerminal) result = vn.LN; else result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } } while (vn.toElement(VTDNav.P)) { if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; break; } else { //vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } } if (state == BACKWARD) { currentStep.resetP(vn); currentStep.set_ft(true); vn.pop2(); currentStep = currentStep.PrevStep; } break; case END: currentStep = null; // reset(); return - 1; case BACKWARD: b = false; vn.push2(); while (vn.toElement(VTDNav.P)) { if (currentStep.eval(vn)) { if (currentStep.NextStep != null) { state = FORWARD; currentStep = currentStep.NextStep; b = true; break; } else { //vn.pop(); state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } } if (b == false) { vn.pop2(); currentStep.resetP(vn); if (currentStep.PrevStep != null) { currentStep.set_ft(true); state = BACKWARD; currentStep = currentStep.PrevStep; } else { state = END; } } break; case TERMINAL: while (vn.toElement(VTDNav.P)) { if (currentStep.eval(vn)) { result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } vn.pop2(); currentStep.resetP(vn); if (currentStep.PrevStep != null) { currentStep.set_ft(true); state = BACKWARD; currentStep = currentStep.PrevStep; } else { state = END; } break; default: throw new XPathEvalException("unknown state"); } return - 2; }
private String getName(VTDNav vn) { int a; if (argCount1 == 0) { a = vn.getCurrentIndex(); int type = vn.getTokenType(a); if ((type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME || type == VTDNav.TOKEN_PI_NAME)) { try { if (vn.nameIndex != a) { vn.name = vn.toRawString(a); vn.nameIndex = a; } return vn.name; } catch (Exception e) { return ""; } } else return ""; } else if (argCount1 == 1) { a = evalFirstArgumentListNodeSet2(vn); try { if (a == -1 || vn.ns == false) return ""; else { int type = vn.getTokenType(a); if (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME || type == VTDNav.TOKEN_PI_NAME) return vn.toRawString(a); return ""; } } catch (Exception e) { } return ""; } else throw new System.ArgumentException ("name()'s argument count is invalid"); }
private String getName(VTDNav vn) { int a; if (argCount() == 0) { a = vn.getCurrentIndex(); int type = vn.getTokenType(a); if ((type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME)) { try { return vn.toString(a); } catch (Exception e) { return ""; } } else return ""; } else if (argCount() == 1) { a = -1; vn.push2(); try { a = argumentList.e.evalNodeSet(vn); argumentList.e.reset(vn); vn.pop2(); } catch (Exception e) { argumentList.e.reset(vn); vn.pop2(); } try { if (a == -1 || vn.ns == false) return ""; else { int type = vn.getTokenType(a); if (type == VTDNav.TOKEN_STARTING_TAG || type == VTDNav.TOKEN_ATTR_NAME) return vn.toString(a); return ""; } } catch (Exception e) { } return ""; } else throw new System.ArgumentException ("name()'s argument count is invalid"); }
protected internal int process_child2(VTDNav vn) { int result; bool b = false, b1 = false; Predicate t= null; switch(state){ case START: // first search for any predicate that // requires contextSize // if so, compute its context size // if size > 0 // set context // if size ==0 // immediately set the state to backward or end t = currentStep.p; while (t != null) { if (t.requireContext) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize=(i); } t = t.nextP; } if (b1) { state = END; break; } b = vn.toNode(VTDNav.FIRST_CHILD); state = END; if (b) { do { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { if (currentStep.nextS != null) { // currentStep.position++; state = FORWARD; currentStep = currentStep.nextS; } else { state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) { return result; } } break; } } while (vn.toNode(VTDNav.NS)); if (state == END) vn.toNode(VTDNav.PARENT); } break; case END: currentStep = null; // reset(); return -1; case FORWARD: t = currentStep.p; while (t != null) { if (t.requireContext) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize=(i); } t = t.nextP; } if (b1) { currentStep = currentStep.prevS; state = BACKWARD; break; } state = BACKWARD; if (vn.toNode(VTDNav.FC)) { do { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { if (currentStep.nextS != null) { state = FORWARD; currentStep = currentStep.nextS; } else { state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } goto forward; } } while (vn.toNode(VTDNav.NS)); vn.toNode(VTDNav.P); if (currentStep.hasPredicate) currentStep.resetP(vn); currentStep = currentStep.prevS; } else { // vn.toElement(VTDNav.P); currentStep = currentStep.prevS; } forward: break; case BACKWARD: if (currentStep.out_of_range){ currentStep.out_of_range = false; transition_child(vn); break; } // currentStep = currentStep.prevS; //b = false; while (vn.toNode(VTDNav.NS)) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { b = true; break; } } if (b) { state = FORWARD; currentStep = currentStep.nextS; } else{ currentStep.out_of_range = false; transition_child(vn); } break; case TERMINAL: if (currentStep.out_of_range){ currentStep.out_of_range = false; transition_child(vn); break; } while (vn.toNode(VTDNav.NS)) { if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { // state = TERMINAL; result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } currentStep.out_of_range = false; transition_child(vn); break; default: throw new XPathEvalException("unknown state"); } return -2; }
private System.String normalizeSpace(VTDNav vn) { if (argCount() == 0) { String s = null; try { if (vn.atTerminal) { int ttype = vn.getTokenType(vn.LN); if (ttype == VTDNav.TOKEN_CDATA_VAL) s = vn.toRawString(vn.LN); else if (ttype == VTDNav.TOKEN_ATTR_NAME || ttype == VTDNav.TOKEN_ATTR_NS) { s = vn.toString(vn.LN + 1); } else s = vn.toString(vn.LN); }else s = vn.toString(vn.getCurrentIndex()); return normalize(s); } catch (NavException e) { return ""; // this will almost never occur } } else if (argCount() == 1) { String s = argumentList.e.evalString(vn); return normalize(s); } throw new System.ArgumentException("normalize-space()'s argument count is invalid"); //return null; }
protected int process_preceding_sibling2(VTDNav vn) { bool b = false, b1 = false; Predicate t= null; int result; switch(state){ case START: case FORWARD: t = currentStep.p; while(t!=null){ if (t.requireContext){ int i = computeContextSize(t,vn); if (i==0){ b1 = true; break; }else t.ContextSize=(i); } t = t.nextP; } if (b1){ if (state == FORWARD){ state = BACKWARD; currentStep = currentStep.prevS; }else state = END; break; } if ( state == START) state = END; else state = BACKWARD; vn.push2(); while (vn.toNode(VTDNav.PS)){ if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))){ if (currentStep.nextS!=null){ state = FORWARD; currentStep = currentStep.nextS; break; } else { state = TERMINAL; result = vn.getCurrentIndex(); if ( isUnique(result)) return result; } } } if (state == END) { if (currentStep.hasPredicate) currentStep.resetP(vn); vn.pop2(); } else if ( state == BACKWARD){ if (currentStep.hasPredicate) currentStep.resetP(vn); vn.pop2(); currentStep = currentStep.prevS; } break; case END: currentStep = null; // reset(); return -1; case BACKWARD: if (currentStep.out_of_range) { currentStep.out_of_range = false; transition_preceding_sibling(vn); break; } while (vn.toNode(VTDNav.PS)){ if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))){ if (currentStep.nextS!=null){ state = FORWARD; currentStep = currentStep.nextS; b = true; break; } else { state = TERMINAL; result = vn.getCurrentIndex(); if ( isUnique(result)) return result; } } } if (b==false){ currentStep.out_of_range = false; transition_preceding_sibling(vn); } break; case TERMINAL: if (currentStep.out_of_range) { currentStep.out_of_range = false; transition_preceding_sibling(vn); break; } while (vn.toNode(VTDNav.PS)){ if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))){ // state = TERMINAL; result = vn.getCurrentIndex(); if ( isUnique(result)) return result; } } currentStep.out_of_range = false; transition_preceding_sibling(vn); break; default: throw new XPathEvalException("unknown state"); } return -2; }
protected int process_self2(VTDNav vn) { bool b1 = false; Predicate t = null; int result; switch (state) { case START: case FORWARD: t = currentStep.p; while (t != null) { if (t.requireContext) { int i = computeContextSize(t, vn); if (i == 0) { b1 = true; break; } else t.ContextSize=(i); } t = t.nextP; } if (b1) { if (state == FORWARD) { state = BACKWARD; currentStep = currentStep.prevS; } else state = END; break; } if ((currentStep.nt_eval || currentStep.nt.eval2(vn)) && ((!currentStep.hasPredicate) || currentStep.evalPredicates(vn))) { if (currentStep.nextS != null) { state = FORWARD; currentStep = currentStep.nextS; } else { state = TERMINAL; if (vn.atTerminal) result = vn.LN; else result = vn.getCurrentIndex(); if (isUnique(result)) return result; } } else { if (currentStep.hasPredicate) currentStep.resetP(vn); if (state == START) state = END; else state = BACKWARD; } break; case END: currentStep = null; // reset(); return -1; case BACKWARD: case TERMINAL: if (currentStep.prevS != null) { state = BACKWARD; currentStep = currentStep.prevS; } else { state = END; } break; default: throw new XPathEvalException("unknown state"); } return -2; }