public override void Compile(ByteCode bc)
        {
            _function.Compile(bc);

            int argslen = _arguments.Count;

            if (!string.IsNullOrEmpty(_name))
            {
                bc.Emit_Copy(0);
                bc.Emit_Index(DynValue.NewString(_name), true);
                bc.Emit_Swap(0, 1);
                ++argslen;
            }

            for (int i = 0; i < _arguments.Count; i++)
            {
                _arguments[i].Compile(bc);
            }

            if (!string.IsNullOrEmpty(_name))
            {
                bc.Emit_ThisCall(argslen, _debugErr);
            }
            else
            {
                bc.Emit_Call(argslen, _debugErr);
            }
        }
        public override void Compile(ByteCode bc)
        {
            //for var_1, ···, var_n in explist do block end

            bc.PushSourceRef(m_RefFor);

            Loop L = new Loop()
            {
                Scope = m_StackFrame
            };

            bc.LoopTracker.Loops.Push(L);

            // get iterator tuple
            m_RValues.Compile(bc);

            // prepares iterator tuple - stack : iterator-tuple
            bc.Emit_IterPrep();

            // loop start - stack : iterator-tuple
            int start = bc.GetJumpPointForNextInstruction();

            bc.Emit_Enter(m_StackFrame);

            // expand the tuple - stack : iterator-tuple, f, var, s
            bc.Emit_ExpTuple(0);

            // calls f(s, var) - stack : iterator-tuple, iteration result
            bc.Emit_Call(2, "for..in");

            // perform assignment of iteration result- stack : iterator-tuple, iteration result
            for (int i = 0; i < m_NameExps.Length; i++)
            {
                m_NameExps[i].CompileAssignment(bc, 0, i);
            }

            // pops  - stack : iterator-tuple
            bc.Emit_Pop();

            // repushes the main iterator var - stack : iterator-tuple, main-iterator-var
            bc.Emit_Load(m_Names[0]);

            // updates the iterator tuple - stack : iterator-tuple, main-iterator-var
            bc.Emit_IterUpd();

            // checks head, jumps if nil - stack : iterator-tuple, main-iterator-var
            var endjump = bc.Emit_Jump(OpCode.JNil, -1);

            // executes the stuff - stack : iterator-tuple
            m_Block.Compile(bc);

            bc.PopSourceRef();
            bc.PushSourceRef(m_RefEnd);

            // loop back again - stack : iterator-tuple
            bc.Emit_Leave(m_StackFrame);
            bc.Emit_Jump(OpCode.Jump, start);

            bc.LoopTracker.Loops.Pop();

            int exitpointLoopExit = bc.GetJumpPointForNextInstruction();

            bc.Emit_Leave(m_StackFrame);

            int exitpointBreaks = bc.GetJumpPointForNextInstruction();

            bc.Emit_Pop();

            foreach (Instruction i in L.BreakJumps)
            {
                i.NumVal = exitpointBreaks;
            }

            endjump.NumVal = exitpointLoopExit;

            bc.PopSourceRef();
        }