// 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!

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

    static final UnexecutableNil U_NIL = UnexecutableNil.U_NIL;

    public static IRBuilder createIRBuilder(Ruby runtime, IRManager manager) {

        return new IRBuilder(manager);

    }

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

        Ruby ruby = Ruby.getGlobalRuntime();

        // 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 ignored) { }

        }

    }

    private static class IRLoop {

        public final IRScope  container;

        public final IRLoop   parentLoop;

        public final Label    loopStartLabel;

        public final Label    loopEndLabel;

        public final Label    iterStartLabel;

        public final Label    iterEndLabel;

        public final Variable loopResult;

        public IRLoop(IRScope s, IRLoop outerLoop) {

            container = s;

            parentLoop = outerLoop;

            loopStartLabel = s.getNewLabel("_LOOP_BEGIN");

            loopEndLabel   = s.getNewLabel("_LOOP_END");

            iterStartLabel = s.getNewLabel("_ITER_BEGIN");

            iterEndLabel   = s.getNewLabel("_ITER_END");

            loopResult     = s.createTemporaryVariable();

            s.setHasLoopsFlag();

        }

    }

    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 rescue 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(IRBuilder b, IRScope s, IRLoop currLoop) {

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

        }

    }

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

     * Every ensure block has a start label and end label

     *

     * 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

     *     .. copy of ensure block IR ..

     *  L_dummy_rescue:

     *     e = recv_exc

     *  L_start:

     *     .. ensure block IR ..

     *     throw e

     *  L_end:

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

     *

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

     * and returns), N has to first run the ensure block before exiting.

     *

     * 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

     * run the stack of ensure blocks in the right order.

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

    private static class EnsureBlockInfo {

        Label    regionStart;

        Label    start;

        Label    end;

        Label    dummyRescueBlockLabel;

        Variable savedGlobalException;

        // Label of block that will rescue exceptions raised by ensure code

        Label    bodyRescuer;

        // 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;

        // This ensure block's instructions

        List<Instr> instrs;

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

            regionStart = s.getNewLabel();

            start       = s.getNewLabel();

            end         = s.getNewLabel();

            dummyRescueBlockLabel = s.getNewLabel();

            instrs = new ArrayList<>();

            savedGlobalException = null;

            innermostLoop = l;

            matchingRescueNode = n;

            this.bodyRescuer = bodyRescuer;

        }

        public void addInstr(Instr i) {

            instrs.add(i);

        }

        public void addInstrAtBeginning(Instr i) {

            instrs.add(0, i);

        }

        public void emitBody(IRBuilder b, IRScope s) {

            b.addInstr(s, new LabelInstr(start));

            for (Instr i: instrs) {

                b.addInstr(s, i);

            }

        }

        public void cloneIntoHostScope(IRBuilder b, IRScope s) {

            SimpleCloneInfo ii = new SimpleCloneInfo(s, true);

            // Clone required labels.

            // During normal cloning below, labels not found in the rename map

            // are not cloned.

            ii.renameLabel(start);

            for (Instr i: instrs) {

                if (i instanceof LabelInstr) {

                    ii.renameLabel(((LabelInstr)i).label);

                }

            }

            // Clone instructions now

            b.addInstr(s, new LabelInstr(ii.getRenamedLabel(start)));

            b.addInstr(s, new ExceptionRegionStartMarkerInstr(bodyRescuer));

            for (Instr i: instrs) {

                Instr clonedInstr = i.clone(ii);

                if (clonedInstr instanceof CallBase) {

                    CallBase call = (CallBase)clonedInstr;

                    Operand block = call.getClosureArg(null);

                    if (block instanceof WrappedIRClosure) s.addClosure(((WrappedIRClosure)block).getClosure());

                }

                b.addInstr(s, clonedInstr);

            }

            b.addInstr(s, new ExceptionRegionEndMarkerInstr());

        }

    }

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

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

    // Stack of ensure blocks that are currently active

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

    // Stack of ensure blocks whose bodies are being constructed

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

    // Combined stack of active rescue/ensure nestings -- required to properly set up

    // rescuers for ensure block bodies cloned into other regions -- those bodies are

    // rescued by the active rescuers at the point of definition rather than the point

    // of cloning.

    private Stack<Label> activeRescuers = new Stack<>();

    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<>();

    public IRLoop getCurrentLoop() {

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

    }

    protected IRManager manager;

    public IRBuilder(IRManager manager) {

        this.manager = manager;