* Copyright (c) 2007 BUSINESS OBJECTS SOFTWARE LIMITED

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

*     * Redistributions of source code must retain the above copyright notice,

*       this list of conditions and the following disclaimer.

* 

*     * Redistributions in binary form must reproduce the above copyright

*       notice, this list of conditions and the following disclaimer in the

*       documentation and/or other materials provided with the distribution.

* 

*     * Neither the name of Business Objects nor the names of its contributors

*       may be used to endorse or promote products derived from this software

*       without specific prior written permission.

* 

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

*/

/*

* CodeGenerator.java

* Created: Dec 3, 2002 at 7:24:06 PM

* By: Raymond Cypher

*/

* Convert Expression instances into g-machine instruction sequences.

*

* <p>

* Created: Dec 3, 2002 at 7:24:05 PM

* @author Raymond Cypher

*/

    /** The namespace for log messages from the G machine. */

    public static final String MACHINE_LOGGER_NAMESPACE = "org.openquark.cal.internal.runtime.g";

    /** An instance of a Logger for G machine messages. */

    static final Logger MACHINE_LOGGER = Logger.getLogger(MACHINE_LOGGER_NAMESPACE);

    /** A map of QualifiedName -> NPrimitiveFunc for primitive functions. */

    private static final Map<QualifiedName, NPrimitiveFunc> primitiveFuncMap = new HashMap<QualifiedName, NPrimitiveFunc> ();

    /** Flag indicating that function tracing and breakpoints are enabled and */

    private static final boolean GENERATE_DEBUG_CODE = System.getProperty(MachineConfiguration.MACHINE_DEBUG_CAPABLE_PROP) != null;

    static {

        // Initialise the primitive function map.

        primitiveFuncMap.put (NDeepSeq.name, NDeepSeq.instance);

        primitiveFuncMap.put (NOrdinalValue.name, NOrdinalValue.instance);

        primitiveFuncMap.put (NShowRecord.name, NShowRecord.instance);

        primitiveFuncMap.put (NRecordFieldValuePrimitive.name, NRecordFieldValuePrimitive.instance);

        primitiveFuncMap.put (NRecordFieldTypePrimitive.name, NRecordFieldTypePrimitive.instance);

        primitiveFuncMap.put (NInsertTextualRecordFieldPrimitive.name, NInsertTextualRecordFieldPrimitive.instance);

        primitiveFuncMap.put (NInsertOrdinalRecordFieldPrimitive.name, NInsertOrdinalRecordFieldPrimitive.instance);

        primitiveFuncMap.put (NAppendRecordPrimitive.name, NAppendRecordPrimitive.instance);

        primitiveFuncMap.put (NRecordTypeDictionary.name, NRecordTypeDictionary.instance);

        primitiveFuncMap.put (NRecordToJListPrimitive.name, NRecordToJListPrimitive.instance);

        primitiveFuncMap.put (NRecordFromJListPrimitive.name, NRecordFromJListPrimitive.instance);

        primitiveFuncMap.put (NRecordFromJMapPrimitive.name, NRecordFromJMapPrimitive.instance);

        primitiveFuncMap.put (NRecordToJRecordValuePrimitive.name, NRecordToJRecordValuePrimitive.instance);

        primitiveFuncMap.put (NStrictRecordPrimitive.name, NStrictRecordPrimitive.instance);

        primitiveFuncMap.put (NCompareRecord.name, NCompareRecord.instance);

        primitiveFuncMap.put (NNotEqualsRecord.name, NNotEqualsRecord.instance);

        primitiveFuncMap.put (NEqualsRecord.name, NEqualsRecord.instance);

        primitiveFuncMap.put (NArbitraryRecordPrimitive.name, NArbitraryRecordPrimitive.instance);

        primitiveFuncMap.put (NCoArbitraryRecordPrimitive.name, NCoArbitraryRecordPrimitive.instance);

        primitiveFuncMap.put (NError.name, NError.instance);

        primitiveFuncMap.put (NSeq.name, NSeq.instance);

        primitiveFuncMap.put (NPrimCatch.name, NPrimCatch.instance);

        primitiveFuncMap.put (NPrimThrow.name, NPrimThrow.instance);

        primitiveFuncMap.put (NBuildList.name, NBuildList.instance);

        primitiveFuncMap.put (NBuildRecord.name, NBuildRecord.instance);

       

        MACHINE_LOGGER.setLevel(Level.FINEST);

        MACHINE_LOGGER.setLevel(Level.FINEST);

        MACHINE_LOGGER.setUseParentHandlers(false);

        StreamHandler consoleHandler = new StreamHandler(System.out, new ConsoleFormatter()) {

            /** Override this to always flush the stream. */

            @Override

            public void publish(LogRecord record) {

                super.publish(record);

                flush();

            }

            /** Override to just flush the stream, we don't want to close System.out. */

            @Override

            public void close() {

                flush();

            }

        };

        consoleHandler.setLevel(Level.ALL);

        MACHINE_LOGGER.addHandler(consoleHandler);

    }

    protected GMachineFunction currentMachineFunction;

    //protected CompilerMessageLogger logger;

    /** Show code generation diagnostics. */

    public static boolean CODEGEN_DIAG = false;

    private KeyholeOptimizer ko = new KeyholeOptimizer ();

    private Module currentModule;

    /**

     * Construct CodeGenerator from compiler.

     * @param isForAdjunct

     */

    CodeGenerator(boolean isForAdjunct) {

        super (isForAdjunct);

    }

    /**

     * Generate g-machine code for all the supercombinators in the program.

     * @param module

     * @param logger

     * @return CompilerMessage.Severity

     */

    @Override

    public CompilerMessage.Severity generateSCCode (Module module, CompilerMessageLogger logger) {

        if (module == null) {

            throw new IllegalArgumentException("g.CodeGenerator.generateSCCode() cannot have a null module.");

        }

        CompilerMessageLogger generateLogger = new MessageLogger();

       

        try {

            informStatusListeners(StatusListener.SM_GENCODE, module.getName());

            currentModule = module;

            for (final MachineFunction mf : module.getFunctions()) {

               

                GMachineFunction gmf = (GMachineFunction)mf;

               

                if (gmf.isCodeGenerated()) {

                    continue;

                }

                if (gmf.getAliasOf() != null || gmf.getLiteralValue() != null) {

                    gmf.setCodeGenerated(true);

                    continue;

                }

                try {

                    generateSCCode (gmf);

                } catch (CodeGenerationException e) {

                    try {

                        // Note: The code generation could potentially have failed because a foreign type or a foreign function's corresponding Java entity

                        // could not be resolved. (In this case the CodeGenerationException would be wrapping an UnableToResolveForeignEntityException)

                       

                        final Throwable cause = e.getCause();

                        if (cause instanceof UnableToResolveForeignEntityException) {

                            generateLogger.logMessage(((UnableToResolveForeignEntityException)cause).getCompilerMessage());

                        }

                       

                        // Code generation aborted. Error generating code for: {cl.getQualifiedName()}

                        generateLogger.logMessage(new CompilerMessage(new MessageKind.Error.CodeGenerationAborted(gmf.getQualifiedName().getQualifiedName()), e));

                    } catch (CompilerMessage.AbortCompilation e2) {/* Ignore exceptions generated by the act of logging. */}

                    return generateLogger.getMaxSeverity();

                }

            }

            fixupPushGlobals (module);

        } catch (Exception e) {

            try {

                if (generateLogger.getNErrors() > 0) {

                    //if an error occurred previously, we continue to compile the program to try to report additional

                    //meaningful compilation errors. However, this can produce spurious exceptions related to the fact

                    //that the program state does not satisfy preconditions because of the initial error(s). We don't

                    //report the spurious exception as an internal coding error.

                    generateLogger.logMessage(new CompilerMessage(new MessageKind.Fatal.UnableToRecoverFromCodeGenErrors(module.getName())));

                } else {                              

                    generateLogger.logMessage(new CompilerMessage(new MessageKind.Fatal.CodeGenerationAbortedDueToInternalCodingError(module.getName()), e));

                }                                                                           

            } catch (CompilerMessage.AbortCompilation ace) {

                /* Ignore exceptions generated by the act of logging. */

            }

        } catch (Error e) {

            try {

                generateLogger.logMessage(new CompilerMessage(new MessageKind.Error.CodeGenerationAbortedWithException(module.getName(), e)));

            } catch (CompilerMessage.AbortCompilation ace) {

                /* Ignore exceptions generated by the act of logging. */

            }

        } finally {

            if (logger != null) {

                // Log messages to the passed-in logger.

                try {

                    logger.logMessages(generateLogger);

                } catch (CompilerMessage.AbortCompilation e) {

                    /* Ignore exceptions generated by the act of logging. */

                }

            }

        }

        return generateLogger.getMaxSeverity();

    }

    /**

     * Generate supercombinator code

     * @param gmf the code label for which the supercombinator code should be generated.

     * @throws CodeGenerationException

     */

    private void generateSCCode(GMachineFunction gmf) throws CodeGenerationException {

        // We are generating a supercombinator.

        // Show diagnostics if turned on

        if (CODEGEN_DIAG) {

            // DIAG

            MACHINE_LOGGER.log(Level.FINE, "CodeGen: SC = " + gmf.getName ());

        }

        // Save the supercombinator away in the object to save stack if we recurse

        this.currentMachineFunction = gmf;

        InstructionList gp = null;

        Expression e = gmf.getExpressionForm();

        // If this is a DataConstructor for an enumeration data type

        // we want to simply return as these are treates as int.

        Expression.PackCons packCons = e.asPackCons();

        if (packCons != null) {

            DataConstructor dc = packCons.getDataConstructor();

            if (TypeExpr.isEnumType(dc.getTypeConstructor())) {

                gmf.setCodeGenerated(true);

                return;

            }

        }

        // Call the top level scheme

        // Recursive code generation

        try {

            gp = schemeSC(e);

        } catch (StackOverflowError excp) {

            // Blown the Java call stack - raise compiler error

            throw new CodeGenerationException ("Code generation stack recursion too deeply nested, use an iterative code generator", excp);

        }

        gp = ko.optimizeCode (gp);

        // Put instuctions into the MachineFunction

        Code code = new Code (gp);

        gmf.setCode(code);

        gmf.setCodeGenerated(true);

        if (CODEGEN_DIAG) {

            MACHINE_LOGGER.log(Level.FINE, "\n");

            MACHINE_LOGGER.log(Level.FINE, gmf.toString ());

            MACHINE_LOGGER.log(Level.FINE, gp.toString ());

            MACHINE_LOGGER.log(Level.FINE, "\n");

        }

    }

    /**

     * Execute the supercombinator compilation scheme.

     * Creation date: (12/03/02 9:26:31 PM)

     * @param e Expression the expression

     * @return InstructionList the instructions and other data compiled by this scheme

     * @throws CodeGenerationException

     */

    private InstructionList schemeSC(Expression e) throws CodeGenerationException {

        InstructionList body = new InstructionList ();

        // Show diagnostics if turned on

        if (CODEGEN_DIAG) {

            // DIAG

            MACHINE_LOGGER.log(Level.FINE, "\nCodeGen: Entering SC compilation scheme with intermediate code:\n" + e);

        }

        // Is e a pack constructor?

        Expression.PackCons packCons = e.asPackCons();

        if (packCons != null) {

            // Generate the pack constructor code and return.

            DataConstructor dc = packCons.getDataConstructor();

            // If this is a supercombinator and we are instrumenting the code.

            if (System.getProperty("org.openquark.cal.machine.g.call_counts") != null) {

                body.code (new Instruction.I_Instrument (new Executor.CallCountInfo(currentMachineFunction.getQualifiedName (), "DataConstructor function form counts")));

            }

            // Force the evaluation of any strict arguments.

            if (dc.hasStrictArgs()) {

                for (int i = 0; i < dc.getArity(); ++i) {

                    if (dc.isArgStrict(i)) {

                        body.code(new Instruction.I_Push(i));

                        body.code(Instruction.I_Eval);

                        body.code(new Instruction.I_Pop(1));

                    }

                }

            }

            if (GENERATE_DEBUG_CODE) {

                // Add an instruction that will suspend execution if a breakpoint is set

                // trace a function message, etc.

                Instruction inst =

                    new Instruction.I_Debug_Processing(currentMachineFunction.getQualifiedName(),

                            currentMachineFunction.getArity());

                body.code(inst);

            }

            Instruction instruction = Instruction.I_PackCons.makePackCons(dc);

            body.code (instruction);

            body.code (new Instruction.I_Update (0));

            body.code (Instruction.I_Unwind);

        } else {

            // If this is a supercombinator and we are instrumenting the code.

            if (System.getProperty("org.openquark.cal.machine.g.call_counts") != null) {

                body.code (new Instruction.I_Instrument (new Executor.CallCountInfo(currentMachineFunction.getQualifiedName (), "Call counts")));

            }

            int arity = currentMachineFunction.getArity();

            Map<QualifiedName, Integer> env = new HashMap<QualifiedName, Integer> ();

            String parameterNames[] = currentMachineFunction.getParameterNames();

            for (int i = 0; i < parameterNames.length; ++i) {

                String parameterName = parameterNames[i];                                    

                QualifiedName qn = QualifiedName.make(currentModule.getName(), parameterName);              

                env.put (qn, Integer.valueOf((arity - i)));             

            }

            //body.code (new Instruction.I_Println("Entering: " + cl.getQualifiedName().toString()));

            for (int i = 0; i < currentMachineFunction.getArity(); ++i) {

                if (currentMachineFunction.getParameterStrictness()[i]) {

                    body.code(new Instruction.I_Push(i));

                    body.code(Instruction.I_Eval);

                    body.code(new Instruction.I_Pop(1));

                }

            }

            if (GENERATE_DEBUG_CODE) {

                // Add in an instruction that will generate a trace message with the name of the current function

                // and the state of its arguments.

                body.code (new Instruction.I_Debug_Processing(currentMachineFunction.getQualifiedName(), currentMachineFunction.getArity()));

            }

            // Invoke the R scheme to compile the body

            body.code (schemeR(e, env, arity));

        }

        return body;

    }

    /**

     * Execute the R compilation scheme.  This generates code to apply a supercombinator to

     * its arguments.

     * Creation date: (12/04/02 9:32:17 AM)

     * @param e Expression the expression

     * @param p Map: a table linking variable names to stack offsets.

     * @param d int: the depth of the current execution context minus one (i.e. at this point the number of arguments).

     * @return InstructionList the instructions and other data compiled by this scheme

     * @throws CodeGenerationException

     */  

    private InstructionList schemeR(Expression e, Map<QualifiedName, Integer> p, int d) throws CodeGenerationException {

        // R[[ i ]] p d = PUSHVVAL i; UPDATE d; POP d; UNWIND;

        // R[[ f ]] p d = PUSHGLOBAL f; EVAL; UPDATE d; POP d; UNWIND;

        // R[[ x ]] p d = PUSH (d - p(x)); EVAL; UPDATE d; POP d; UNWIND;

        // R[[ Cons E1 E2]] p d = C[[ E2 ]] p d; C[[ E1 ]] p (d+1); CONS; UPDATE d; POP d; UNWIND;

        // R[[ if Ec Et Ef]] p d = C[[ Ec ]] p d; EVAL; I_COND (R[[ Et ]] p d) (R[[ Ef ]] p d);

        // R[[ E1 E2]] p d = C[[ E1 E2]] p d; UPDATE d; POP d; UNWIND;

        // R[[letrec D in E]] p d = CLetrec[[ D ]] p1 d1; R[[ E ]] p1 d1;

        //      where

        //      (p1, d1) = Xr[[ D ]] p d;

        // Show diagnostics if turned on

        if (CODEGEN_DIAG) {

            // DIAG

            MACHINE_LOGGER.log(Level.FINE, "\nCodeGen: Entering R compilation scheme with intermediate code:\n" + e);  

           

            for (final Map.Entry<QualifiedName, Integer> entry : p.entrySet()) {              

                MACHINE_LOGGER.log(Level.FINE, "    " + entry.getKey() + ": " + entry.getValue());

            }

        }

        InstructionList gp = new InstructionList ();

        // Is e a literal?

        Expression.Literal literal = e.asLiteral();

        if (literal != null) {

            // Code a I_PushVVal instruction to push the literal onto the stack.

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    Literal:");

            }

            Object val = literal.getLiteral ();

            if (val instanceof Boolean) {

                // Booleans are handled as a special case.

                if (((Boolean)val).booleanValue()) {

                    gp.code (Instruction.I_PushTrue);

                } else {

                    gp.code (Instruction.I_PushFalse);

                }

            } else {

                gp.code(Instruction.I_PushVVal.makePushVVal(literal.getLiteral()));

            }

            appendUpdateCode(gp, d);

            return gp;

        }

        BasicOpTuple  basicOpExpressions = BasicOpTuple.isBasicOp(e);

        if (GENERATE_DEBUG_CODE) {

            //When we have function tracing enabled, we want to force all primitive operations to be

            //done as function calls. This will have the effect of ensuring that they get traced when called. 

            if (basicOpExpressions != null && !basicOpExpressions.getName().equals(currentMachineFunction.getQualifiedName())) {

                basicOpExpressions = null;

            }

        }

        // Is e a basic operation (arithmetic, comparative etc.)?  Test only - don't get tuple

        if (basicOpExpressions != null) {

            // Unpack the basic op into subexpressions

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    basic:");

            }

            // Code a basic operation

            int op = basicOpExpressions.getPrimitiveOp ();

            Instruction instruction = null;

            if (op == PrimOps.PRIMOP_EAGER) {

                return schemeR (basicOpExpressions.getArgument(0), p, d);

            } else

                if (op == PrimOps.PRIMOP_FOREIGN_FUNCTION) {

                    instruction = new Instruction.I_ForeignFunctionCall (basicOpExpressions.getForeignFunctionInfo());

                } else {

                    instruction = new Instruction.I_PrimOp(op);

                }

            int nArgs = basicOpExpressions.getNArguments ();

            if (nArgs < 0) {

                throw new CodeGenerationException ("Internal Coding Error: Invalid basic operator arity");  

            }

            if (op == PrimOps.PRIMOP_CAL_VALUE_TO_OBJECT) {

                //Prelude.calValueToObject is non-strict in its first argument.       

                gp.code (schemeC (basicOpExpressions.getArgument(0), p, d));

                gp.code (instruction);

            } else

            {

                for (int i = 0; i < nArgs; ++i) {

                    gp.code (schemeE (basicOpExpressions.getArgument(i), p, d + i));

                }

                gp.code (instruction);

            }

            appendUpdateCode(gp, d);

            return gp;

        }

        // Is e an application of a saturated constructor?

        if (ConstructorOpTuple.isConstructorOp(e, true) != null) {

            // Unpack the basic op into subexpressions

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    basic:");

            }

            ConstructorOpTuple  constructorOpExpressions = ConstructorOpTuple.isConstructorOp(e, false);

            DataConstructor dc = constructorOpExpressions.getDataConstructor ();

            Instruction instruction = Instruction.I_PackCons.makePackCons(dc);

            int nArgs = constructorOpExpressions.getNArguments ();

            if (nArgs < 0) {

                throw new CodeGenerationException ("Internal Coding Error: Invalid constructor operator arity");  

            }

            for (int i = 0; i < nArgs; ++i) {

                gp.code (schemeC (constructorOpExpressions.getArgument(nArgs - i - 1), p, d + i));

            }

            // Force the evaluation of any strict arguments.

            if (dc.hasStrictArgs()) {

                for (int i = 0; i < dc.getArity(); ++i) {

                    if (dc.isArgStrict(i)) {

                        gp.code(new Instruction.I_Push(i));

                        gp.code(Instruction.I_Eval);

                        gp.code(new Instruction.I_Pop(1));

                    }

                }

            }

            gp.code (instruction);

            appendUpdateCode (gp, d);

            return gp;

        }

        // Is e a variable?

        Expression.Var var = e.asVar();

        if (var != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    Var:");

            }

            // e is a variable, possible addressing modes are:

            // Push <k> for an argument

            // PushGlobal <l> for a label (e.g. supercombinator)

            // Code an Push <k> if we find it's an argument

            gp.code (schemeC (e, p, d));

            appendUpdateCode(gp, d);

            Integer ei = p.get(var.getName());

            if (CODEGEN_DIAG) {

                if (ei == null) {

                    MACHINE_LOGGER.log(Level.FINE, "        Global:");

                } else {

                    MACHINE_LOGGER.log(Level.FINE, "        local:");

                }

            }

            return gp;

        }

        // Is e a conditional op (if <cond expr> <then expr> <else expr>)?

        CondTuple conditionExpressions = CondTuple.isCondOp(e);

        if (conditionExpressions != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    condition:");

            }

            // This is a conditional op.  The conditionExpressions tuple holds (kCond, kThen, kElse) expressions

            // Generate the code for kThen and kElse, as arguments to a new I_Cond instruction

            gp.code (schemeE (conditionExpressions.getConditionExpression(), p, d));

            InstructionList thenPart = schemeR (conditionExpressions.getThenExpression(), p, d);

            InstructionList elsePart = schemeR (conditionExpressions.getElseExpression(), p, d);

            Instruction i = new Instruction.I_Cond (new Code (thenPart), new Code(elsePart));

            gp.code (i);

            return gp;         

        }

        // Is e a switch?

        Expression.Switch sw = e.asSwitch();

        if (sw != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    switch:");

            }

            gp.code (schemeE (sw.getSwitchExpr (), p, d));

            // Get the alternatives

            Expression.Switch.SwitchAlt[] alts = sw.getAlts();

            Map<Object, Code> altTagToCodeMap = new HashMap<Object, Code>();

            ModuleName moduleName = currentMachineFunction.getQualifiedName().getModuleName();

            // Build the code for each branch, save the variable requirement of each

            // branch as an alternative in gp, for later resolution

            for (final SwitchAlt alt : alts) {

                // For now, generate code for each tag.

                for (final Object altTag : alt.getAltTags()) {                  

                    String[] vars = getVars(alt, altTag);

                    Map<QualifiedName, Integer> newEnv = argOffset (0, p);

                    for (int j = 0; j < vars.length; ++j) {

                        QualifiedName qn = QualifiedName.make(moduleName, vars [j]);

                        newEnv.put (qn, Integer.valueOf(d + 1 + j));

                    }

                    // i_split: takes a dc object, tells it to push all (vars.length) fields onto the stack

                    InstructionList altGP = new InstructionList ();

                    altGP.code (new Instruction.I_Split (vars.length));

                    altGP.code (schemeR(alt.getAltExpr(), newEnv, d + vars.length));

                    Code code = new Code(altGP);

                    altTagToCodeMap.put(altTag, code);

                }

            }

            ErrorInfo errorInfo = sw.getErrorInfo() == null ? null : toRuntimeErrorInfo(sw.getErrorInfo());

            gp.code (new Instruction.I_Switch (altTagToCodeMap, errorInfo));

            return gp;

        }

        // Is e a data constructor field selection?

        Expression.DataConsSelection dataConsSelection = e.asDataConsSelection();

        if (dataConsSelection != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    selectDC:");

            }

            gp.code (schemeC(dataConsSelection.getDCValueExpr(), p, d));

            gp.code (new Instruction.I_LazySelectDCField(dataConsSelection.getDataConstructor(),

                    dataConsSelection.getFieldIndex(),

                    toRuntimeErrorInfo (dataConsSelection.getErrorInfo())));

//gp.code (schemeE (dataConsSelection.getDCValueExpr(), p, d));

//          // Extract the field value onto the stack.

//          int fieldIndex = dataConsSelection.getFieldIndex();

//          ErrorInfo errorInfo = dataConsSelection.getErrorInfo() == null ? null : new ErrorInfo(dataConsSelection.getErrorInfo());

//          gp.code (new Instruction.I_SelectDCField (dataConsSelection.getDataConstructor(), fieldIndex, errorInfo));

//          // Add a var to the env, and generate code for that var.

//          Expression.Var varName = dataConsSelection.getVarName();

//          QualifiedName varQualifiedName = varName.getName();

//          Map newEnv = argOffset (0, p);

//          newEnv.put (varQualifiedName, JavaPrimitives.makeInteger (d + 1));

//          gp.code (schemeR(varName, newEnv, d + 1));

            appendUpdateCode (gp, d);

            return gp;

        }

        // Is e a let expression?

        Expression.Let let = e.asLet();

        if (let != null) {

            // Currently the compiler doesn't differentialte between let and letrec scenarios.

            // As such we have to treat all lets as letrecs.

            Expression.Let.LetDefn[] defs = let.getDefns();

            EnvAndDepth ead = schemeXr (defs, p, d);           

            InstructionList gprecs = schemeCLetrec (defs, ead.env, ead.depth);

            gp.code (gprecs);

            gp.code (schemeR (let.getBody (), ead.env, ead.depth));

            return gp; 

        }

        // Is e a tail recursive call?

        if (e.asTailRecursiveCall() != null) {

            // The g-machine doesn't have a specific optimization for tail recursive calls

            // so we simply handle it as the original fully saturated application and let

            // the general tail call optimization handle it.

            return schemeR (e.asTailRecursiveCall().getApplForm(), p, d);

        }

        // Is e an application?

        Expression.Appl appl = e.asAppl();

        if (appl != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    Application:");

            }

            InstructionList il = schemeRS (e, p, d, 0);

            if (il != null) {

                gp.code (il);

                return gp;

            }

            gp.code (schemeC (e, p, d));

            appendUpdateCode(gp, d);

            return gp;

        }

        // Is e a record update

        // e is a record update

        Expression.RecordUpdate recordUpdate = e.asRecordUpdate();

        if (recordUpdate != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    Record update:");

            }

            gp.code (schemeE (e, p, d));

            appendUpdateCode (gp, d);

            return gp;

        }         

        // Is e a record extension

        // e is a record extension

        Expression.RecordExtension recordExtension = e.asRecordExtension();

        if (recordExtension != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    Record extension:");

            }

            gp.code (schemeE (e, p, d));

            appendUpdateCode (gp, d);

            return gp;

        } 

        // e is a record selection

        Expression.RecordSelection recordSelection = e.asRecordSelection();

        if (recordSelection != null) {

            if (CODEGEN_DIAG) {

                MACHINE_LOGGER.log(Level.FINE, "    Record selection:");

            }

            gp.code (schemeE (e, p, d));

            appendUpdateCode (gp, d);

            return gp;

        } 

        // e is a record case

        Expression.RecordCase recordCase = e.asRecordCase();

        if (recordCase != null) {

            // Strictly compile the condition expression

            Expression conditionExpr = recordCase.getConditionExpr();

            gp.code (schemeE (conditionExpr, p, d));

            Map<QualifiedName, Integer> newEnv = argOffset (0, p);

            QualifiedName recordName = QualifiedName.make(currentMachineFunction.getQualifiedName().getModuleName(), "$recordCase");

            newEnv.put (recordName, Integer.valueOf(++d));

            //FieldName -> String

            SortedMap<FieldName, String> fieldBindingVarMap = recordCase.getFieldBindingVarMap();

            int recordPos = 0;

            // This creates, if necessary, a record equivalent to the original record minus the bound fields.         

            String baseRecordPatternVarName = recordCase.getBaseRecordPatternVarName();       

            if (baseRecordPatternVarName != null &&

                    !baseRecordPatternVarName.equals(Expression.RecordCase.WILDCARD_VAR)) {

                recordPos++;

                // Create a new record that is the original record minus the bound fields.

                QualifiedName qn = QualifiedName.make(currentMachineFunction.getQualifiedName().getModuleName(), baseRecordPatternVarName);

                newEnv.put (qn, Integer.valueOf(++d));

                // push the original record

                gp.code (new Instruction.I_Push(0));

                // consume the record on top of the stack and replace with an extended version

                gp.code (new Instruction.I_ExtendRecord());

                // Now remove fields from the record as appropriate.

                for (final FieldName fieldName : fieldBindingVarMap.keySet()) {

                  

                    gp.code (new Instruction.I_RemoveRecordField(fieldName.getCalSourceForm()));

                }

            }

            // Now push the values for the bound fields onto the stack.

            for (final Map.Entry<FieldName, String> entry : fieldBindingVarMap.entrySet()) {

                FieldName fieldName = entry.getKey();

                String bindingVarName = entry.getValue();

                //ignore anonymous pattern variables. These are guaranteed not to be used

                //by the result expression, and so don't need to be extracted from the condition record.

                if (!bindingVarName.equals(Expression.RecordCase.WILDCARD_VAR)) {

                    QualifiedName qn = QualifiedName.make(currentMachineFunction.getQualifiedName().getModuleName(), bindingVarName);

                    newEnv.put(qn, Integer.valueOf(++d));

                    gp.code (new Instruction.I_Push (recordPos));

                    gp.code (new Instruction.I_RecordSelection (fieldName.getCalSourceForm()));

                    recordPos++;

                }

            }

            //encode the result expression in the context of the extended variable scope.

            Expression resultExpr = recordCase.getResultExpr();

            gp.code (schemeR (resultExpr, newEnv, d));

            appendUpdateCode(gp, d);

            return gp;

        }

        Expression.Cast cast = e.asCast();

        if (cast != null) {

            gp.code (schemeE(cast.getVarToCast(), p, d));

            gp.code (new Instruction.I_Cast(getCastType(cast)));

            appendUpdateCode(gp, d);

            return gp;

        }

        MACHINE_LOGGER.log(Level.FINE,

                "\nCodeGen: Bad exit of R compilation scheme with intermediate code:\n"

                + e);

        logEnvironment(p);       

        throw new CodeGenerationException ("Internal Coding Error: unrecognized expression " + e +".");

    }

    /** Execute the RS compilation scheme.  Completes the evaluation of an expression,

     * the top n ribs of which have already been put on the stack.

     * RS constructs instances of the ribs of E, putting them on the stack and

     * then unwinds in the same fashion as the R scheme.

     * @param e

     * @param p

     * @param d

     * @param n

     * @return null if the given Expression is not handled by the ES scheme, otherwise the IntructionList of generated instructions.

     * @throws CodeGenerationException

     */

    private InstructionList schemeRS (Expression e, Map<QualifiedName, Integer> p, int d, int n) throws CodeGenerationException {

        // RS[[ f ]] p d n = PUSHGLOBAL f; MKAP n; UPDATE (d-n); POP (d-n); UNWIND;