| Methods Summary |
|---|
| protected com.sun.org.apache.xpath.internal.Expression | and(int opPos)Compile an 'and' operation.
return compileOperation(new And(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | arg(int opPos)Compile a function argument.
// no-op
return compile(opPos + 2);
|
| public void | assertion(boolean b, java.lang.String msg)Tell the user of an assertion error, and probably throw an
exception.
if (!b)
{
java.lang.String fMsg = XSLMessages.createXPATHMessage(
XPATHErrorResources.ER_INCORRECT_PROGRAMMER_ASSERTION,
new Object[]{ msg });
throw new RuntimeException(fMsg);
}
|
| protected com.sun.org.apache.xpath.internal.Expression | bool(int opPos)Compile a 'boolean(...)' operation.
return compileUnary(new com.sun.org.apache.xpath.internal.operations.Bool(), opPos);
|
| public com.sun.org.apache.xpath.internal.Expression | compile(int opPos)Execute the XPath object from a given opcode position.
int op = getOp(opPos);
Expression expr = null;
// System.out.println(getPatternString()+"op: "+op);
switch (op)
{
case OpCodes.OP_XPATH :
expr = compile(opPos + 2); break;
case OpCodes.OP_OR :
expr = or(opPos); break;
case OpCodes.OP_AND :
expr = and(opPos); break;
case OpCodes.OP_NOTEQUALS :
expr = notequals(opPos); break;
case OpCodes.OP_EQUALS :
expr = equals(opPos); break;
case OpCodes.OP_LTE :
expr = lte(opPos); break;
case OpCodes.OP_LT :
expr = lt(opPos); break;
case OpCodes.OP_GTE :
expr = gte(opPos); break;
case OpCodes.OP_GT :
expr = gt(opPos); break;
case OpCodes.OP_PLUS :
expr = plus(opPos); break;
case OpCodes.OP_MINUS :
expr = minus(opPos); break;
case OpCodes.OP_MULT :
expr = mult(opPos); break;
case OpCodes.OP_DIV :
expr = div(opPos); break;
case OpCodes.OP_MOD :
expr = mod(opPos); break;
// case OpCodes.OP_QUO :
// expr = quo(opPos); break;
case OpCodes.OP_NEG :
expr = neg(opPos); break;
case OpCodes.OP_STRING :
expr = string(opPos); break;
case OpCodes.OP_BOOL :
expr = bool(opPos); break;
case OpCodes.OP_NUMBER :
expr = number(opPos); break;
case OpCodes.OP_UNION :
expr = union(opPos); break;
case OpCodes.OP_LITERAL :
expr = literal(opPos); break;
case OpCodes.OP_VARIABLE :
expr = variable(opPos); break;
case OpCodes.OP_GROUP :
expr = group(opPos); break;
case OpCodes.OP_NUMBERLIT :
expr = numberlit(opPos); break;
case OpCodes.OP_ARGUMENT :
expr = arg(opPos); break;
case OpCodes.OP_EXTFUNCTION :
expr = compileExtension(opPos); break;
case OpCodes.OP_FUNCTION :
expr = compileFunction(opPos); break;
case OpCodes.OP_LOCATIONPATH :
expr = locationPath(opPos); break;
case OpCodes.OP_PREDICATE :
expr = null; break; // should never hit this here.
case OpCodes.OP_MATCHPATTERN :
expr = matchPattern(opPos + 2); break;
case OpCodes.OP_LOCATIONPATHPATTERN :
expr = locationPathPattern(opPos); break;
case OpCodes.OP_QUO:
error(XPATHErrorResources.ER_UNKNOWN_OPCODE,
new Object[]{ "quo" }); //"ERROR! Unknown op code: "+m_opMap[opPos]);
break;
default :
error(XPATHErrorResources.ER_UNKNOWN_OPCODE,
new Object[]{ Integer.toString(getOp(opPos)) }); //"ERROR! Unknown op code: "+m_opMap[opPos]);
}
// if(null != expr)
// expr.setSourceLocator(m_locator);
return expr;
|
| private com.sun.org.apache.xpath.internal.Expression | compileExtension(int opPos)Compile an extension function.
int endExtFunc = opPos + getOp(opPos + 1) - 1;
opPos = getFirstChildPos(opPos);
java.lang.String ns = (java.lang.String) getTokenQueue().elementAt(getOp(opPos));
opPos++;
java.lang.String funcName =
(java.lang.String) getTokenQueue().elementAt(getOp(opPos));
opPos++;
// We create a method key to uniquely identify this function so that we
// can cache the object needed to invoke it. This way, we only pay the
// reflection overhead on the first call.
Function extension = new FuncExtFunction(ns, funcName, String.valueOf(getNextMethodId()));
try
{
int i = 0;
while (opPos < endExtFunc)
{
int nextOpPos = getNextOpPos(opPos);
extension.setArg(this.compile(opPos), i);
opPos = nextOpPos;
i++;
}
}
catch (WrongNumberArgsException wnae)
{
; // should never happen
}
return extension;
|
| com.sun.org.apache.xpath.internal.Expression | compileFunction(int opPos)Compile a built-in XPath function.
int endFunc = opPos + getOp(opPos + 1) - 1;
opPos = getFirstChildPos(opPos);
int funcID = getOp(opPos);
opPos++;
if (-1 != funcID)
{
Function func = FunctionTable.getFunction(funcID);
func.postCompileStep(this);
try
{
int i = 0;
for (int p = opPos; p < endFunc; p = getNextOpPos(p), i++)
{
// System.out.println("argPos: "+ p);
// System.out.println("argCode: "+ m_opMap[p]);
func.setArg(compile(p), i);
}
func.checkNumberArgs(i);
}
catch (WrongNumberArgsException wnae)
{
java.lang.String name = FunctionTable.getFunctionName(funcID);
m_errorHandler.fatalError( new TransformerException(
XSLMessages.createXPATHMessage(XPATHErrorResources.ER_ONLY_ALLOWS,
new Object[]{name, wnae.getMessage()}), m_locator));
//"name + " only allows " + wnae.getMessage() + " arguments", m_locator));
}
return func;
}
else
{
error(XPATHErrorResources.ER_FUNCTION_TOKEN_NOT_FOUND, null); //"function token not found.");
return null;
}
|
| private com.sun.org.apache.xpath.internal.Expression | compileOperation(com.sun.org.apache.xpath.internal.operations.Operation operation, int opPos)Bottle-neck compilation of an operation with left and right operands.
int leftPos = getFirstChildPos(opPos);
int rightPos = getNextOpPos(leftPos);
operation.setLeftRight(compile(leftPos), compile(rightPos));
return operation;
|
| private void | compilePredicates(int opPos, com.sun.org.apache.xpath.internal.Expression[] predicates)Compiles predicates in the step.
for (int i = 0; OpCodes.OP_PREDICATE == getOp(opPos); i++)
{
predicates[i] = predicate(opPos);
opPos = getNextOpPos(opPos);
}
|
| private com.sun.org.apache.xpath.internal.Expression | compileUnary(com.sun.org.apache.xpath.internal.operations.UnaryOperation unary, int opPos)Bottle-neck compilation of a unary operation.
int rightPos = getFirstChildPos(opPos);
unary.setRight(compile(rightPos));
return unary;
|
| public int | countPredicates(int opPos)Count the number of predicates in the step.
int count = 0;
while (OpCodes.OP_PREDICATE == getOp(opPos))
{
count++;
opPos = getNextOpPos(opPos);
}
return count;
|
| protected com.sun.org.apache.xpath.internal.Expression | div(int opPos)Compile a 'div' operation.
return compileOperation(new Div(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | equals(int opPos)Compile a '=' operation.
return compileOperation(new Equals(), opPos);
|
| public void | error(java.lang.String msg, java.lang.Object[] args)Tell the user of an error, and probably throw an
exception.
java.lang.String fmsg = XSLMessages.createXPATHMessage(msg, args);
if (null != m_errorHandler)
{
m_errorHandler.fatalError(new TransformerException(fmsg, m_locator));
}
else
{
// System.out.println(te.getMessage()
// +"; file "+te.getSystemId()
// +"; line "+te.getLineNumber()
// +"; column "+te.getColumnNumber());
throw new TransformerException(fmsg, (SAXSourceLocator)m_locator);
}
|
| public com.sun.org.apache.xpath.internal.Expression[] | getCompiledPredicates(int opPos)Compile a zero or more predicates for a given match pattern.
int count = countPredicates(opPos);
if (count > 0)
{
Expression[] predicates = new Expression[count];
compilePredicates(opPos, predicates);
return predicates;
}
return null;
|
| public int | getLocationPathDepth()Get the level of the location path or union being constructed.
return locPathDepth;
|
| public com.sun.org.apache.xml.internal.utils.PrefixResolver | getNamespaceContext()Get the current namespace context for the xpath.
return m_currentPrefixResolver;
|
| private synchronized long | getNextMethodId()Get the next available method id
if (s_nextMethodId == Long.MAX_VALUE)
s_nextMethodId = 0;
return s_nextMethodId++;
|
| public int | getWhatToShow(int opPos)Get a {@link org.w3c.dom.traversal.NodeFilter} bit set that tells what
to show for a given node test.
int axesType = getOp(opPos);
int testType = getOp(opPos + 3);
// System.out.println("testType: "+testType);
switch (testType)
{
case OpCodes.NODETYPE_COMMENT :
return DTMFilter.SHOW_COMMENT;
case OpCodes.NODETYPE_TEXT :
// return DTMFilter.SHOW_TEXT | DTMFilter.SHOW_COMMENT;
return DTMFilter.SHOW_TEXT | DTMFilter.SHOW_CDATA_SECTION ;
case OpCodes.NODETYPE_PI :
return DTMFilter.SHOW_PROCESSING_INSTRUCTION;
case OpCodes.NODETYPE_NODE :
// return DTMFilter.SHOW_ALL;
switch (axesType)
{
case OpCodes.FROM_NAMESPACE:
return DTMFilter.SHOW_NAMESPACE;
case OpCodes.FROM_ATTRIBUTES :
case OpCodes.MATCH_ATTRIBUTE :
return DTMFilter.SHOW_ATTRIBUTE;
case OpCodes.FROM_SELF:
case OpCodes.FROM_ANCESTORS_OR_SELF:
case OpCodes.FROM_DESCENDANTS_OR_SELF:
return DTMFilter.SHOW_ALL;
default:
if (getOp(0) == OpCodes.OP_MATCHPATTERN)
return ~DTMFilter.SHOW_ATTRIBUTE
& ~DTMFilter.SHOW_DOCUMENT
& ~DTMFilter.SHOW_DOCUMENT_FRAGMENT;
else
return ~DTMFilter.SHOW_ATTRIBUTE;
}
case OpCodes.NODETYPE_ROOT :
return DTMFilter.SHOW_DOCUMENT | DTMFilter.SHOW_DOCUMENT_FRAGMENT;
case OpCodes.NODETYPE_FUNCTEST :
return NodeTest.SHOW_BYFUNCTION;
case OpCodes.NODENAME :
switch (axesType)
{
case OpCodes.FROM_NAMESPACE :
return DTMFilter.SHOW_NAMESPACE;
case OpCodes.FROM_ATTRIBUTES :
case OpCodes.MATCH_ATTRIBUTE :
return DTMFilter.SHOW_ATTRIBUTE;
// break;
case OpCodes.MATCH_ANY_ANCESTOR :
case OpCodes.MATCH_IMMEDIATE_ANCESTOR :
return DTMFilter.SHOW_ELEMENT;
// break;
default :
return DTMFilter.SHOW_ELEMENT;
}
default :
// System.err.println("We should never reach here.");
return DTMFilter.SHOW_ALL;
}
|
| protected com.sun.org.apache.xpath.internal.Expression | group(int opPos)Compile an expression group.
// no-op
return compile(opPos + 2);
|
| protected com.sun.org.apache.xpath.internal.Expression | gt(int opPos)Compile a '>' operation.
return compileOperation(new Gt(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | gte(int opPos)Compile a '>=' operation.
return compileOperation(new Gte(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | literal(int opPos)Compile a literal string value.
opPos = getFirstChildPos(opPos);
return (XString) getTokenQueue().elementAt(getOp(opPos));
|
| public com.sun.org.apache.xpath.internal.Expression | locationPath(int opPos)Compile a location path. The LocPathIterator itself may create
{@link com.sun.org.apache.xpath.internal.axes.AxesWalker} children.
locPathDepth++;
try
{
DTMIterator iter = WalkerFactory.newDTMIterator(this, opPos, (locPathDepth == 0));
return (Expression)iter; // cast OK, I guess.
}
finally
{
locPathDepth--;
}
|
| public com.sun.org.apache.xpath.internal.Expression | locationPathPattern(int opPos)Compile a location match pattern unit expression.
opPos = getFirstChildPos(opPos);
return stepPattern(opPos, 0, null);
|
| protected com.sun.org.apache.xpath.internal.Expression | lt(int opPos)Compile a '<' operation.
return compileOperation(new Lt(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | lte(int opPos)Compile a '<=' operation.
return compileOperation(new Lte(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | matchPattern(int opPos)Compile an entire match pattern expression.
locPathDepth++;
try
{
// First, count...
int nextOpPos = opPos;
int i;
for (i = 0; getOp(nextOpPos) == OpCodes.OP_LOCATIONPATHPATTERN; i++)
{
nextOpPos = getNextOpPos(nextOpPos);
}
if (i == 1)
return compile(opPos);
UnionPattern up = new UnionPattern();
StepPattern[] patterns = new StepPattern[i];
for (i = 0; getOp(opPos) == OpCodes.OP_LOCATIONPATHPATTERN; i++)
{
nextOpPos = getNextOpPos(opPos);
patterns[i] = (StepPattern) compile(opPos);
opPos = nextOpPos;
}
up.setPatterns(patterns);
return up;
}
finally
{
locPathDepth--;
}
|
| protected com.sun.org.apache.xpath.internal.Expression | minus(int opPos)Compile a '-' operation.
return compileOperation(new Minus(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | mod(int opPos)Compile a 'mod' operation.
return compileOperation(new Mod(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | mult(int opPos)Compile a '*' operation.
return compileOperation(new Mult(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | neg(int opPos)Compile a unary '-' operation.
return compileUnary(new Neg(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | notequals(int opPos)Compile a '!=' operation.
return compileOperation(new NotEquals(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | number(int opPos)Compile a 'number(...)' operation.
return compileUnary(new com.sun.org.apache.xpath.internal.operations.Number(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | numberlit(int opPos)Compile a literal number value.
opPos = getFirstChildPos(opPos);
return (XNumber) getTokenQueue().elementAt(getOp(opPos));
|
| protected com.sun.org.apache.xpath.internal.Expression | or(int opPos)Compile an 'or' operation.
return compileOperation(new Or(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | plus(int opPos)Compile a '+' operation.
return compileOperation(new Plus(), opPos);
|
| public com.sun.org.apache.xpath.internal.Expression | predicate(int opPos)Compile a location step predicate expression.
return compile(opPos + 2);
|
| public void | setNamespaceContext(com.sun.org.apache.xml.internal.utils.PrefixResolver pr)Set the current namespace context for the xpath.
m_currentPrefixResolver = pr;
|
| protected com.sun.org.apache.xpath.internal.patterns.StepPattern | stepPattern(int opPos, int stepCount, com.sun.org.apache.xpath.internal.patterns.StepPattern ancestorPattern)Compile a step pattern unit expression, used for both location paths
and match patterns.
int startOpPos = opPos;
int stepType = getOp(opPos);
if (OpCodes.ENDOP == stepType)
{
return null;
}
boolean addMagicSelf = true;
int endStep = getNextOpPos(opPos);
// int nextStepType = getOpMap()[endStep];
StepPattern pattern;
// boolean isSimple = ((OpCodes.ENDOP == nextStepType) && (stepCount == 0));
int argLen;
switch (stepType)
{
case OpCodes.OP_FUNCTION :
if(DEBUG)
System.out.println("MATCH_FUNCTION: "+m_currentPattern);
addMagicSelf = false;
argLen = getOp(opPos + OpMap.MAPINDEX_LENGTH);
pattern = new FunctionPattern(compileFunction(opPos), Axis.PARENT, Axis.CHILD);
break;
case OpCodes.FROM_ROOT :
if(DEBUG)
System.out.println("FROM_ROOT, "+m_currentPattern);
addMagicSelf = false;
argLen = getArgLengthOfStep(opPos);
opPos = getFirstChildPosOfStep(opPos);
pattern = new StepPattern(DTMFilter.SHOW_DOCUMENT |
DTMFilter.SHOW_DOCUMENT_FRAGMENT,
Axis.PARENT, Axis.CHILD);
break;
case OpCodes.MATCH_ATTRIBUTE :
if(DEBUG)
System.out.println("MATCH_ATTRIBUTE: "+getStepLocalName(startOpPos)+", "+m_currentPattern);
argLen = getArgLengthOfStep(opPos);
opPos = getFirstChildPosOfStep(opPos);
pattern = new StepPattern(DTMFilter.SHOW_ATTRIBUTE,
getStepNS(startOpPos),
getStepLocalName(startOpPos),
Axis.PARENT, Axis.ATTRIBUTE);
break;
case OpCodes.MATCH_ANY_ANCESTOR :
if(DEBUG)
System.out.println("MATCH_ANY_ANCESTOR: "+getStepLocalName(startOpPos)+", "+m_currentPattern);
argLen = getArgLengthOfStep(opPos);
opPos = getFirstChildPosOfStep(opPos);
int what = getWhatToShow(startOpPos);
// bit-o-hackery, but this code is due for the morgue anyway...
if(0x00000500 == what)
addMagicSelf = false;
pattern = new StepPattern(getWhatToShow(startOpPos),
getStepNS(startOpPos),
getStepLocalName(startOpPos),
Axis.ANCESTOR, Axis.CHILD);
break;
case OpCodes.MATCH_IMMEDIATE_ANCESTOR :
if(DEBUG)
System.out.println("MATCH_IMMEDIATE_ANCESTOR: "+getStepLocalName(startOpPos)+", "+m_currentPattern);
argLen = getArgLengthOfStep(opPos);
opPos = getFirstChildPosOfStep(opPos);
pattern = new StepPattern(getWhatToShow(startOpPos),
getStepNS(startOpPos),
getStepLocalName(startOpPos),
Axis.PARENT, Axis.CHILD);
break;
default :
error(XPATHErrorResources.ER_UNKNOWN_MATCH_OPERATION, null); //"unknown match operation!");
return null;
}
pattern.setPredicates(getCompiledPredicates(opPos + argLen));
if(null == ancestorPattern)
{
// This is the magic and invisible "." at the head of every
// match pattern, and corresponds to the current node in the context
// list, from where predicates are counted.
// So, in order to calculate "foo[3]", it has to count from the
// current node in the context list, so, from that current node,
// the full pattern is really "self::node()/child::foo[3]". If you
// translate this to a select pattern from the node being tested,
// which is really how we're treating match patterns, it works out to
// self::foo/parent::node[child::foo[3]]", or close enough.
/* if(addMagicSelf && pattern.getPredicateCount() > 0)
{
StepPattern selfPattern = new StepPattern(DTMFilter.SHOW_ALL,
Axis.PARENT, Axis.CHILD);
// We need to keep the new nodetest from affecting the score...
XNumber score = pattern.getStaticScore();
pattern.setRelativePathPattern(selfPattern);
pattern.setStaticScore(score);
selfPattern.setStaticScore(score);
}*/
}
else
{
// System.out.println("Setting "+ancestorPattern+" as relative to "+pattern);
pattern.setRelativePathPattern(ancestorPattern);
}
StepPattern relativePathPattern = stepPattern(endStep, stepCount + 1,
pattern);
return (null != relativePathPattern) ? relativePathPattern : pattern;
|
| protected com.sun.org.apache.xpath.internal.Expression | string(int opPos)Compile a 'string(...)' operation.
return compileUnary(new com.sun.org.apache.xpath.internal.operations.String(), opPos);
|
| protected com.sun.org.apache.xpath.internal.Expression | union(int opPos)Compile a location path union. The UnionPathIterator itself may create
{@link com.sun.org.apache.xpath.internal.axes.LocPathIterator} children.
locPathDepth++;
try
{
return UnionPathIterator.createUnionIterator(this, opPos);
}
finally
{
locPathDepth--;
}
|
| protected com.sun.org.apache.xpath.internal.Expression | variable(int opPos)Compile a variable reference.
Variable var = new Variable();
opPos = getFirstChildPos(opPos);
int nsPos = getOp(opPos);
java.lang.String namespace
= (OpCodes.EMPTY == nsPos) ? null
: (java.lang.String) getTokenQueue().elementAt(nsPos);
java.lang.String localname
= (java.lang.String) getTokenQueue().elementAt(getOp(opPos+1));
QName qname = new QName(namespace, localname);
var.setQName(qname);
return var;
|
| public void | warn(java.lang.String msg, java.lang.Object[] args)Warn the user of an problem.
java.lang.String fmsg = XSLMessages.createXPATHWarning(msg, args);
if (null != m_errorHandler)
{
m_errorHandler.warning(new TransformerException(fmsg, m_locator));
}
else
{
System.out.println(fmsg
+"; file "+m_locator.getSystemId()
+"; line "+m_locator.getLineNumber()
+"; column "+m_locator.getColumnNumber());
}
|
