/** Type check all the children of this node. */
public Type typeCheck(SymbolTable stable) throws TypeCheckError {
final int count = _globals.size();
for (int i = 0; i < count; i++) {
final VariableBase var = (VariableBase) _globals.elementAt(i);
var.typeCheck(stable);
}
return typeCheckContents(stable);
}
/** Create a new auxillary class extending NodeSortRecord. */
private static String compileSortRecord(
Vector sortObjects, ClassGenerator classGen, MethodGenerator methodGen) {
final XSLTC xsltc = ((Sort) sortObjects.firstElement()).getXSLTC();
final String className = xsltc.getHelperClassName();
// This generates a new class for handling this specific sort
final NodeSortRecordGenerator sortRecord =
new NodeSortRecordGenerator(
className,
NODE_SORT_RECORD,
"sort$0.java",
ACC_PUBLIC | ACC_SUPER | ACC_FINAL,
new String[] {},
classGen.getStylesheet());
final ConstantPoolGen cpg = sortRecord.getConstantPool();
// Add a new instance variable for each var in closure
final int nsorts = sortObjects.size();
final ArrayList dups = new ArrayList();
for (int j = 0; j < nsorts; j++) {
final Sort sort = (Sort) sortObjects.get(j);
// Set the name of the inner class in this sort object
sort.setInnerClassName(className);
final int length = (sort._closureVars == null) ? 0 : sort._closureVars.size();
for (int i = 0; i < length; i++) {
final VariableRefBase varRef = (VariableRefBase) sort._closureVars.get(i);
// Discard duplicate variable references
if (dups.contains(varRef)) continue;
final VariableBase var = varRef.getVariable();
sortRecord.addField(
new Field(
ACC_PUBLIC,
cpg.addUtf8(var.getEscapedName()),
cpg.addUtf8(var.getType().toSignature()),
null,
cpg.getConstantPool()));
dups.add(varRef);
}
}
MethodGenerator init = compileInit(sortObjects, sortRecord, cpg, className);
MethodGenerator extract = compileExtract(sortObjects, sortRecord, cpg, className);
sortRecord.addMethod(init);
sortRecord.addMethod(extract);
xsltc.dumpClass(sortRecord.getJavaClass());
return className;
}
/**
* Translate a predicate expression. This translation pushes two references on the stack: a
* reference to a newly created filter object and a reference to the predicate's closure.
*/
public void translateFilter(ClassGenerator classGen, MethodGenerator methodGen) {
final ConstantPoolGen cpg = classGen.getConstantPool();
final InstructionList il = methodGen.getInstructionList();
// Compile auxiliary class for filter
compileFilter(classGen, methodGen);
// Create new instance of filter
il.append(new NEW(cpg.addClass(_className)));
il.append(DUP);
il.append(new INVOKESPECIAL(cpg.addMethodref(_className, "<init>", "()V")));
// Initialize closure variables
final int length = (_closureVars == null) ? 0 : _closureVars.size();
for (int i = 0; i < length; i++) {
VariableRefBase varRef = (VariableRefBase) _closureVars.get(i);
VariableBase var = varRef.getVariable();
Type varType = var.getType();
il.append(DUP);
// Find nearest closure implemented as an inner class
Closure variableClosure = _parentClosure;
while (variableClosure != null) {
if (variableClosure.inInnerClass()) break;
variableClosure = variableClosure.getParentClosure();
}
// Use getfield if in an inner class
if (variableClosure != null) {
il.append(ALOAD_0);
il.append(
new GETFIELD(
cpg.addFieldref(
variableClosure.getInnerClassName(),
var.getEscapedName(),
varType.toSignature())));
} else {
// Use a load of instruction if in translet class
il.append(var.loadInstruction());
}
// Store variable in new closure
il.append(
new PUTFIELD(cpg.addFieldref(_className, var.getEscapedName(), varType.toSignature())));
}
}
/** Parse the contents of the variable */
public void parseContents(Parser parser) {
// Parse 'name' and 'select' attributes plus parameter contents
super.parseContents(parser);
// Add a ref to this var to its enclosing construct
SyntaxTreeNode parent = getParent();
if (parent instanceof Stylesheet) {
// Mark this as a global variable
_isLocal = false;
// Check if a global variable with this name already exists...
Variable var = parser.getSymbolTable().lookupVariable(_name);
// ...and if it does we need to check import precedence
if (var != null) {
final int us = this.getImportPrecedence();
final int them = var.getImportPrecedence();
// It is an error if the two have the same import precedence
if (us == them) {
final String name = _name.toString();
reportError(this, parser, ErrorMsg.VARIABLE_REDEF_ERR, name);
}
// Ignore this if previous definition has higher precedence
else if (them > us) {
_ignore = true;
return;
} else {
var.disable();
}
// Add this variable if we have higher precedence
}
((Stylesheet) parent).addVariable(this);
parser.getSymbolTable().addVariable(this);
} else {
_isLocal = true;
}
}
public void toString(StringBuffer buffer, String tab) {
buffer.append(tab).append("<Assignment"); // $NON-NLS-1$
appendInterval(buffer);
buffer
.append(" operator='")
.append(getXmlStringValue(getOperator(operator)))
.append("'>\n"); // $NON-NLS-1$ //$NON-NLS-2$
leftHandSide.toString(buffer, TAB + tab);
buffer.append("\n").append(TAB).append(tab).append("<Value>\n"); // $NON-NLS-1$ //$NON-NLS-2$
rightHandSide.toString(buffer, TAB + TAB + tab);
buffer.append("\n").append(TAB).append(tab).append("</Value>\n"); // $NON-NLS-1$ //$NON-NLS-2$
buffer.append(tab).append("</Assignment>"); // $NON-NLS-1$
}
/**
* Returns the node type of the expression owning this predicate. The return value is cached in
* <code>_ptype</code>.
*/
public int getPosType() {
if (_ptype == -1) {
SyntaxTreeNode parent = getParent();
if (parent instanceof StepPattern) {
_ptype = ((StepPattern) parent).getNodeType();
} else if (parent instanceof AbsoluteLocationPath) {
AbsoluteLocationPath path = (AbsoluteLocationPath) parent;
Expression exp = path.getPath();
if (exp instanceof Step) {
_ptype = ((Step) exp).getNodeType();
}
} else if (parent instanceof VariableRefBase) {
final VariableRefBase ref = (VariableRefBase) parent;
final VariableBase var = ref.getVariable();
final Expression exp = var.getExpression();
if (exp instanceof Step) {
_ptype = ((Step) exp).getNodeType();
}
} else if (parent instanceof Step) {
_ptype = ((Step) parent).getNodeType();
}
}
return _ptype;
}
public static String compileSortRecordFactory(
Vector sortObjects,
ClassGenerator classGen,
MethodGenerator methodGen,
String sortRecordClass) {
final XSLTC xsltc = ((Sort) sortObjects.firstElement()).getXSLTC();
final String className = xsltc.getHelperClassName();
final NodeSortRecordFactGenerator sortRecordFactory =
new NodeSortRecordFactGenerator(
className,
NODE_SORT_FACTORY,
className + ".java",
ACC_PUBLIC | ACC_SUPER | ACC_FINAL,
new String[] {},
classGen.getStylesheet());
ConstantPoolGen cpg = sortRecordFactory.getConstantPool();
// Add a new instance variable for each var in closure
final int nsorts = sortObjects.size();
final ArrayList dups = new ArrayList();
for (int j = 0; j < nsorts; j++) {
final Sort sort = (Sort) sortObjects.get(j);
final int length = (sort._closureVars == null) ? 0 : sort._closureVars.size();
for (int i = 0; i < length; i++) {
final VariableRefBase varRef = (VariableRefBase) sort._closureVars.get(i);
// Discard duplicate variable references
if (dups.contains(varRef)) continue;
final VariableBase var = varRef.getVariable();
sortRecordFactory.addField(
new Field(
ACC_PUBLIC,
cpg.addUtf8(var.getEscapedName()),
cpg.addUtf8(var.getType().toSignature()),
null,
cpg.getConstantPool()));
dups.add(varRef);
}
}
// Define a constructor for this class
final org.apache.bcel.generic.Type[] argTypes = new org.apache.bcel.generic.Type[7];
argTypes[0] = Util.getJCRefType(DOM_INTF_SIG);
argTypes[1] = Util.getJCRefType(STRING_SIG);
argTypes[2] = Util.getJCRefType(TRANSLET_INTF_SIG);
argTypes[3] = Util.getJCRefType("[" + STRING_SIG);
argTypes[4] = Util.getJCRefType("[" + STRING_SIG);
argTypes[5] = Util.getJCRefType("[" + STRING_SIG);
argTypes[6] = Util.getJCRefType("[" + STRING_SIG);
final String[] argNames = new String[7];
argNames[0] = DOCUMENT_PNAME;
argNames[1] = "className";
argNames[2] = TRANSLET_PNAME;
argNames[3] = "order";
argNames[4] = "type";
argNames[5] = "lang";
argNames[6] = "case_order";
InstructionList il = new InstructionList();
final MethodGenerator constructor =
new MethodGenerator(
ACC_PUBLIC,
org.apache.bcel.generic.Type.VOID,
argTypes,
argNames,
"<init>",
className,
il,
cpg);
// Push all parameters onto the stack and called super.<init>()
il.append(ALOAD_0);
il.append(ALOAD_1);
il.append(ALOAD_2);
il.append(new ALOAD(3));
il.append(new ALOAD(4));
il.append(new ALOAD(5));
il.append(new ALOAD(6));
il.append(new ALOAD(7));
il.append(
new INVOKESPECIAL(
cpg.addMethodref(
NODE_SORT_FACTORY,
"<init>",
"("
+ DOM_INTF_SIG
+ STRING_SIG
+ TRANSLET_INTF_SIG
+ "["
+ STRING_SIG
+ "["
+ STRING_SIG
+ "["
+ STRING_SIG
+ "["
+ STRING_SIG
+ ")V")));
il.append(RETURN);
// Override the definition of makeNodeSortRecord()
il = new InstructionList();
final MethodGenerator makeNodeSortRecord =
new MethodGenerator(
ACC_PUBLIC,
Util.getJCRefType(NODE_SORT_RECORD_SIG),
new org.apache.bcel.generic.Type[] {
org.apache.bcel.generic.Type.INT, org.apache.bcel.generic.Type.INT
},
new String[] {"node", "last"},
"makeNodeSortRecord",
className,
il,
cpg);
il.append(ALOAD_0);
il.append(ILOAD_1);
il.append(ILOAD_2);
il.append(
new INVOKESPECIAL(
cpg.addMethodref(
NODE_SORT_FACTORY, "makeNodeSortRecord", "(II)" + NODE_SORT_RECORD_SIG)));
il.append(DUP);
il.append(new CHECKCAST(cpg.addClass(sortRecordClass)));
// Initialize closure in record class
final int ndups = dups.size();
for (int i = 0; i < ndups; i++) {
final VariableRefBase varRef = (VariableRefBase) dups.get(i);
final VariableBase var = varRef.getVariable();
final Type varType = var.getType();
il.append(DUP);
// Get field from factory class
il.append(ALOAD_0);
il.append(
new GETFIELD(cpg.addFieldref(className, var.getEscapedName(), varType.toSignature())));
// Put field in record class
il.append(
new PUTFIELD(
cpg.addFieldref(sortRecordClass, var.getEscapedName(), varType.toSignature())));
}
il.append(POP);
il.append(ARETURN);
constructor.setMaxLocals();
constructor.setMaxStack();
sortRecordFactory.addMethod(constructor);
makeNodeSortRecord.setMaxLocals();
makeNodeSortRecord.setMaxStack();
sortRecordFactory.addMethod(makeNodeSortRecord);
xsltc.dumpClass(sortRecordFactory.getJavaClass());
return className;
}
/**
* Compiles code that instantiates a NodeSortRecordFactory object which will produce
* NodeSortRecord objects of a specific type.
*/
public static void compileSortRecordFactory(
Vector sortObjects, ClassGenerator classGen, MethodGenerator methodGen) {
String sortRecordClass = compileSortRecord(sortObjects, classGen, methodGen);
boolean needsSortRecordFactory = false;
final int nsorts = sortObjects.size();
for (int i = 0; i < nsorts; i++) {
final Sort sort = (Sort) sortObjects.elementAt(i);
needsSortRecordFactory |= sort._needsSortRecordFactory;
}
String sortRecordFactoryClass = NODE_SORT_FACTORY;
if (needsSortRecordFactory) {
sortRecordFactoryClass =
compileSortRecordFactory(sortObjects, classGen, methodGen, sortRecordClass);
}
final ConstantPoolGen cpg = classGen.getConstantPool();
final InstructionList il = methodGen.getInstructionList();
// Backwards branches are prohibited if an uninitialized object is
// on the stack by section 4.9.4 of the JVM Specification, 2nd Ed.
// We don't know whether this code might contain backwards branches
// so we mustn't create the new object until after we've created
// the suspect arguments to its constructor. Instead we calculate
// the values of the arguments to the constructor first, store them
// in temporary variables, create the object and reload the
// arguments from the temporaries to avoid the problem.
// Compile code that initializes the static _sortOrder
LocalVariableGen sortOrderTemp =
methodGen.addLocalVariable(
"sort_order_tmp", Util.getJCRefType("[" + STRING_SIG), null, null);
il.append(new PUSH(cpg, nsorts));
il.append(new ANEWARRAY(cpg.addClass(STRING)));
for (int level = 0; level < nsorts; level++) {
final Sort sort = (Sort) sortObjects.elementAt(level);
il.append(DUP);
il.append(new PUSH(cpg, level));
sort.translateSortOrder(classGen, methodGen);
il.append(AASTORE);
}
sortOrderTemp.setStart(il.append(new ASTORE(sortOrderTemp.getIndex())));
LocalVariableGen sortTypeTemp =
methodGen.addLocalVariable(
"sort_type_tmp", Util.getJCRefType("[" + STRING_SIG), null, null);
il.append(new PUSH(cpg, nsorts));
il.append(new ANEWARRAY(cpg.addClass(STRING)));
for (int level = 0; level < nsorts; level++) {
final Sort sort = (Sort) sortObjects.elementAt(level);
il.append(DUP);
il.append(new PUSH(cpg, level));
sort.translateSortType(classGen, methodGen);
il.append(AASTORE);
}
sortTypeTemp.setStart(il.append(new ASTORE(sortTypeTemp.getIndex())));
LocalVariableGen sortLangTemp =
methodGen.addLocalVariable(
"sort_lang_tmp", Util.getJCRefType("[" + STRING_SIG), null, null);
il.append(new PUSH(cpg, nsorts));
il.append(new ANEWARRAY(cpg.addClass(STRING)));
for (int level = 0; level < nsorts; level++) {
final Sort sort = (Sort) sortObjects.elementAt(level);
il.append(DUP);
il.append(new PUSH(cpg, level));
sort.translateLang(classGen, methodGen);
il.append(AASTORE);
}
sortLangTemp.setStart(il.append(new ASTORE(sortLangTemp.getIndex())));
LocalVariableGen sortCaseOrderTemp =
methodGen.addLocalVariable(
"sort_case_order_tmp", Util.getJCRefType("[" + STRING_SIG), null, null);
il.append(new PUSH(cpg, nsorts));
il.append(new ANEWARRAY(cpg.addClass(STRING)));
for (int level = 0; level < nsorts; level++) {
final Sort sort = (Sort) sortObjects.elementAt(level);
il.append(DUP);
il.append(new PUSH(cpg, level));
sort.translateCaseOrder(classGen, methodGen);
il.append(AASTORE);
}
sortCaseOrderTemp.setStart(il.append(new ASTORE(sortCaseOrderTemp.getIndex())));
il.append(new NEW(cpg.addClass(sortRecordFactoryClass)));
il.append(DUP);
il.append(methodGen.loadDOM());
il.append(new PUSH(cpg, sortRecordClass));
il.append(classGen.loadTranslet());
sortOrderTemp.setEnd(il.append(new ALOAD(sortOrderTemp.getIndex())));
sortTypeTemp.setEnd(il.append(new ALOAD(sortTypeTemp.getIndex())));
sortLangTemp.setEnd(il.append(new ALOAD(sortLangTemp.getIndex())));
sortCaseOrderTemp.setEnd(il.append(new ALOAD(sortCaseOrderTemp.getIndex())));
il.append(
new INVOKESPECIAL(
cpg.addMethodref(
sortRecordFactoryClass,
"<init>",
"("
+ DOM_INTF_SIG
+ STRING_SIG
+ TRANSLET_INTF_SIG
+ "["
+ STRING_SIG
+ "["
+ STRING_SIG
+ "["
+ STRING_SIG
+ "["
+ STRING_SIG
+ ")V")));
// Initialize closure variables in sortRecordFactory
final ArrayList dups = new ArrayList();
for (int j = 0; j < nsorts; j++) {
final Sort sort = (Sort) sortObjects.get(j);
final int length = (sort._closureVars == null) ? 0 : sort._closureVars.size();
for (int i = 0; i < length; i++) {
VariableRefBase varRef = (VariableRefBase) sort._closureVars.get(i);
// Discard duplicate variable references
if (dups.contains(varRef)) continue;
final VariableBase var = varRef.getVariable();
// Store variable in new closure
il.append(DUP);
il.append(var.loadInstruction());
il.append(
new PUTFIELD(
cpg.addFieldref(
sortRecordFactoryClass, var.getEscapedName(), var.getType().toSignature())));
dups.add(varRef);
}
}
}
/**
* Create a new "Filter" class implementing <code>CurrentNodeListFilter</code>. Allocate registers
* for local variables and local parameters passed in the closure to test(). Notice that local
* variables need to be "unboxed".
*/
private void compileFilter(ClassGenerator classGen, MethodGenerator methodGen) {
TestGenerator testGen;
LocalVariableGen local;
FilterGenerator filterGen;
_className = getXSLTC().getHelperClassName();
filterGen =
new FilterGenerator(
_className,
"java.lang.Object",
toString(),
ACC_PUBLIC | ACC_SUPER,
new String[] {CURRENT_NODE_LIST_FILTER},
classGen.getStylesheet());
final ConstantPoolGen cpg = filterGen.getConstantPool();
final int length = (_closureVars == null) ? 0 : _closureVars.size();
// Add a new instance variable for each var in closure
for (int i = 0; i < length; i++) {
VariableBase var = ((VariableRefBase) _closureVars.get(i)).getVariable();
filterGen.addField(
new Field(
ACC_PUBLIC,
cpg.addUtf8(var.getEscapedName()),
cpg.addUtf8(var.getType().toSignature()),
null,
cpg.getConstantPool()));
}
final InstructionList il = new InstructionList();
testGen =
new TestGenerator(
ACC_PUBLIC | ACC_FINAL,
org.apache.bcel.generic.Type.BOOLEAN,
new org.apache.bcel.generic.Type[] {
org.apache.bcel.generic.Type.INT,
org.apache.bcel.generic.Type.INT,
org.apache.bcel.generic.Type.INT,
org.apache.bcel.generic.Type.INT,
Util.getJCRefType(TRANSLET_SIG),
Util.getJCRefType(NODE_ITERATOR_SIG)
},
new String[] {"node", "position", "last", "current", "translet", "iterator"},
"test",
_className,
il,
cpg);
// Store the dom in a local variable
local = testGen.addLocalVariable("document", Util.getJCRefType(DOM_INTF_SIG), null, null);
final String className = classGen.getClassName();
il.append(filterGen.loadTranslet());
il.append(new CHECKCAST(cpg.addClass(className)));
il.append(new GETFIELD(cpg.addFieldref(className, DOM_FIELD, DOM_INTF_SIG)));
local.setStart(il.append(new ASTORE(local.getIndex())));
// Store the dom index in the test generator
testGen.setDomIndex(local.getIndex());
_exp.translate(filterGen, testGen);
il.append(IRETURN);
filterGen.addEmptyConstructor(ACC_PUBLIC);
filterGen.addMethod(testGen);
getXSLTC().dumpClass(filterGen.getJavaClass());
}
public void traverseBottomUp(Visitor visitor) {
leftHandSide.traverseBottomUp(visitor);
rightHandSide.traverseBottomUp(visitor);
accept(visitor);
}
public void traverseTopDown(Visitor visitor) {
accept(visitor);
leftHandSide.traverseTopDown(visitor);
rightHandSide.traverseTopDown(visitor);
}
public void childrenAccept(Visitor visitor) {
leftHandSide.accept(visitor);
rightHandSide.accept(visitor);
}
/* 11: */
/* 12: */ public VariableRefBase(VariableBase variable) /* 13: */ {
/* 14: 45 */ this._variable = variable;
/* 15: 46 */ variable.addReference(this);
/* 16: */ }
