public void compile(ApplyExp applyexp, Compilation compilation, Target target) {
Expression aexpression[] = applyexp.getArgs();
CodeAttr codeattr = compilation.getCode();
codeattr.pushScope();
gnu.bytecode.Variable variable = codeattr.addLocal(Type.pointer_type);
aexpression[0].compile(compilation, Target.pushObject);
codeattr.emitStore(variable);
for (int i = 1; i < aexpression.length; ) {
if (i > 1) {
codeattr.emitElse();
}
int k = i + 1;
applyexp = aexpression[i];
if (applyexp instanceof LambdaExp) {
LambdaExp lambdaexp = (LambdaExp) applyexp;
applyexp = lambdaexp.firstDecl();
Type type = applyexp.getType();
if (!applyexp.getCanRead()) {
applyexp = null;
} else {
applyexp.allocateVariable(codeattr);
}
if (type instanceof TypeValue) {
((TypeValue) type).emitTestIf(variable, applyexp, compilation);
} else {
if (k < aexpression.length) {
codeattr.emitLoad(variable);
type.emitIsInstance(codeattr);
codeattr.emitIfIntNotZero();
}
if (applyexp != null) {
codeattr.emitLoad(variable);
applyexp.compileStore(compilation);
}
}
lambdaexp.allocChildClasses(compilation);
lambdaexp.body.compileWithPosition(compilation, target);
i = k;
} else {
throw new Error("not implemented: typeswitch arg not LambdaExp");
}
}
int j = aexpression.length - 2;
do {
j--;
if (j >= 0) {
codeattr.emitFi();
} else {
codeattr.popScope();
return;
}
} while (true);
}
public void emitTestIf(Variable incoming, Declaration decl, Compilation comp) {
CodeAttr code = comp.getCode();
if (incoming != null) code.emitLoad(incoming);
if (decl != null) {
code.emitDup();
decl.compileStore(comp);
}
comp.compileConstant(this);
code.emitSwap();
code.emitInvokeVirtual(isInstanceMethod);
code.emitIfIntNotZero();
}
public static void emitLoadModuleMethod(LambdaExp paramLambdaExp, Compilation paramCompilation)
{
Object localObject3 = paramLambdaExp.nameDecl;
Object localObject1;
CodeAttr localCodeAttr;
Object localObject2;
label61:
label129:
label150:
label178:
int i;
if (localObject3 == null)
{
localObject1 = paramLambdaExp.getName();
localCodeAttr = null;
localObject2 = localCodeAttr;
if (paramCompilation.immediate)
{
localObject2 = localCodeAttr;
if (localObject1 != null)
{
localObject2 = localCodeAttr;
if (localObject3 != null)
{
localObject3 = Environment.getCurrent();
if (!(localObject1 instanceof Symbol)) {
break label353;
}
localObject2 = (Symbol)localObject1;
localObject3 = ((Environment)localObject3).get((Symbol)localObject2, paramCompilation.getLanguage().getEnvPropertyFor(paramLambdaExp.nameDecl), null);
localObject2 = localCodeAttr;
if ((localObject3 instanceof ModuleMethod)) {
localObject2 = (ModuleMethod)localObject3;
}
}
}
}
localCodeAttr = paramCompilation.getCode();
localObject3 = Compilation.typeModuleMethod;
if (localObject2 != null) {
break label369;
}
localCodeAttr.emitNew((ClassType)localObject3);
localCodeAttr.emitDup(1);
localObject2 = "<init>";
localObject3 = ((ClassType)localObject3).getDeclaredMethod((String)localObject2, 4);
if (!paramLambdaExp.getNeedsClosureEnv()) {
break label385;
}
localObject2 = paramLambdaExp.getOwningLambda();
if ((!(localObject2 instanceof ClassExp)) || (((LambdaExp)localObject2).staticLinkField == null)) {
break label393;
}
localCodeAttr.emitLoad(localCodeAttr.getCurrentScope().getVariable(1));
localCodeAttr.emitPushInt(paramLambdaExp.getSelectorValue(paramCompilation));
paramCompilation.compileConstant(localObject1, Target.pushObject);
int j = paramLambdaExp.min_args;
if (paramLambdaExp.keywords != null) {
break label583;
}
i = paramLambdaExp.max_args;
label215:
localCodeAttr.emitPushInt(i << 12 | j);
localCodeAttr.emitInvoke((Method)localObject3);
if (paramLambdaExp.properties == null) {
return;
}
j = paramLambdaExp.properties.length;
i = 0;
label252:
if (i >= j) {
return;
}
localObject2 = paramLambdaExp.properties[i];
if ((localObject2 != null) && (localObject2 != PropertySet.nameKey))
{
localObject1 = paramLambdaExp.properties[(i + 1)];
localCodeAttr.emitDup(1);
paramCompilation.compileConstant(localObject2);
localObject2 = Target.pushObject;
if (!(localObject1 instanceof Expression)) {
break label589;
}
((Expression)localObject1).compile(paramCompilation, (Target)localObject2);
}
}
for (;;)
{
localCodeAttr.emitInvokeVirtual(ClassType.make("gnu.mapping.PropertySet").getDeclaredMethod("setProperty", 2));
i += 2;
break label252;
localObject1 = ((Declaration)localObject3).getSymbol();
break;
label353:
localObject2 = Symbol.make("", localObject1.toString().intern());
break label61;
label369:
paramCompilation.compileConstant(localObject2, Target.pushValue((Type)localObject3));
localObject2 = "init";
break label129;
label385:
localObject2 = paramCompilation.getModule();
break label150;
label393:
if ((!(localObject2 instanceof ModuleExp)) || ((paramCompilation.moduleClass == paramCompilation.mainClass) && (!paramCompilation.method.getStaticFlag())))
{
localCodeAttr.emitPushThis();
break label178;
}
if (paramCompilation.moduleInstanceVar == null)
{
paramCompilation.moduleInstanceVar = localCodeAttr.locals.current_scope.addVariable(localCodeAttr, paramCompilation.moduleClass, "$instance");
if ((paramCompilation.moduleClass == paramCompilation.mainClass) || (paramCompilation.isStatic())) {
break label571;
}
localCodeAttr.emitNew(paramCompilation.moduleClass);
localCodeAttr.emitDup(paramCompilation.moduleClass);
localCodeAttr.emitInvokeSpecial(paramCompilation.moduleClass.constructor);
paramCompilation.moduleInstanceMainField = paramCompilation.moduleClass.addField("$main", paramCompilation.mainClass, 0);
localCodeAttr.emitDup(paramCompilation.moduleClass);
localCodeAttr.emitPushThis();
localCodeAttr.emitPutField(paramCompilation.moduleInstanceMainField);
}
for (;;)
{
localCodeAttr.emitStore(paramCompilation.moduleInstanceVar);
localCodeAttr.emitLoad(paramCompilation.moduleInstanceVar);
break;
label571:
localCodeAttr.emitGetStatic(paramCompilation.moduleInstanceMainField);
}
label583:
i = -1;
break label215;
label589:
paramCompilation.compileConstant(localObject1, (Target)localObject2);
}
}
static void compile(ApplyExp exp, Compilation comp, Target target, boolean checkInlineable) {
int args_length = exp.args.length;
Expression exp_func = exp.func;
LambdaExp func_lambda = null;
String func_name = null;
Declaration owner = null;
Object quotedValue = null;
if (exp_func instanceof LambdaExp) {
func_lambda = (LambdaExp) exp_func;
func_name = func_lambda.getName();
if (func_name == null) func_name = "<lambda>";
} else if (exp_func instanceof ReferenceExp) {
ReferenceExp func_ref = (ReferenceExp) exp_func;
owner = func_ref.contextDecl();
Declaration func_decl = func_ref.binding;
while (func_decl != null && func_decl.isAlias() && func_decl.value instanceof ReferenceExp) {
func_ref = (ReferenceExp) func_decl.value;
if (owner != null || func_decl.needsContext() || func_ref.binding == null) break;
func_decl = func_ref.binding;
owner = func_ref.contextDecl();
}
if (!func_decl.getFlag(Declaration.IS_UNKNOWN)) {
Expression value = func_decl.getValue();
func_name = func_decl.getName();
if (value != null && value instanceof LambdaExp) func_lambda = (LambdaExp) value;
if (value != null && value instanceof QuoteExp) quotedValue = ((QuoteExp) value).getValue();
}
} else if (exp_func instanceof QuoteExp) {
quotedValue = ((QuoteExp) exp_func).getValue();
}
if (checkInlineable && quotedValue instanceof Procedure) {
Procedure proc = (Procedure) quotedValue;
if (target instanceof IgnoreTarget && proc.isSideEffectFree()) {
for (int i = 0; i < args_length; i++) exp.args[i].compile(comp, target);
return;
}
try {
if (inlineCompile(proc, exp, comp, target)) return;
} catch (Throwable ex) {
comp.getMessages()
.error('e', "caught exception in inline-compiler for " + quotedValue + " - " + ex, ex);
return;
}
}
gnu.bytecode.CodeAttr code = comp.getCode();
Method method;
if (func_lambda != null) {
if ((func_lambda.max_args >= 0 && args_length > func_lambda.max_args)
|| args_length < func_lambda.min_args)
// This is supposed to get caught by InlineCalls.
throw new Error("internal error - wrong number of parameters for " + func_lambda);
int conv = func_lambda.getCallConvention();
// Mostly duplicates logic with LambdaExp.validateApply.
// See comment there.
if (comp.inlineOk(func_lambda)
&& (conv <= Compilation.CALL_WITH_CONSUMER
|| (conv == Compilation.CALL_WITH_TAILCALLS && !exp.isTailCall()))
&& (method = func_lambda.getMethod(args_length)) != null) {
PrimProcedure pproc = new PrimProcedure(method, func_lambda);
boolean is_static = method.getStaticFlag();
boolean extraArg = false;
// ?? Procedure.checkArgCount(this, args.length); // FIXME
if (!is_static || func_lambda.declareClosureEnv() != null) {
if (is_static) extraArg = true;
if (comp.curLambda == func_lambda) // Recursive call.
code.emitLoad(
func_lambda.closureEnv != null ? func_lambda.closureEnv : func_lambda.thisVariable);
else if (owner != null) owner.load(null, 0, comp, Target.pushObject);
else func_lambda.getOwningLambda().loadHeapFrame(comp);
}
pproc.compile(extraArg ? Type.voidType : null, exp, comp, target);
return;
}
}
/*
if (comp.usingCPStyle())
{
{
Label l = new Label(code);
gnu.bytecode.SwitchState fswitch = comp.fswitch;
int pc = fswitch.getMaxValue() + 1;
fswitch.addCase(pc, code, l);
exp_func.compile(comp, new StackTarget(Compilation.typeProcedure));
comp.loadCallContext();
// Emit: context->pc = pc.
comp.loadCallContext();
code.emitPushInt(pc);
code.emitPutField(Compilation.pcCallContextField);
code.emitInvokeVirtual(Compilation.applyCpsMethod);
// emit[save java stack, if needed]
Type[] stackTypes = code.saveStackTypeState(false);
java.util.Stack stackFields = new java.util.Stack();
if (stackTypes != null)
{
for (int i = stackTypes.length; --i >= 0; )
{
Field fld = comp.allocLocalField (stackTypes[i], null);
code.emitPushThis();
code.emitSwap();
code.emitPutField(fld);
stackFields.push(fld);
}
}
code.emitReturn();
l.define(code);
// emit[restore java stack, if needed]
if (stackTypes != null)
{
for (int i = stackTypes.length; --i >= 0; )
{
Field fld = (Field) stackFields.pop();
code.emitPushThis();
code.emitGetField(fld);
comp.freeLocalField(fld);
}
}
// FIXME
// Load result from stack.value to target.
comp.loadCallContext();
code.emitGetField(comp.valueCallContextField);
target.compileFromStack(comp, Type.pointer_type);
}
return;
}
*/
// Check for tail-recursion.
boolean tail_recurse = exp.isTailCall() && func_lambda != null && func_lambda == comp.curLambda;
if (func_lambda != null
&& func_lambda.getInlineOnly()
&& !tail_recurse
&& func_lambda.min_args == args_length) {
pushArgs(func_lambda, exp.args, null, comp);
if (func_lambda.getFlag(LambdaExp.METHODS_COMPILED)) {
popParams(code, func_lambda, null, false);
code.emitTailCall(false, func_lambda.getVarScope());
return;
}
func_lambda.flags |= LambdaExp.METHODS_COMPILED;
LambdaExp saveLambda = comp.curLambda;
comp.curLambda = func_lambda;
func_lambda.allocChildClasses(comp);
func_lambda.allocParameters(comp);
popParams(code, func_lambda, null, false);
func_lambda.enterFunction(comp);
func_lambda.body.compileWithPosition(comp, target);
func_lambda.compileEnd(comp);
func_lambda.generateApplyMethods(comp);
code.popScope();
comp.curLambda = saveLambda;
return;
}
if (comp.curLambda.isHandlingTailCalls()
&& (exp.isTailCall() || target instanceof ConsumerTarget)
&& !comp.curLambda.getInlineOnly()) {
ClassType typeContext = Compilation.typeCallContext;
exp_func.compile(comp, new StackTarget(Compilation.typeProcedure));
// evaluate args to frame-locals vars; // may recurse!
if (args_length <= 4) {
for (int i = 0; i < args_length; ++i)
exp.args[i].compileWithPosition(comp, Target.pushObject);
comp.loadCallContext();
code.emitInvoke(
Compilation.typeProcedure.getDeclaredMethod("check" + args_length, args_length + 1));
} else {
compileToArray(exp.args, comp);
comp.loadCallContext();
code.emitInvoke(Compilation.typeProcedure.getDeclaredMethod("checkN", 2));
}
if (exp.isTailCall()) {
code.emitReturn();
} else if (((ConsumerTarget) target).isContextTarget()) {
comp.loadCallContext();
code.emitInvoke(typeContext.getDeclaredMethod("runUntilDone", 0));
} else {
comp.loadCallContext();
code.emitLoad(((ConsumerTarget) target).getConsumerVariable());
code.emitInvoke(typeContext.getDeclaredMethod("runUntilValue", 1));
}
return;
}
if (!tail_recurse) exp_func.compile(comp, new StackTarget(Compilation.typeProcedure));
boolean toArray =
(tail_recurse ? func_lambda.min_args != func_lambda.max_args : args_length > 4);
int[] incValues = null; // Increments if we can use iinc.
if (toArray) {
compileToArray(exp.args, comp);
method = Compilation.applyNmethod;
} else if (tail_recurse) {
incValues = new int[exp.args.length];
pushArgs(func_lambda, exp.args, incValues, comp);
method = null;
} else {
for (int i = 0; i < args_length; ++i) {
exp.args[i].compileWithPosition(comp, Target.pushObject);
if (!code.reachableHere()) break;
}
method = Compilation.applymethods[args_length];
}
if (!code.reachableHere()) {
comp.error('e', "unreachable code");
return;
}
if (tail_recurse) {
popParams(code, func_lambda, incValues, toArray);
code.emitTailCall(false, func_lambda.getVarScope());
return;
}
code.emitInvokeVirtual(method);
target.compileFromStack(comp, Type.pointer_type);
}