import gnu.bytecode.CodeAttr; //导入依赖的package包/类
public void compileToNode(ApplyExp exp, Compilation comp,
                          ConsumerTarget target) {
    CodeAttr code = comp.getCode();
    Expression[] args = exp.getArgs();
    args[0].compile(comp, Target.pushObject);
    args[1].compile(comp, Target.pushObject);
    String mname;
    if (target.isContextTarget()) {
        comp.loadCallContext();
        mname = "applyTemplates$X";
    } else {
        code.emitLoad(target.getConsumerVariable());
        mname = "applyTemplates$C";
    }
    code.emitInvokeStatic(ClassType.make("gnu.kawa.xslt.ApplyTemplates")
                          .getDeclaredMethod(mname, 3));
}
 

import gnu.bytecode.CodeAttr; //导入依赖的package包/类
public void compile (Compilation comp, Target target)
 {
   pushOptions(comp);
   try
     {
int n = length, i;
       CodeAttr code = comp.getCode();
for (i = 0; i < n - 1; i++)
         {
           exps[i].compileWithPosition(comp, Target.Ignore);
           if (! code.reachableHere())
             {
               if (comp.warnUnreachable())
                 comp.error('w', "unreachable code", exps[i+1]);
               return;
             }
         }
exps[i].compileWithPosition(comp, target);
     }
   finally
     {
popOptions(comp);
     }
 }
 

import gnu.bytecode.CodeAttr; //导入依赖的package包/类
/** Same as 2-argument compileWithPosition,
 * but use some other Expression's line number. */
  public final void compileWithPosition(Compilation comp, Target target,
                                        Expression position) {
      CodeAttr code = comp.getCode();
      if (! code.reachableHere())
          return;
      int line = position.getLineNumber ();
      if (line > 0) {
          code.putLineNumber(position.getFileName(), line);
          String saveFilename = comp.getFileName();
          int saveLine = comp.getLineNumber();
          int saveColumn = comp.getColumnNumber();
          comp.setLine(position);
          compile(comp, target);
          // This might logically belong in a `finally' clause. It is
          // intentionally not so, so that if there is an internal error
          // causing an exception, we get the line number where the
          // exception was thrown.
          comp.setLine(saveFilename, saveLine, saveColumn);
      } else
          compile(comp, target);
}
 

import gnu.bytecode.CodeAttr; //导入依赖的package包/类
static byte[] gnuByteCodeHelloWorld() {
    ClassType c = new ClassType("HelloWorld");
    c.setSuper("java.lang.Object");
    c.setModifiers(Access.PUBLIC);
    c.setSourceFile("HelloWorld.java");

    Method m = c.addMethod("<init>", "()V", Access.PUBLIC);
    CodeAttr code = m.startCode();
    code.pushScope();
    code.emitPushThis();
    code.emitInvokeSpecial(objectCtor);
    code.emitReturn();
    code.popScope();

    m = c.addMethod("main", "([Ljava/lang/String;)V", Access.PUBLIC
            | Access.STATIC);
    code = m.startCode();
    code.pushScope();
    code.emitGetStatic(outField);
    code.emitPushString("Hello world!");
    code.emitInvokeVirtual(printlnMethod);
    code.emitReturn();
    code.popScope();

    return c.writeToArray();
}
 

import gnu.bytecode.CodeAttr; //导入依赖的package包/类
@Override
public void emitPushBoolean(boolean value)
{
  CodeAttr code = getCode();
  if (value)
    code.emitGetStatic(ClassType.make("gnu.commonlisp.lang.Lisp2").getDeclaredField("TRUE"));
  else
    code.emitGetStatic(Compilation.scmListType.getDeclaredField("Empty"));
}
 

import gnu.bytecode.CodeAttr; //导入依赖的package包/类
/** 
 * Compiles the key of the case expression,
 * then computes the hash code, optimizing
 * according to the type.
 */
private void compileKey(Compilation comp) {

    CodeAttr code = comp.getCode();

    if (key.getType() == Type.intType
        || key.getType() == Type.shortType
        || key.getType() == Type.byteType
        || key.getType() == LangPrimType.charType
        || key.getType() == LangPrimType.characterType) {
        // hashCode for an int is the int itself
        key.compile(comp, Type.intType);
    } else if (key.getType() == Type.longType) {
        // hashCode function for longs, inlined
        key.compile(comp, Type.longType);
        key.compile(comp, Type.longType);
        code.emitPushInt(32);
        code.emitShr();
        code.emitXOr();
        StackTarget st = new StackTarget(Type.intType);
        st.compileFromStack(comp, Type.longType);
    } else {
        // hashCode computed using hashCode method
        // of java.lang.Object
        key.compile(comp, Type.objectType);
        code.emitInvokeVirtual(hashCodeMethod);
    }
}
 

import gnu.bytecode.CodeAttr; //导入依赖的package包/类
public void compileFromStack(Compilation comp, Type stackType) {
    if (! stackType.isVoid()) {
        CodeAttr code = comp.getCode();
        if (code.reachableHere())
            code.emitPop(1);
    }
}
 

import gnu.bytecode.CodeAttr; //导入依赖的package包/类
public void emitPushBoolean(boolean value, CodeAttr code)
{
  if (value)
    code.emitGetStatic(ClassType.make("gnu.commonlisp.lang.Lisp2").getDeclaredField("TRUE"));
  else
    code.emitGetStatic(Compilation.scmListType.getDeclaredField("Empty"));
}