com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator

Here are the examples of the java api class com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator taken from open source projects.

1. Sort#compileInit()

Project: openjdk
File: Sort.java
/**
     * Create a constructor for the new class. Updates the reference to the
     * collator in the super calls only when the stylesheet specifies a new
     * language in xsl:sort.
     */
private static MethodGenerator compileInit(NodeSortRecordGenerator sortRecord, ConstantPoolGen cpg, String className) {
    final InstructionList il = new InstructionList();
    final MethodGenerator init = new MethodGenerator(ACC_PUBLIC, com.sun.org.apache.bcel.internal.generic.Type.VOID, null, null, "<init>", className, il, cpg);
    // Call the constructor in the NodeSortRecord superclass
    il.append(ALOAD_0);
    il.append(new INVOKESPECIAL(cpg.addMethodref(NODE_SORT_RECORD, "<init>", "()V")));
    il.append(RETURN);
    return init;
}

2. Stylesheet#compileConstructor()

Project: openjdk
File: Stylesheet.java
/**
     * Compile the translet's constructor
     */
private void compileConstructor(ClassGenerator classGen, Output output) {
    final ConstantPoolGen cpg = classGen.getConstantPool();
    final InstructionList il = new InstructionList();
    final MethodGenerator constructor = new MethodGenerator(ACC_PUBLIC, com.sun.org.apache.bcel.internal.generic.Type.VOID, null, null, "<init>", _className, il, cpg);
    // Call the constructor in the AbstractTranslet superclass
    il.append(classGen.loadTranslet());
    il.append(new INVOKESPECIAL(cpg.addMethodref(TRANSLET_CLASS, "<init>", "()V")));
    constructor.markChunkStart();
    il.append(classGen.loadTranslet());
    il.append(new GETSTATIC(cpg.addFieldref(_className, STATIC_NAMES_ARRAY_FIELD, NAMES_INDEX_SIG)));
    il.append(new PUTFIELD(cpg.addFieldref(TRANSLET_CLASS, NAMES_INDEX, NAMES_INDEX_SIG)));
    il.append(classGen.loadTranslet());
    il.append(new GETSTATIC(cpg.addFieldref(_className, STATIC_URIS_ARRAY_FIELD, URIS_INDEX_SIG)));
    il.append(new PUTFIELD(cpg.addFieldref(TRANSLET_CLASS, URIS_INDEX, URIS_INDEX_SIG)));
    constructor.markChunkEnd();
    constructor.markChunkStart();
    il.append(classGen.loadTranslet());
    il.append(new GETSTATIC(cpg.addFieldref(_className, STATIC_TYPES_ARRAY_FIELD, TYPES_INDEX_SIG)));
    il.append(new PUTFIELD(cpg.addFieldref(TRANSLET_CLASS, TYPES_INDEX, TYPES_INDEX_SIG)));
    constructor.markChunkEnd();
    constructor.markChunkStart();
    il.append(classGen.loadTranslet());
    il.append(new GETSTATIC(cpg.addFieldref(_className, STATIC_NAMESPACE_ARRAY_FIELD, NAMESPACE_INDEX_SIG)));
    il.append(new PUTFIELD(cpg.addFieldref(TRANSLET_CLASS, NAMESPACE_INDEX, NAMESPACE_INDEX_SIG)));
    constructor.markChunkEnd();
    constructor.markChunkStart();
    il.append(classGen.loadTranslet());
    il.append(new PUSH(cpg, AbstractTranslet.CURRENT_TRANSLET_VERSION));
    il.append(new PUTFIELD(cpg.addFieldref(TRANSLET_CLASS, TRANSLET_VERSION_INDEX, TRANSLET_VERSION_INDEX_SIG)));
    constructor.markChunkEnd();
    if (_hasIdCall) {
        constructor.markChunkStart();
        il.append(classGen.loadTranslet());
        il.append(new PUSH(cpg, Boolean.TRUE));
        il.append(new PUTFIELD(cpg.addFieldref(TRANSLET_CLASS, HASIDCALL_INDEX, HASIDCALL_INDEX_SIG)));
        constructor.markChunkEnd();
    }
    // Compile in code to set the output configuration from <xsl:output>
    if (output != null) {
        // Set all the output settings files in the translet
        constructor.markChunkStart();
        output.translate(classGen, constructor);
        constructor.markChunkEnd();
    }
    // This is an implicit, nameless xsl:decimal-format top-level element.
    if (_numberFormattingUsed) {
        constructor.markChunkStart();
        DecimalFormatting.translateDefaultDFS(classGen, constructor);
        constructor.markChunkEnd();
    }
    il.append(RETURN);
    classGen.addMethod(constructor);
}

3. Stylesheet#compileStaticInitializer()

Project: openjdk
File: Stylesheet.java
/**
     * Compile the namesArray, urisArray and typesArray into
     * the static initializer. They are read-only from the
     * translet. All translet instances can share a single
     * copy of this informtion.
     */
private void compileStaticInitializer(ClassGenerator classGen) {
    final ConstantPoolGen cpg = classGen.getConstantPool();
    final InstructionList il = new InstructionList();
    final MethodGenerator staticConst = new MethodGenerator(ACC_PUBLIC | ACC_STATIC, com.sun.org.apache.bcel.internal.generic.Type.VOID, null, null, "<clinit>", _className, il, cpg);
    addStaticField(classGen, "[" + STRING_SIG, STATIC_NAMES_ARRAY_FIELD);
    addStaticField(classGen, "[" + STRING_SIG, STATIC_URIS_ARRAY_FIELD);
    addStaticField(classGen, "[I", STATIC_TYPES_ARRAY_FIELD);
    addStaticField(classGen, "[" + STRING_SIG, STATIC_NAMESPACE_ARRAY_FIELD);
    // Create fields of type char[] that will contain literal text from
    // the stylesheet.
    final int charDataFieldCount = getXSLTC().getCharacterDataCount();
    for (int i = 0; i < charDataFieldCount; i++) {
        addStaticField(classGen, STATIC_CHAR_DATA_FIELD_SIG, STATIC_CHAR_DATA_FIELD + i);
    }
    // Put the names array into the translet - used for dom/translet mapping
    final Vector namesIndex = getXSLTC().getNamesIndex();
    int size = namesIndex.size();
    String[] namesArray = new String[size];
    String[] urisArray = new String[size];
    int[] typesArray = new int[size];
    int index;
    for (int i = 0; i < size; i++) {
        String encodedName = (String) namesIndex.elementAt(i);
        if ((index = encodedName.lastIndexOf(':')) > -1) {
            urisArray[i] = encodedName.substring(0, index);
        }
        index = index + 1;
        if (encodedName.charAt(index) == '@') {
            typesArray[i] = DTM.ATTRIBUTE_NODE;
            index++;
        } else if (encodedName.charAt(index) == '?') {
            typesArray[i] = DTM.NAMESPACE_NODE;
            index++;
        } else {
            typesArray[i] = DTM.ELEMENT_NODE;
        }
        if (index == 0) {
            namesArray[i] = encodedName;
        } else {
            namesArray[i] = encodedName.substring(index);
        }
    }
    staticConst.markChunkStart();
    il.append(new PUSH(cpg, size));
    il.append(new ANEWARRAY(cpg.addClass(STRING)));
    int namesArrayRef = cpg.addFieldref(_className, STATIC_NAMES_ARRAY_FIELD, NAMES_INDEX_SIG);
    il.append(new PUTSTATIC(namesArrayRef));
    staticConst.markChunkEnd();
    for (int i = 0; i < size; i++) {
        final String name = namesArray[i];
        staticConst.markChunkStart();
        il.append(new GETSTATIC(namesArrayRef));
        il.append(new PUSH(cpg, i));
        il.append(new PUSH(cpg, name));
        il.append(AASTORE);
        staticConst.markChunkEnd();
    }
    staticConst.markChunkStart();
    il.append(new PUSH(cpg, size));
    il.append(new ANEWARRAY(cpg.addClass(STRING)));
    int urisArrayRef = cpg.addFieldref(_className, STATIC_URIS_ARRAY_FIELD, URIS_INDEX_SIG);
    il.append(new PUTSTATIC(urisArrayRef));
    staticConst.markChunkEnd();
    for (int i = 0; i < size; i++) {
        final String uri = urisArray[i];
        staticConst.markChunkStart();
        il.append(new GETSTATIC(urisArrayRef));
        il.append(new PUSH(cpg, i));
        il.append(new PUSH(cpg, uri));
        il.append(AASTORE);
        staticConst.markChunkEnd();
    }
    staticConst.markChunkStart();
    il.append(new PUSH(cpg, size));
    il.append(new NEWARRAY(BasicType.INT));
    int typesArrayRef = cpg.addFieldref(_className, STATIC_TYPES_ARRAY_FIELD, TYPES_INDEX_SIG);
    il.append(new PUTSTATIC(typesArrayRef));
    staticConst.markChunkEnd();
    for (int i = 0; i < size; i++) {
        final int nodeType = typesArray[i];
        staticConst.markChunkStart();
        il.append(new GETSTATIC(typesArrayRef));
        il.append(new PUSH(cpg, i));
        il.append(new PUSH(cpg, nodeType));
        il.append(IASTORE);
    }
    // Put the namespace names array into the translet
    final Vector namespaces = getXSLTC().getNamespaceIndex();
    staticConst.markChunkStart();
    il.append(new PUSH(cpg, namespaces.size()));
    il.append(new ANEWARRAY(cpg.addClass(STRING)));
    int namespaceArrayRef = cpg.addFieldref(_className, STATIC_NAMESPACE_ARRAY_FIELD, NAMESPACE_INDEX_SIG);
    il.append(new PUTSTATIC(namespaceArrayRef));
    staticConst.markChunkEnd();
    for (int i = 0; i < namespaces.size(); i++) {
        final String ns = (String) namespaces.elementAt(i);
        staticConst.markChunkStart();
        il.append(new GETSTATIC(namespaceArrayRef));
        il.append(new PUSH(cpg, i));
        il.append(new PUSH(cpg, ns));
        il.append(AASTORE);
        staticConst.markChunkEnd();
    }
    // Grab all the literal text in the stylesheet and put it in a char[]
    final int charDataCount = getXSLTC().getCharacterDataCount();
    final int toCharArray = cpg.addMethodref(STRING, "toCharArray", "()[C");
    for (int i = 0; i < charDataCount; i++) {
        staticConst.markChunkStart();
        il.append(new PUSH(cpg, getXSLTC().getCharacterData(i)));
        il.append(new INVOKEVIRTUAL(toCharArray));
        il.append(new PUTSTATIC(cpg.addFieldref(_className, STATIC_CHAR_DATA_FIELD + i, STATIC_CHAR_DATA_FIELD_SIG)));
        staticConst.markChunkEnd();
    }
    il.append(RETURN);
    classGen.addMethod(staticConst);
}

4. Stylesheet#compileBuildKeys()

Project: openjdk
File: Stylesheet.java
/**
     * Compile a buildKeys() method into the output class. Note that keys
     * for the input document are created in topLevel(), not in this method.
     * However, we still need this method to create keys for documents loaded
     * via the XPath document() function.
     */
private String compileBuildKeys(ClassGenerator classGen) {
    final ConstantPoolGen cpg = classGen.getConstantPool();
    final com.sun.org.apache.bcel.internal.generic.Type[] argTypes = { Util.getJCRefType(DOM_INTF_SIG), Util.getJCRefType(NODE_ITERATOR_SIG), Util.getJCRefType(TRANSLET_OUTPUT_SIG), com.sun.org.apache.bcel.internal.generic.Type.INT };
    final String[] argNames = { DOCUMENT_PNAME, ITERATOR_PNAME, TRANSLET_OUTPUT_PNAME, "current" };
    final InstructionList il = new InstructionList();
    final MethodGenerator buildKeys = new MethodGenerator(ACC_PUBLIC, com.sun.org.apache.bcel.internal.generic.Type.VOID, argTypes, argNames, "buildKeys", _className, il, classGen.getConstantPool());
    buildKeys.addException("com.sun.org.apache.xalan.internal.xsltc.TransletException");
    final Iterator<SyntaxTreeNode> elements = elements();
    while (elements.hasNext()) {
        // xsl:key
        final SyntaxTreeNode element = elements.next();
        if (element instanceof Key) {
            final Key key = (Key) element;
            key.translate(classGen, buildKeys);
            _keys.put(key.getName(), key);
        }
    }
    il.append(RETURN);
    // Compute max locals + stack and add method to class
    buildKeys.stripAttributes(true);
    buildKeys.setMaxLocals();
    buildKeys.setMaxStack();
    buildKeys.removeNOPs();
    classGen.addMethod(buildKeys.getMethod());
    return ("(" + DOM_INTF_SIG + NODE_ITERATOR_SIG + TRANSLET_OUTPUT_SIG + "I)V");
}

5. Sort#compileSortRecordFactory()

Project: openjdk
File: Sort.java
public static String compileSortRecordFactory(Vector<Sort> sortObjects, ClassGenerator classGen, MethodGenerator methodGen, String sortRecordClass) {
    final XSLTC xsltc = (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<VariableRefBase> dups = new ArrayList<>();
    for (int j = 0; j < nsorts; j++) {
        final 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 = 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 com.sun.org.apache.bcel.internal.generic.Type[] argTypes = new com.sun.org.apache.bcel.internal.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, com.sun.org.apache.bcel.internal.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 com.sun.org.apache.bcel.internal.generic.Type[] { com.sun.org.apache.bcel.internal.generic.Type.INT, com.sun.org.apache.bcel.internal.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;
}

6. Stylesheet#compileTransform()

Project: openjdk
File: Stylesheet.java
/**
     * Compile transform() into the output class. This method is used to
     * initialize global variables and global parameters. The current node
     * is set to be the document's root node.
     */
private void compileTransform(ClassGenerator classGen) {
    final ConstantPoolGen cpg = classGen.getConstantPool();
    /*
         * Define the the method transform with the following signature:
         * void transform(DOM, NodeIterator, HandlerBase)
         */
    final com.sun.org.apache.bcel.internal.generic.Type[] argTypes = new com.sun.org.apache.bcel.internal.generic.Type[3];
    argTypes[0] = Util.getJCRefType(DOM_INTF_SIG);
    argTypes[1] = Util.getJCRefType(NODE_ITERATOR_SIG);
    argTypes[2] = Util.getJCRefType(TRANSLET_OUTPUT_SIG);
    final String[] argNames = new String[3];
    argNames[0] = DOCUMENT_PNAME;
    argNames[1] = ITERATOR_PNAME;
    argNames[2] = TRANSLET_OUTPUT_PNAME;
    final InstructionList il = new InstructionList();
    final MethodGenerator transf = new MethodGenerator(ACC_PUBLIC, com.sun.org.apache.bcel.internal.generic.Type.VOID, argTypes, argNames, "transform", _className, il, classGen.getConstantPool());
    transf.addException("com.sun.org.apache.xalan.internal.xsltc.TransletException");
    // Define and initialize current with the root node
    final LocalVariableGen current = transf.addLocalVariable("current", com.sun.org.apache.bcel.internal.generic.Type.INT, null, null);
    final String applyTemplatesSig = classGen.getApplyTemplatesSig();
    final int applyTemplates = cpg.addMethodref(getClassName(), "applyTemplates", applyTemplatesSig);
    final int domField = cpg.addFieldref(getClassName(), DOM_FIELD, DOM_INTF_SIG);
    // push translet for PUTFIELD
    il.append(classGen.loadTranslet());
    if (isMultiDocument()) {
        il.append(new NEW(cpg.addClass(MULTI_DOM_CLASS)));
        il.append(DUP);
    }
    il.append(classGen.loadTranslet());
    il.append(transf.loadDOM());
    il.append(new INVOKEVIRTUAL(cpg.addMethodref(TRANSLET_CLASS, "makeDOMAdapter", "(" + DOM_INTF_SIG + ")" + DOM_ADAPTER_SIG)));
    if (isMultiDocument()) {
        final int init = cpg.addMethodref(MULTI_DOM_CLASS, "<init>", "(" + DOM_INTF_SIG + ")V");
        il.append(new INVOKESPECIAL(init));
    // MultiDOM is on the stack
    }
    //store to _dom variable
    il.append(new PUTFIELD(domField));
    // continue with globals initialization
    final int gitr = cpg.addInterfaceMethodref(DOM_INTF, "getIterator", "()" + NODE_ITERATOR_SIG);
    il.append(transf.loadDOM());
    il.append(new INVOKEINTERFACE(gitr, 1));
    il.append(transf.nextNode());
    current.setStart(il.append(new ISTORE(current.getIndex())));
    // Transfer the output settings to the output post-processor
    il.append(classGen.loadTranslet());
    il.append(transf.loadHandler());
    final int index = cpg.addMethodref(TRANSLET_CLASS, "transferOutputSettings", "(" + OUTPUT_HANDLER_SIG + ")V");
    il.append(new INVOKEVIRTUAL(index));
    /*
         * Compile buildKeys() method. Note that this method is not
         * invoked here as keys for the input document are now created
         * in topLevel(). However, this method is still needed by the
         * LoadDocument class.
         */
    final String keySig = compileBuildKeys(classGen);
    final int keyIdx = cpg.addMethodref(getClassName(), "buildKeys", keySig);
    // Look for top-level elements that need handling
    final Iterator<SyntaxTreeNode> toplevel = elements();
    if (_globals.size() > 0 || toplevel.hasNext()) {
        // Compile method for handling top-level elements
        final String topLevelSig = compileTopLevel(classGen);
        // Get a reference to that method
        final int topLevelIdx = cpg.addMethodref(getClassName(), "topLevel", topLevelSig);
        // Push all parameters on the stack and call topLevel()
        // The 'this' pointer
        il.append(classGen.loadTranslet());
        il.append(classGen.loadTranslet());
        // The DOM reference
        il.append(new GETFIELD(domField));
        il.append(transf.loadIterator());
        // The output handler
        il.append(transf.loadHandler());
        il.append(new INVOKEVIRTUAL(topLevelIdx));
    }
    // start document
    il.append(transf.loadHandler());
    il.append(transf.startDocument());
    // push first arg for applyTemplates
    il.append(classGen.loadTranslet());
    // push translet for GETFIELD to get DOM arg
    il.append(classGen.loadTranslet());
    il.append(new GETFIELD(domField));
    // push remaining 2 args
    il.append(transf.loadIterator());
    il.append(transf.loadHandler());
    il.append(new INVOKEVIRTUAL(applyTemplates));
    // endDocument
    il.append(transf.loadHandler());
    il.append(transf.endDocument());
    il.append(RETURN);
    // Compute max locals + stack and add method to class
    classGen.addMethod(transf);
}

7. Stylesheet#compileTopLevel()

Project: openjdk
File: Stylesheet.java
/**
     * Compile a topLevel() method into the output class. This method is
     * called from transform() to handle all non-template top-level elements.
     * Returns the signature of the topLevel() method.
     *
     * Global variables/params and keys are first sorted to resolve
     * dependencies between them. The XSLT 1.0 spec does not allow a key
     * to depend on a variable. However, for compatibility with Xalan
     * interpretive, that type of dependency is allowed. Note also that
     * the buildKeys() method is still generated as it is used by the
     * LoadDocument class, but it no longer called from transform().
     */
private String compileTopLevel(ClassGenerator classGen) {
    final ConstantPoolGen cpg = classGen.getConstantPool();
    final com.sun.org.apache.bcel.internal.generic.Type[] argTypes = { Util.getJCRefType(DOM_INTF_SIG), Util.getJCRefType(NODE_ITERATOR_SIG), Util.getJCRefType(TRANSLET_OUTPUT_SIG) };
    final String[] argNames = { DOCUMENT_PNAME, ITERATOR_PNAME, TRANSLET_OUTPUT_PNAME };
    final InstructionList il = new InstructionList();
    final MethodGenerator toplevel = new MethodGenerator(ACC_PUBLIC, com.sun.org.apache.bcel.internal.generic.Type.VOID, argTypes, argNames, "topLevel", _className, il, classGen.getConstantPool());
    toplevel.addException("com.sun.org.apache.xalan.internal.xsltc.TransletException");
    // Define and initialize 'current' variable with the root node
    final LocalVariableGen current = toplevel.addLocalVariable("current", com.sun.org.apache.bcel.internal.generic.Type.INT, null, null);
    final int setFilter = cpg.addInterfaceMethodref(DOM_INTF, "setFilter", "(Lcom/sun/org/apache/xalan/internal/xsltc/StripFilter;)V");
    final int gitr = cpg.addInterfaceMethodref(DOM_INTF, "getIterator", "()" + NODE_ITERATOR_SIG);
    il.append(toplevel.loadDOM());
    il.append(new INVOKEINTERFACE(gitr, 1));
    il.append(toplevel.nextNode());
    current.setStart(il.append(new ISTORE(current.getIndex())));
    // Create a new list containing variables/params + keys
    Vector varDepElements = new Vector(_globals);
    Iterator<SyntaxTreeNode> elements = elements();
    while (elements.hasNext()) {
        SyntaxTreeNode element = elements.next();
        if (element instanceof Key) {
            varDepElements.add(element);
        }
    }
    // Determine a partial order for the variables/params and keys
    varDepElements = resolveDependencies(varDepElements);
    // Translate vars/params and keys in the right order
    final int count = varDepElements.size();
    for (int i = 0; i < count; i++) {
        final TopLevelElement tle = (TopLevelElement) varDepElements.elementAt(i);
        tle.translate(classGen, toplevel);
        if (tle instanceof Key) {
            final Key key = (Key) tle;
            _keys.put(key.getName(), key);
        }
    }
    // Compile code for other top-level elements
    Vector whitespaceRules = new Vector();
    elements = elements();
    while (elements.hasNext()) {
        SyntaxTreeNode element = elements.next();
        // xsl:decimal-format
        if (element instanceof DecimalFormatting) {
            ((DecimalFormatting) element).translate(classGen, toplevel);
        } else // xsl:strip/preserve-space
        if (element instanceof Whitespace) {
            whitespaceRules.addAll(((Whitespace) element).getRules());
        }
    }
    // Translate all whitespace strip/preserve rules
    if (whitespaceRules.size() > 0) {
        Whitespace.translateRules(whitespaceRules, classGen);
    }
    if (classGen.containsMethod(STRIP_SPACE, STRIP_SPACE_PARAMS) != null) {
        il.append(toplevel.loadDOM());
        il.append(classGen.loadTranslet());
        il.append(new INVOKEINTERFACE(setFilter, 2));
    }
    il.append(RETURN);
    // Compute max locals + stack and add method to class
    classGen.addMethod(toplevel);
    return ("(" + DOM_INTF_SIG + NODE_ITERATOR_SIG + TRANSLET_OUTPUT_SIG + ")V");
}

8. Sort#compileSortRecord()

Project: openjdk
File: Sort.java
/**
     * Create a new auxillary class extending NodeSortRecord.
     */
private static String compileSortRecord(Vector<Sort> sortObjects, ClassGenerator classGen, MethodGenerator methodGen) {
    final XSLTC xsltc = 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<VariableRefBase> dups = new ArrayList<>();
    for (int j = 0; j < nsorts; j++) {
        final 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(sortRecord, cpg, className);
    MethodGenerator extract = compileExtract(sortObjects, sortRecord, cpg, className);
    sortRecord.addMethod(init);
    sortRecord.addMethod(extract);
    xsltc.dumpClass(sortRecord.getJavaClass());
    return className;
}

9. Number#compileConstructor()

Project: openjdk
File: Number.java
/**
     * Compiles a constructor for the class <tt>_className</tt> that
     * inherits from {Any,Single,Multiple}NodeCounter. This constructor
     * simply calls the same constructor in the super class.
     */
private void compileConstructor(ClassGenerator classGen) {
    MethodGenerator cons;
    final InstructionList il = new InstructionList();
    final ConstantPoolGen cpg = classGen.getConstantPool();
    cons = new MethodGenerator(ACC_PUBLIC, com.sun.org.apache.bcel.internal.generic.Type.VOID, new com.sun.org.apache.bcel.internal.generic.Type[] { Util.getJCRefType(TRANSLET_INTF_SIG), Util.getJCRefType(DOM_INTF_SIG), Util.getJCRefType(NODE_ITERATOR_SIG), com.sun.org.apache.bcel.internal.generic.Type.BOOLEAN }, new String[] { "dom", "translet", "iterator", "hasFrom" }, "<init>", _className, il, cpg);
    // this
    il.append(ALOAD_0);
    // translet
    il.append(ALOAD_1);
    // DOM
    il.append(ALOAD_2);
    // iterator
    il.append(new ALOAD(3));
    // hasFrom
    il.append(new ILOAD(4));
    int index = cpg.addMethodref(ClassNames[_level], "<init>", "(" + TRANSLET_INTF_SIG + DOM_INTF_SIG + NODE_ITERATOR_SIG + "Z)V");
    il.append(new INVOKESPECIAL(index));
    il.append(RETURN);
    classGen.addMethod(cons);
}

10. Whitespace#compileDefault()

Project: openjdk
File: Whitespace.java
/**
     * Compiles the predicate method
     */
private static void compileDefault(int defaultAction, ClassGenerator classGen) {
    final ConstantPoolGen cpg = classGen.getConstantPool();
    final InstructionList il = new InstructionList();
    final XSLTC xsltc = classGen.getParser().getXSLTC();
    // private boolean Translet.stripSpace(int type) - cannot be static
    final MethodGenerator stripSpace = new MethodGenerator(ACC_PUBLIC | ACC_FINAL, com.sun.org.apache.bcel.internal.generic.Type.BOOLEAN, new com.sun.org.apache.bcel.internal.generic.Type[] { Util.getJCRefType(DOM_INTF_SIG), com.sun.org.apache.bcel.internal.generic.Type.INT, com.sun.org.apache.bcel.internal.generic.Type.INT }, new String[] { "dom", "node", "type" }, "stripSpace", classGen.getClassName(), il, cpg);
    classGen.addInterface("com/sun/org/apache/xalan/internal/xsltc/StripFilter");
    if (defaultAction == STRIP_SPACE)
        il.append(ICONST_1);
    else
        il.append(ICONST_0);
    il.append(IRETURN);
    classGen.addMethod(stripSpace);
}

11. Whitespace#compilePredicate()

Project: openjdk
File: Whitespace.java
/*
    private static void compileDebug(ClassGenerator classGen,
                                     InstructionList il) {
        final ConstantPoolGen cpg = classGen.getConstantPool();
        final int prt = cpg.addMethodref("java/lang/System/out",
                                         "println",
                                         "(Ljava/lang/String;)V");
        il.append(DUP);
        il.append(new INVOKESTATIC(prt));
    }
    */
/**
     * Compiles the predicate method
     */
private static void compilePredicate(Vector rules, int defaultAction, ClassGenerator classGen) {
    final ConstantPoolGen cpg = classGen.getConstantPool();
    final InstructionList il = new InstructionList();
    final XSLTC xsltc = classGen.getParser().getXSLTC();
    // private boolean Translet.stripSpace(int type) - cannot be static
    final MethodGenerator stripSpace = new MethodGenerator(ACC_PUBLIC | ACC_FINAL, com.sun.org.apache.bcel.internal.generic.Type.BOOLEAN, new com.sun.org.apache.bcel.internal.generic.Type[] { Util.getJCRefType(DOM_INTF_SIG), com.sun.org.apache.bcel.internal.generic.Type.INT, com.sun.org.apache.bcel.internal.generic.Type.INT }, new String[] { "dom", "node", "type" }, "stripSpace", classGen.getClassName(), il, cpg);
    classGen.addInterface("com/sun/org/apache/xalan/internal/xsltc/StripFilter");
    final int paramDom = stripSpace.getLocalIndex("dom");
    final int paramCurrent = stripSpace.getLocalIndex("node");
    final int paramType = stripSpace.getLocalIndex("type");
    BranchHandle strip[] = new BranchHandle[rules.size()];
    BranchHandle preserve[] = new BranchHandle[rules.size()];
    int sCount = 0;
    int pCount = 0;
    // Traverse all strip/preserve rules
    for (int i = 0; i < rules.size(); i++) {
        // Get the next rule in the prioritised list
        WhitespaceRule rule = (WhitespaceRule) rules.elementAt(i);
        // Returns the namespace for a node in the DOM
        final int gns = cpg.addInterfaceMethodref(DOM_INTF, "getNamespaceName", "(I)Ljava/lang/String;");
        final int strcmp = cpg.addMethodref("java/lang/String", "compareTo", "(Ljava/lang/String;)I");
        // Handle elements="ns:*" type rule
        if (rule.getStrength() == RULE_NAMESPACE) {
            il.append(new ALOAD(paramDom));
            il.append(new ILOAD(paramCurrent));
            il.append(new INVOKEINTERFACE(gns, 2));
            il.append(new PUSH(cpg, rule.getNamespace()));
            il.append(new INVOKEVIRTUAL(strcmp));
            il.append(ICONST_0);
            if (rule.getAction() == STRIP_SPACE) {
                strip[sCount++] = il.append(new IF_ICMPEQ(null));
            } else {
                preserve[pCount++] = il.append(new IF_ICMPEQ(null));
            }
        } else // Handle elements="ns:el" type rule
        if (rule.getStrength() == RULE_ELEMENT) {
            // Create the QName for the element
            final Parser parser = classGen.getParser();
            QName qname;
            if (rule.getNamespace() != Constants.EMPTYSTRING)
                qname = parser.getQName(rule.getNamespace(), null, rule.getElement());
            else
                qname = parser.getQName(rule.getElement());
            // Register the element.
            final int elementType = xsltc.registerElement(qname);
            il.append(new ILOAD(paramType));
            il.append(new PUSH(cpg, elementType));
            // Compare current node type with wanted element type
            if (rule.getAction() == STRIP_SPACE)
                strip[sCount++] = il.append(new IF_ICMPEQ(null));
            else
                preserve[pCount++] = il.append(new IF_ICMPEQ(null));
        }
    }
    if (defaultAction == STRIP_SPACE) {
        compileStripSpace(strip, sCount, il);
        compilePreserveSpace(preserve, pCount, il);
    } else {
        compilePreserveSpace(preserve, pCount, il);
        compileStripSpace(strip, sCount, il);
    }
    classGen.addMethod(stripSpace);
}