// IR Building Notes

// -----------------

//

// 1. More copy instructions added than necessary

// ----------------------------------------------

// Note that in general, there will be lots of a = b kind of copies

// introduced in the IR because the translation is entirely single-node focused.

// An example will make this clear

//

// RUBY:

//     v = @f

// will translate to

//

// AST:

//     LocalAsgnNode v

//       InstrVarNode f

// will translate to

//

// IR:

//     tmp = self.f [ GET_FIELD(tmp,self,f) ]

//     v = tmp      [ COPY(v, tmp) ]

//

// instead of

//     v = self.f   [ GET_FIELD(v, self, f) ]

//

// We could get smarter and pass in the variable into which this expression is going to get evaluated

// and use that to store the value of the expression (or not build the expression if the variable is null).

//

// But, that makes the code more complicated, and in any case, all this will get fixed in a single pass of

// copy propagation and dead-code elimination.

//

// Something to pay attention to and if this extra pass becomes a concern (not convinced that it is yet),

// this smart can be built in here.  Right now, the goal is to do something simple and straightforward that is going to be correct.

//

// 2. Returning null vs manager.getNil()

// ----------------------------

// - We should be returning null from the build methods where it is a normal "error" condition

// - We should be returning manager.getNil() where the actual return value of a build is the ruby nil operand

//   Look in buildIf for an example of this

//

// 3. Temporary variable reuse

// ---------------------------

// I am reusing variables a lot in places in this code.  Should I instead always get a new variable when I need it

// This introduces artificial data dependencies, but fewer variables.  But, if we are going to implement SSA pass

// this is not a big deal.  Think this through!

    protected static final Operand[] NO_ARGS = new Operand[]{};

    protected static final UnexecutableNil U_NIL = UnexecutableNil.U_NIL;

    private static String  rubyVersion = "1.8"; // default is 1.8

    public static void setRubyVersion(String rubyVersion) {

        IRBuilder.rubyVersion = rubyVersion;

    }

    public boolean is1_9() {

        return false;

    }

    /* -----------------------------------------------------------------------------------

     * Every ensure block has a start label and end label, and at the end, it will jump

     * to an address stored in a return address variable.

     *

     * This ruby code will translate to the IR shown below

     * -----------------

     *   begin

     *       ... protected body ...

     *   ensure

     *       ... ensure block to run

     *   end

     * -----------------

     *  L_region_start

     *     IR instructions for the protected body

     *  L_start:

     *     .. ensure block IR ...

     *     jump %ret_addr

     *  L_end:

     * -----------------

     *

     * If N is a node in the protected body that might exit this scope (exception rethrows

     * and returns), N has to first jump to the ensure block and let the ensure block run.

     * In addition, N has to set up a return address label in the return address var of

     * this ensure block so that the ensure block can transfer control block to N.

     *

     * Since we can have a nesting of ensure blocks, we are maintaining a stack of these

     * well-nested ensure blocks.  Every node N that will exit this scope will have to

     * co-ordinate the jumps in-and-out of the ensure blocks in the top-to-bottom stacked

     * order.

     * ----------------------------------------------------------------------------------- */

    private static class EnsureBlockInfo {

        Label    regionStart;

        Label    start;

        Label    end;

        Label    dummyRescueBlockLabel;

        Variable returnAddr;

        Variable savedGlobalException;

        // Innermost loop within which this ensure block is nested, if any

        IRLoop   innermostLoop;

        // AST node for any associated rescue node in the case of begin-rescue-ensure-end block

        // Will be null in the case of begin-ensure-end block

        RescueNode matchingRescueNode;  

        public EnsureBlockInfo(IRScope s, RescueNode n, IRLoop l) {

            regionStart = s.getNewLabel();

            start       = s.getNewLabel();

            end         = s.getNewLabel();

            returnAddr  = s.getNewTemporaryVariable();

            dummyRescueBlockLabel = s.getNewLabel();

            savedGlobalException = null;

            innermostLoop = l;

            matchingRescueNode = n;

        }

        // Emit jump chain by walking up the ensure block stack

        // If we have been passed a loop value, then emit values that are nested within that loop

        public static void emitJumpChain(IRScope s, Stack<EnsureBlockInfo> ebStack, IRLoop loop) {

            // SSS: There are 2 ways of encoding this:

            // 1. Jump to ensure block 1, return back here, jump ensure block 2, return back here, ...

            //    Generates 3*n instrs. where n is the # of ensure blocks to execute

            // 2. Jump to ensure block 1, then to block 2, then to 3, ...

            //    Generates n+1 instrs. where n is the # of ensure blocks to execute

            // Doesn't really matter all that much since we shouldn't have deep nesting of ensure blocks often

            // but is there a reason to go with technique 1 at all??

            int n = ebStack.size();

            EnsureBlockInfo[] ebArray = ebStack.toArray(new EnsureBlockInfo[n]);

            for (int i = n-1; i >= 0; i--) {

                EnsureBlockInfo ebi = ebArray[i];

                //

                if (ebi.innermostLoop != loop) break;

                Label retLabel = s.getNewLabel();

                if (ebi.savedGlobalException != null) {

                    s.addInstr(new PutGlobalVarInstr("$!", ebi.savedGlobalException));

                }

                s.addInstr(new SetReturnAddressInstr(ebi.returnAddr, retLabel));

                s.addInstr(new JumpInstr(ebi.start));

                s.addInstr(new LabelInstr(retLabel));

            }

        }

    }

    // Stack encoding nested ensure blocks

    private Stack<EnsureBlockInfo> _ensureBlockStack = new Stack<EnsureBlockInfo>();

    private static class RescueBlockInfo {

        RescueNode rescueNode;             // Rescue node for which we are tracking info 

        Label      entryLabel;             // Entry of the rescue block

        Variable   savedExceptionVariable; // Variable that contains the saved $! variable

        IRLoop     innermostLoop;          // Innermost loop within which this ensure block is nested, if any

        public RescueBlockInfo(RescueNode n, Label l, Variable v, IRLoop loop) {

            rescueNode = n;

            entryLabel = l;

            savedExceptionVariable = v;

            innermostLoop = loop;

        }

        public void restoreException(IRScope s, IRLoop currLoop) {

            if (currLoop == innermostLoop) s.addInstr(new PutGlobalVarInstr("$!", savedExceptionVariable));

        }

    }

    // Stack encoding nested rescue blocks -- this just tracks the start label of the blocks

    private Stack<RescueBlockInfo> _rescueBlockStack = new Stack<RescueBlockInfo>();

    private int _lastProcessedLineNum = -1;

    // Since we are processing ASTs, loop bodies are processed in depth-first manner

    // with outer loops encountered before inner loops, and inner loops finished before outer ones.

    //

    // So, we can keep track of loops in a loop stack which  keeps track of loops as they are encountered.

    // This lets us implement next/redo/break/retry easily for the non-closure cases

    private Stack<IRLoop> loopStack = new Stack<IRLoop>();

    public IRLoop getCurrentLoop() {

        return loopStack.isEmpty() ? null : loopStack.peek();

    }

   

    protected IRManager manager;

   

    public IRBuilder(IRManager manager) {

        this.manager = manager;

    }

    public static Node buildAST(boolean isCommandLineScript, String arg) {

        Ruby ruby = Ruby.getGlobalRuntime();

       

        // set to IR mode, since we use different scopes, etc for IR

        ruby.getInstanceConfig().setCompileMode(CompileMode.OFFIR);

       

        // inline script

        if (isCommandLineScript) return ruby.parse(ByteList.create(arg), "-e", null, 0, false);

        // from file

        FileInputStream fis = null;

        try {

            File file = new File(arg);

            fis = new FileInputStream(file);

            long size = file.length();

            byte[] bytes = new byte[(int)size];

            fis.read(bytes);

            System.out.println("-- processing " + arg + " --");

            return ruby.parse(new ByteList(bytes), arg, null, 0, false);

        } catch (IOException ioe) {

            throw new RuntimeException(ioe);

        } finally {

            try { if (fis != null) fis.close(); } catch(Exception e) { }

        }

    }

    public static IRBuilder createIRBuilder(IRManager manager, boolean is19) {

        return is19 ? new IRBuilder19(manager) : new IRBuilder(manager);

    }

    public Node skipOverNewlines(IRScope s, Node n) {

        if (n.getNodeType() == NodeType.NEWLINENODE) {

            // Do not emit multiple line number instrs for the same line

            int currLineNum = n.getPosition().getStartLine();

            if (currLineNum != _lastProcessedLineNum) {

               s.addInstr(new LineNumberInstr(s, currLineNum));

               _lastProcessedLineNum = currLineNum;

            }

        }

        while (n.getNodeType() == NodeType.NEWLINENODE)

            n = ((NewlineNode)n).getNextNode();

        return n;

    }

    public Operand build(Node node, IRScope s) {

        if (node == null) return null;

        if (s == null) {

            System.out.println("Got a null scope!");

            throw new NotCompilableException("Unknown node encountered in builder: " + node);

        }

        switch (node.getNodeType()) {

            case ALIASNODE: return buildAlias((AliasNode) node, s);

            case ANDNODE: return buildAnd((AndNode) node, s);

            case ARGSCATNODE: return buildArgsCat((ArgsCatNode) node, s);

            case ARGSPUSHNODE: return buildArgsPush((ArgsPushNode) node, s);

            case ARRAYNODE: return buildArray(node, s);

            case ATTRASSIGNNODE: return buildAttrAssign((AttrAssignNode) node, s);

            case BACKREFNODE: return buildBackref((BackRefNode) node, s);

            case BEGINNODE: return buildBegin((BeginNode) node, s);

            case BIGNUMNODE: return buildBignum((BignumNode) node, s);

            case BLOCKNODE: return buildBlock((BlockNode) node, s);

            case BREAKNODE: return buildBreak((BreakNode) node, s);

            case CALLNODE: return buildCall((CallNode) node, s);

            case CASENODE: return buildCase((CaseNode) node, s);

            case CLASSNODE: return buildClass((ClassNode) node, s);

            case CLASSVARNODE: return buildClassVar((ClassVarNode) node, s);

            case CLASSVARASGNNODE: return buildClassVarAsgn((ClassVarAsgnNode) node, s);

            case CLASSVARDECLNODE: return buildClassVarDecl((ClassVarDeclNode) node, s);

            case COLON2NODE: return buildColon2((Colon2Node) node, s);

            case COLON3NODE: return buildColon3((Colon3Node) node, s);

            case CONSTDECLNODE: return buildConstDecl((ConstDeclNode) node, s);

            case CONSTNODE: return searchConst(s, s, ((ConstNode) node).getName());

            case DASGNNODE: return buildDAsgn((DAsgnNode) node, s);

            case DEFINEDNODE: return buildGetDefinitionBase(((DefinedNode) node).getExpressionNode(), s);

            case DEFNNODE: return buildDefn((MethodDefNode) node, s);

            case DEFSNODE: return buildDefs((DefsNode) node, s);

            case DOTNODE: return buildDot((DotNode) node, s);

            case DREGEXPNODE: return buildDRegexp((DRegexpNode) node, s);

            case DSTRNODE: return buildDStr((DStrNode) node, s);

            case DSYMBOLNODE: return buildDSymbol((DSymbolNode) node, s);

            case DVARNODE: return buildDVar((DVarNode) node, s);

            case DXSTRNODE: return buildDXStr((DXStrNode) node, s);

            case ENSURENODE: return buildEnsureNode((EnsureNode) node, s);

            case EVSTRNODE: return buildEvStr((EvStrNode) node, s);

            case FALSENODE: return buildFalse(node, s);

            case FCALLNODE: return buildFCall((FCallNode) node, s);

            case FIXNUMNODE: return buildFixnum((FixnumNode) node, s);

            case FLIPNODE: return buildFlip((FlipNode) node, s);

            case FLOATNODE: return buildFloat((FloatNode) node, s);

            case FORNODE: return buildFor((ForNode) node, s);

            case GLOBALASGNNODE: return buildGlobalAsgn((GlobalAsgnNode) node, s);

            case GLOBALVARNODE: return buildGlobalVar((GlobalVarNode) node, s);

            case HASHNODE: return buildHash((HashNode) node, s);

            case IFNODE: return buildIf((IfNode) node, s);

            case INSTASGNNODE: return buildInstAsgn((InstAsgnNode) node, s);

            case INSTVARNODE: return buildInstVar((InstVarNode) node, s);

            case ITERNODE: return buildIter((IterNode) node, s);

            case LITERALNODE: return buildLiteral((LiteralNode) node, s);

            case LOCALASGNNODE: return buildLocalAsgn((LocalAsgnNode) node, s);

            case LOCALVARNODE: return buildLocalVar((LocalVarNode) node, s);

            case MATCH2NODE: return buildMatch2((Match2Node) node, s);

            case MATCH3NODE: return buildMatch3((Match3Node) node, s);

            case MATCHNODE: return buildMatch((MatchNode) node, s);

            case MODULENODE: return buildModule((ModuleNode) node, s);

            case MULTIPLEASGNNODE: return buildMultipleAsgn((MultipleAsgnNode) node, s); // Only for 1.8

            case NEWLINENODE: return buildNewline((NewlineNode) node, s);

            case NEXTNODE: return buildNext((NextNode) node, s);

            case NTHREFNODE: return buildNthRef((NthRefNode) node, s);

            case NILNODE: return buildNil(node, s);