set flag AllPublic. // so we can access main call()

// functions used in the generated code

please include functions call preciseGetOrCallMethod set.

srecord noeq LASToByteCode(MethodMaker m) {

  bool callPing = true;

  replace Tb with GazelleV_LeftArrowScript. // Short for "Toolbox"

  delegate Evaluable to Tb.

  // parameter index of VarContext

  settable int iVarContext = -1;

  delegate none, objValue, intValue, doubleValue to JVMStackCellType.

  delegate convertToObject, discardStackTop, here, loadNull to m.

  Tb.Script returnableScript;

  settable IF1<JVMStackCellType> postConversion;

  JVMStackCellType compileScript(Tb.Script script) {

    returnableScript = script;

    var stackTop = compile(script);

    if (postConversion != null)

      stackTop = postConversion.get(stackTop);

    ret stackTop;

  }

  void compileToObject(Tb.Evaluable code) {

    convertToObject(compile(code));

  }

  JVMStackCellType compile(Tb.Evaluable code) {

    if (code cast Tb.Const) {

      O o = code.value;

      if (o == null) {

        m.add(new ACONST_NULL);

        ret objValue;

      } else if (o cast S) {

        m.stringConstant(o);

        ret objValue;

      } else if (o cast Int) { m.intConstant(o); ret intValue; }

      else if (o cast Double) { m.doubleConstant(o); ret doubleValue; }

      else if (o cast Class) {

        m.classConstant(o);

        ret objValue;

      } else if (o cast Bool) {

        m.boolConstant(o);

        ret intValue;

      } else

        fail("Can't compile const value: " + toStringWithClass(o));

    } else if (code cast Tb.Script) {

      var stackTop = none;

      for (step : code.steps) {

        // pop result of last instruction if any

        if (stackTop != none)

          m.add(new POP);

        stackTop = compile(step);

      }

      ret stackTop;

    } else if (code cast Tb.CallMethod) {

      // push target

      compileToObject(code.target);

      // push method name

      m.stringConstant(code.methodName);

      // push argument array

      argumentsAsArray(code.args);

      // call call()

      m.invokeStatic(mainFunctionHolder call, O, "call", O, S, O[].class);

      ret objValue;

    } else if (code cast Tb.CallMethodOrGetField) {

      // push target

      compileToObject(code.target);

      // push method/field name

      m.stringConstant(code.name);

      // call call()

      m.invokeStatic(mainFunctionHolder call, O, "preciseGetOrCallMethod", O, S);

      ret objValue;

    } else if (code cast Tb.SetField) {

      // push target

      compileToObject(code.target);

      // push field name

      m.stringConstant(code.name);

      // push value

      compileToObject(code.expr);

      // call set()

      m.invokeStatic(mainFunctionHolder set, O, "set", O, S, O);

      ret none;

    } else if (code cast Tb.NewObject) {

      // push class

      m.classConstant(code.c);

      argumentsAsArray(code.args);

      // call nuObject()

      m.invokeStatic(mainFunctionHolder nuObject, O, "nuObject", Class.class, O[].class);

      ret objValue;

    } else if (code cast Tb.Assignment) {

      // evaluate expression, store in temporary variable

      compileToObject(code.expression);

      m.astore(iTemp());

      // Call VarContext.set()

      loadVarContext();

      m.stringConstant(code.var);

      m.aload(iTemp());

      m.invokeVirtual(VarContext, void.class, "set", S, O);

      m.aload(iTemp());

      ret objValue;

    } else if (code cast Tb.While) {

    /* Simulating this:

       while (ping() && (Bool) condition.get(ctx)) {

         body.get(ctx);

       }

       null;

    */

      // Mark loop start as jump target

      var loopStart = m.il.append(new NOP);

      // Call ping() unless disabled

      BranchInstruction branch1 = null;

      if (callPing) {

        m.invokeStatic(mainFunctionHolder ping, bool.class, "ping");

        branch1 = new IFEQ(null);

        m.add(branch1);

      }

      // Evaluate condition

      compileToBool(code.condition);

      var branch2 = new IFEQ(null);

      m.add(branch2);

      // Evaluate body

      discardStackTop(compile(code.body));

      // Jump to loop start

      m.add(new GOTO(loopStart));

      // Update forward branches

      var loopEnd = m.il.append(new NOP);

      branch1?.setTarget(loopEnd);

      branch2.setTarget(loopEnd);

      ret none;

    } else if (code cast Tb.IfThen) {

      compileToBool(code.condition);

      var branch1 = new IFEQ(null);

      m.add(branch1);

      // Evaluate body

      var stackTop = compile(code.body);

      // body returns nothing? then we don't need an else branch

      if (stackTop == none) {

        branch1.setTarget(here());

        ret stackTop;

      } else {

        // otherwise, convert to object and return null in else branch

        convertToObject(stackTop);

        var jumpToEnd = m.forwardGoto();

        branch1.setTarget(here());

        loadNull();

        jumpToEnd.setTarget(m.here());

        ret objValue;

      }

    } else if (code cast Tb.GetVar) {

      ret compileGetVar(code);

    } else if (code cast Tb.ReturnFromScript) {

      if (code.script != returnableScript)

        fail("Can only return from current script");

      var stackTop = compile(code.value);

      if (postConversion != null)

        stackTop = postConversion.get(stackTop);

      m.returnWithType(stackTop);

      ret none;

    }

    fail("Can't compile yet: " + className(code));

  }

  void argumentsAsArray(Evaluable[] args) {  

    int n = l(args);

    m.intConst(n);

    m.add(new ANEWARRAY(m.classRef(O)));

    for iArg to n: {

      m.dup(); // get array again

      m.intConst(iArg);

      compileToObject(args[iArg]);

      m.add(new AASTORE);

    }

  }

  void loadVarContext {

    assertTrue("Need VarContext", iVarContext >= 0);

    m.aload(iVarContext);

  }

  // index of a temporary variable, created on demand

  simplyCached int iTemp() {

    ret m.newLocalVar();

  }

  void compileToBool(Evaluable condition) {

    var stackTop = compile(condition);

    if (stackTop == objValue) {

      // cast to Boolean

      m.checkCast(Bool.class);

      // call Boolean.booleanValue()

      m.invokeVirtual(Bool.class, bool.class, "booleanValue");

    } else if (stackTop == intValue) {} // ok

    else fail("Can't convert to bool: " + stackTop);

  }

  JVMStackCellType compileGetVar(Tb.GetVar code) {

    // Prepare VarContext.get()

    loadVarContext();

    m.stringConstant(code.var);

    // call VarContext.get()

    m.invokeVirtual(VarContext, O, "get", S);

    ret objValue;

  }

}