| Methods Summary |
|---|
| protected void | addAttribute(java.lang.String qname, java.lang.String value)
_attributes.add(qname, value);
|
| protected final void | addElement(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode element)Adds a child node to this syntax tree node.
_contents.addElement(element);
element.setParent(this);
|
| protected void | addPrefixMapping(java.lang.String prefix, java.lang.String uri)Adds a single prefix mapping to this syntax tree node.
if (_prefixMapping == null)
_prefixMapping = new Hashtable();
_prefixMapping.put(prefix, uri);
|
| protected void | compileResultTree(com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator classGen, com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator methodGen)Utility method used by parameters and variables to store result trees
final ConstantPoolGen cpg = classGen.getConstantPool();
final InstructionList il = methodGen.getInstructionList();
final Stylesheet stylesheet = classGen.getStylesheet();
boolean isSimple = isSimpleRTF(this);
boolean isAdaptive = false;
if (!isSimple) {
isAdaptive = isAdaptiveRTF(this);
}
int rtfType = isSimple ? DOM.SIMPLE_RTF
: (isAdaptive ? DOM.ADAPTIVE_RTF : DOM.TREE_RTF);
// Save the current handler base on the stack
il.append(methodGen.loadHandler());
final String DOM_CLASS = classGen.getDOMClass();
// Create new instance of DOM class (with RTF_INITIAL_SIZE nodes)
//int index = cpg.addMethodref(DOM_IMPL, "<init>", "(I)V");
//il.append(new NEW(cpg.addClass(DOM_IMPL)));
il.append(methodGen.loadDOM());
int index = cpg.addInterfaceMethodref(DOM_INTF,
"getResultTreeFrag",
"(IIZ)" + DOM_INTF_SIG);
il.append(new PUSH(cpg, RTF_INITIAL_SIZE));
il.append(new PUSH(cpg, rtfType));
il.append(new PUSH(cpg, stylesheet.callsNodeset()));
il.append(new INVOKEINTERFACE(index,4));
il.append(DUP);
// Overwrite old handler with DOM handler
index = cpg.addInterfaceMethodref(DOM_INTF,
"getOutputDomBuilder",
"()" + TRANSLET_OUTPUT_SIG);
il.append(new INVOKEINTERFACE(index,1));
il.append(DUP);
il.append(methodGen.storeHandler());
// Call startDocument on the new handler
il.append(methodGen.startDocument());
// Instantiate result tree fragment
translateContents(classGen, methodGen);
// Call endDocument on the new handler
il.append(methodGen.loadHandler());
il.append(methodGen.endDocument());
// Check if we need to wrap the DOMImpl object in a DOMAdapter object.
// DOMAdapter is not needed if the RTF is a simple RTF and the nodeset()
// function is not used.
if (stylesheet.callsNodeset()
&& !DOM_CLASS.equals(DOM_IMPL_CLASS)) {
// new com.sun.org.apache.xalan.internal.xsltc.dom.DOMAdapter(DOMImpl,String[]);
index = cpg.addMethodref(DOM_ADAPTER_CLASS,
"<init>",
"("+DOM_INTF_SIG+
"["+STRING_SIG+
"["+STRING_SIG+
"[I"+
"["+STRING_SIG+")V");
il.append(new NEW(cpg.addClass(DOM_ADAPTER_CLASS)));
il.append(new DUP_X1());
il.append(SWAP);
/*
* Give the DOM adapter an empty type mapping if the nodeset
* extension function is never called.
*/
if (!stylesheet.callsNodeset()) {
il.append(new ICONST(0));
il.append(new ANEWARRAY(cpg.addClass(STRING)));
il.append(DUP);
il.append(DUP);
il.append(new ICONST(0));
il.append(new NEWARRAY(BasicType.INT));
il.append(SWAP);
il.append(new INVOKESPECIAL(index));
}
else {
// Push name arrays on the stack
il.append(ALOAD_0);
il.append(new GETFIELD(cpg.addFieldref(TRANSLET_CLASS,
NAMES_INDEX,
NAMES_INDEX_SIG)));
il.append(ALOAD_0);
il.append(new GETFIELD(cpg.addFieldref(TRANSLET_CLASS,
URIS_INDEX,
URIS_INDEX_SIG)));
il.append(ALOAD_0);
il.append(new GETFIELD(cpg.addFieldref(TRANSLET_CLASS,
TYPES_INDEX,
TYPES_INDEX_SIG)));
il.append(ALOAD_0);
il.append(new GETFIELD(cpg.addFieldref(TRANSLET_CLASS,
NAMESPACE_INDEX,
NAMESPACE_INDEX_SIG)));
// Initialized DOM adapter
il.append(new INVOKESPECIAL(index));
// Add DOM adapter to MultiDOM class by calling addDOMAdapter()
il.append(DUP);
il.append(methodGen.loadDOM());
il.append(new CHECKCAST(cpg.addClass(classGen.getDOMClass())));
il.append(SWAP);
index = cpg.addMethodref(MULTI_DOM_CLASS,
"addDOMAdapter",
"(" + DOM_ADAPTER_SIG + ")I");
il.append(new INVOKEVIRTUAL(index));
il.append(POP); // ignore mask returned by addDOMAdapter
}
}
// Restore old handler base from stack
il.append(SWAP);
il.append(methodGen.storeHandler());
|
| protected boolean | contextDependent()Returns true if this expression/instruction depends on the context. By
default, every expression/instruction depends on the context unless it
overrides this method. Currently used to determine if result trees are
compiled using procedures or little DOMs (result tree fragments).
return true;
|
| protected boolean | dependentContents()Return true if any of the expressions/instructions in the contents of
this node is context dependent.
final int n = elementCount();
for (int i = 0; i < n; i++) {
final SyntaxTreeNode item = (SyntaxTreeNode)_contents.elementAt(i);
if (item.contextDependent()) {
return true;
}
}
return false;
|
| public void | display(int indent)Displays the contents of this syntax tree node (to stdout).
This method is intended for debugging _only_, and should be overridden
by all syntax tree node implementations.
displayContents(indent);
|
| protected void | displayContents(int indent)Displays the contents of this syntax tree node (to stdout).
This method is intended for debugging _only_ !!!
final int n = elementCount();
for (int i = 0; i < n; i++) {
SyntaxTreeNode item = (SyntaxTreeNode)_contents.elementAt(i);
item.display(indent);
}
|
| protected final java.lang.Object | elementAt(int pos)Returns a child node at a given position.
return _contents.elementAt(pos);
|
| protected final int | elementCount()Returns the number of children this node has.
return _contents.size();
|
| protected final java.util.Enumeration | elements()Returns an Enumeration of all child nodes of this node.
return _contents.elements();
|
| protected java.lang.String | getAttribute(java.lang.String qname)Returns a value for an attribute from the source element.
if (_attributes == null) {
return EMPTYSTRING;
}
final String value = _attributes.getValue(qname);
return (value == null || value.equals(EMPTYSTRING)) ?
EMPTYSTRING : value;
|
| protected java.lang.String | getAttribute(java.lang.String prefix, java.lang.String localName)
return getAttribute(prefix + ':" + localName);
|
| protected org.xml.sax.Attributes | getAttributes()Returns a list of all attributes declared for the element represented by
this syntax tree node.
return(_attributes);
|
| protected final java.util.Vector | getContents()Returns a Vector containing all the child nodes of this node.
return _contents;
|
| protected int | getImportPrecedence()Get the import precedence of this element. The import precedence equals
the import precedence of the stylesheet in which this element occured.
Stylesheet stylesheet = getStylesheet();
if (stylesheet == null) return Integer.MIN_VALUE;
return stylesheet.getImportPrecedence();
|
| public final int | getLineNumber()Get the source file line number for this element. If unavailable, lookup
in ancestors.
if (_line > 0) return _line;
SyntaxTreeNode parent = getParent();
return (parent != null) ? parent.getLineNumber() : 0;
|
| protected final com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode | getParent()Returns this syntax tree node's parent node.
return _parent;
|
| public final com.sun.org.apache.xalan.internal.xsltc.compiler.Parser | getParser()Returns this node's XSLT parser.
return _parser;
|
| protected java.util.Hashtable | getPrefixMapping()Returns a Hashtable containing the prefix mappings that were declared
for this element. This does not include all prefix mappings in scope,
so one may have to check ancestor elements to get all mappings that are
in in scope.
return _prefixMapping;
|
| protected com.sun.org.apache.xalan.internal.xsltc.compiler.QName | getQName()Set the QName for the SyntaxTreeNode
return(_qname);
|
| public com.sun.org.apache.xalan.internal.xsltc.compiler.Stylesheet | getStylesheet()Get the Stylesheet node that represents the element
that this node occured under.
if (_stylesheet == null) {
SyntaxTreeNode parent = this;
while (parent != null) {
if (parent instanceof Stylesheet)
return((Stylesheet)parent);
parent = parent.getParent();
}
_stylesheet = (Stylesheet)parent;
}
return(_stylesheet);
|
| protected final com.sun.org.apache.xalan.internal.xsltc.compiler.SymbolTable | getSymbolTable()Returns the XSLT parser's symbol table.
return (_parser == null) ? null : _parser.getSymbolTable();
|
| protected com.sun.org.apache.xalan.internal.xsltc.compiler.Template | getTemplate()Get the Template node that represents the element
that this node occured under. Note that this method will return 'null'
for nodes that represent top-level elements.
if (_template == null) {
SyntaxTreeNode parent = this;
while ((parent != null) && (!(parent instanceof Template)))
parent = parent.getParent();
_template = (Template)parent;
}
return(_template);
|
| protected final com.sun.org.apache.xalan.internal.xsltc.compiler.XSLTC | getXSLTC()Returns a reference to the XSLTC (XSLT compiler) in use.
return _parser.getXSLTC();
|
| protected boolean | hasAttribute(java.lang.String qname)
return (_attributes != null && _attributes.getValue(qname) != null);
|
| protected final boolean | hasContents()Tells you if this node has any child nodes.
return elementCount() > 0;
|
| protected final void | indent(int indent)Set the indentation level for debug output.
System.out.print(new String(_spaces, 0, indent));
|
| private boolean | isAdaptiveRTF(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode node)Return true if the node represents an adaptive RTF.
A node is an adaptive RTF if each children is a Text element
or it is or .
Vector contents = node.getContents();
for (int i = 0; i < contents.size(); i++) {
SyntaxTreeNode item = (SyntaxTreeNode)contents.elementAt(i);
if (!isTextElement(item, true))
return false;
}
return true;
|
| protected final boolean | isDummy()Returns 'true' if this syntax tree node is the Sentinal node.
return this == Dummy;
|
| private boolean | isSimpleRTF(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode node)Return true if the node represents a simple RTF.
A node is a simple RTF if all children only produce Text value.
Vector contents = node.getContents();
for (int i = 0; i < contents.size(); i++) {
SyntaxTreeNode item = (SyntaxTreeNode)contents.elementAt(i);
if (!isTextElement(item, false))
return false;
}
return true;
|
| private boolean | isTextElement(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode node, boolean doExtendedCheck)Return true if the node only produces Text content.
A node is a Text element if it is Text, xsl:value-of, xsl:number,
or a combination of these nested in a control instruction (xsl:if or
xsl:choose).
If the doExtendedCheck flag is true, xsl:call-template and xsl:apply-templates
are also considered as Text elements.
if (node instanceof ValueOf || node instanceof Number
|| node instanceof Text)
{
return true;
}
else if (node instanceof If) {
return doExtendedCheck ? isAdaptiveRTF(node) : isSimpleRTF(node);
}
else if (node instanceof Choose) {
Vector contents = node.getContents();
for (int i = 0; i < contents.size(); i++) {
SyntaxTreeNode item = (SyntaxTreeNode)contents.elementAt(i);
if (item instanceof Text ||
((item instanceof When || item instanceof Otherwise)
&& ((doExtendedCheck && isAdaptiveRTF(item))
|| (!doExtendedCheck && isSimpleRTF(item)))))
continue;
else
return false;
}
return true;
}
else if (doExtendedCheck &&
(node instanceof CallTemplate
|| node instanceof ApplyTemplates))
return true;
else
return false;
|
| protected final com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode | lastChild()Returns this element's last child
if (_contents.size() == 0) return null;
return (SyntaxTreeNode)_contents.lastElement();
|
| protected java.lang.String | lookupNamespace(java.lang.String prefix)Returns any namespace URI that is in scope for a given prefix. This
method checks namespace mappings for this element, and if necessary
for ancestor elements as well (ie. if the prefix maps to an URI in this
scope then you'll definately get the URI from this method).
// Initialise the output (default is 'null' for undefined)
String uri = null;
// First look up the prefix/uri mapping in our own hashtable...
if (_prefixMapping != null)
uri = (String)_prefixMapping.get(prefix);
// ... but if we can't find it there we ask our parent for the mapping
if ((uri == null) && (_parent != null)) {
uri = _parent.lookupNamespace(prefix);
if ((prefix == Constants.EMPTYSTRING) && (uri == null))
uri = Constants.EMPTYSTRING;
}
// ... and then we return whatever URI we've got.
return(uri);
|
| protected java.lang.String | lookupPrefix(java.lang.String uri)Returns any namespace prefix that is mapped to a prefix in the current
scope. This method checks namespace mappings for this element, and if
necessary for ancestor elements as well (ie. if the URI is declared
within the current scope then you'll definately get the prefix from
this method). Note that this is a very slow method and consequentially
it should only be used strictly when needed.
// Initialise the output (default is 'null' for undefined)
String prefix = null;
// First look up the prefix/uri mapping in our own hashtable...
if ((_prefixMapping != null) &&
(_prefixMapping.contains(uri))) {
Enumeration prefixes = _prefixMapping.keys();
while (prefixes.hasMoreElements()) {
prefix = (String)prefixes.nextElement();
String mapsTo = (String)_prefixMapping.get(prefix);
if (mapsTo.equals(uri)) return(prefix);
}
}
// ... but if we can't find it there we ask our parent for the mapping
else if (_parent != null) {
prefix = _parent.lookupPrefix(uri);
if ((uri == Constants.EMPTYSTRING) && (prefix == null))
prefix = Constants.EMPTYSTRING;
}
return(prefix);
|
| protected final void | parseChildren(com.sun.org.apache.xalan.internal.xsltc.compiler.Parser parser)Parse all children of this syntax tree node. This method is normally
called by the parseContents() method.
Vector locals = null; // only create when needed
final int count = _contents.size();
for (int i=0; i<count; i++) {
SyntaxTreeNode child = (SyntaxTreeNode)_contents.elementAt(i);
parser.getSymbolTable().setCurrentNode(child);
child.parseContents(parser);
// if variable or parameter, add it to scope
final QName varOrParamName = updateScope(parser, child);
if (varOrParamName != null) {
if (locals == null) {
locals = new Vector(2);
}
locals.addElement(varOrParamName);
}
}
parser.getSymbolTable().setCurrentNode(this);
// after the last element, remove any locals from scope
if (locals != null) {
final int nLocals = locals.size();
for (int i = 0; i < nLocals; i++) {
parser.removeVariable((QName)locals.elementAt(i));
}
}
|
| public void | parseContents(com.sun.org.apache.xalan.internal.xsltc.compiler.Parser parser)Parse the contents of this syntax tree nodes (child nodes, XPath
expressions, patterns and functions). The default behaviour is to parser
the syntax tree node's children (since there are no common expressions,
patterns, etc. that can be handled in this base class.
parseChildren(parser);
|
| protected final void | removeElement(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode element)Removed a child node of this syntax tree node.
_contents.remove(element);
element.setParent(null);
|
| protected void | reportError(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode element, com.sun.org.apache.xalan.internal.xsltc.compiler.Parser parser, java.lang.String errorCode, java.lang.String message)Report an error to the parser.
final ErrorMsg error = new ErrorMsg(errorCode, message, element);
parser.reportError(Constants.ERROR, error);
|
| protected void | reportWarning(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode element, com.sun.org.apache.xalan.internal.xsltc.compiler.Parser parser, java.lang.String errorCode, java.lang.String message)Report a recoverable error to the parser.
final ErrorMsg error = new ErrorMsg(errorCode, message, element);
parser.reportError(Constants.WARNING, error);
|
| protected void | setAttributes(com.sun.org.apache.xalan.internal.xsltc.runtime.AttributeList attributes)Set the attributes for this SyntaxTreeNode.
_attributes = attributes;
|
| protected final void | setFirstElement(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode element)Inserts the first child node of this syntax tree node. The existing
children are shifted back one position.
_contents.insertElementAt(element,0);
element.setParent(this);
|
| protected final void | setLineNumber(int line)Set the source file line number for this element
_line = line;
|
| protected void | setParent(com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode parent)Set this syntax tree node's parent node
if (_parent == null)
_parent = parent;
|
| protected void | setParser(com.sun.org.apache.xalan.internal.xsltc.compiler.Parser parser)Set this node's parser. The parser (the XSLT parser) gives this
syntax tree node access to the symbol table and XPath parser.
_parser = parser;
|
| protected void | setPrefixMapping(java.util.Hashtable mapping)Sets the prefix mapping for the namespaces that were declared in this
element. This does not include all prefix mappings in scope, so one
may have to check ancestor elements to get all mappings that are in
in scope. The prefixes must be passed in as a Hashtable that maps
namespace prefixes (String objects) to namespace URIs (also String).
_prefixMapping = mapping;
|
| protected void | setQName(com.sun.org.apache.xalan.internal.xsltc.compiler.QName qname)Set the QName for the syntax tree node.
_qname = qname;
|
| protected void | setQName(java.lang.String uri, java.lang.String prefix, java.lang.String localname)Set the QName for the SyntaxTreeNode
_qname = new QName(uri, prefix, localname);
|
| public abstract void | translate(com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator classGen, com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator methodGen)Translate this abstract syntax tree node into JVM bytecodes.
|
| protected void | translateContents(com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator classGen, com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator methodGen)Call translate() on all child syntax tree nodes.
// Call translate() on all child nodes
final int n = elementCount();
for (int i = 0; i < n; i++) {
final SyntaxTreeNode item = (SyntaxTreeNode)_contents.elementAt(i);
item.translate(classGen, methodGen);
}
// After translation, unmap any registers for any variables/parameters
// that were declared in this scope. Performing this unmapping in the
// same AST scope as the declaration deals with the problems of
// references falling out-of-scope inside the for-each element.
// (the cause of which being 'lazy' register allocation for references)
for (int i = 0; i < n; i++) {
if( _contents.elementAt(i) instanceof VariableBase) {
final VariableBase var = (VariableBase)_contents.elementAt(i);
var.unmapRegister(methodGen);
}
}
|
| public abstract com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type | typeCheck(com.sun.org.apache.xalan.internal.xsltc.compiler.SymbolTable stable)Type check the children of this node. The type check phase may add
coercions (CastExpr) to the AST.
|
| protected com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type | typeCheckContents(com.sun.org.apache.xalan.internal.xsltc.compiler.SymbolTable stable)Call typeCheck() on all child syntax tree nodes.
final int n = elementCount();
for (int i = 0; i < n; i++) {
SyntaxTreeNode item = (SyntaxTreeNode)_contents.elementAt(i);
item.typeCheck(stable);
}
return Type.Void;
|
| protected com.sun.org.apache.xalan.internal.xsltc.compiler.QName | updateScope(com.sun.org.apache.xalan.internal.xsltc.compiler.Parser parser, com.sun.org.apache.xalan.internal.xsltc.compiler.SyntaxTreeNode node)Add a node to the current scope and return name of a variable or
parameter if the node represents a variable or a parameter.
if (node instanceof Variable) {
final Variable var = (Variable)node;
parser.addVariable(var);
return var.getName();
}
else if (node instanceof Param) {
final Param param = (Param)node;
parser.addParameter(param);
return param.getName();
}
else {
return null;
}
|
