private EdiMapping(XDocument xml)
 {
     if (xml.Root == null)
         throw new Exception("XML is missing a root element.");
     Errors = new List<string>();
     _root = ReadLoop(xml.Root);
 }

        public override void Compile(ByteCode bc)
        {
            var L = new Loop
            {
                Scope = m_StackFrame
            };

            bc.PushSourceRef(m_Repeat);

            bc.LoopTracker.Loops.Push(L);

            var start = bc.GetJumpPointForNextInstruction();

            bc.Emit_Enter(m_StackFrame);
            m_Block.Compile(bc);

            bc.PopSourceRef();
            bc.PushSourceRef(m_Until);
            bc.Emit_Debug("..end");

            m_Condition.Compile(bc);
            bc.Emit_Leave(m_StackFrame);
            bc.Emit_Jump(OpCode.Jf, start);

            bc.LoopTracker.Loops.Pop();

            var exitpoint = bc.GetJumpPointForNextInstruction();

            foreach (var i in L.BreakJumps)
                i.NumVal = exitpoint;

            bc.PopSourceRef();
        }

		BlockingPipeListener(Loop loop)
			: base(loop)
		{
			PipeListener = new PipeListener(loop);
			Listener = PipeListener as Listener;
			Handle = PipeListener;
		}

 public void Dispose_should_throw_if_child_loops_not_disposed()
 {
     using (var loop = new Loop(Times.Once()))
     {
         loop.CreateLoop(Times.Exactly(2));
     }
 }

        public PrepareWatcher(Loop loop, Action<PrepareWatcher, EventTypes> callback)
            : base(loop)
        {
            this.callback = callback;

            watcher_ptr = manos_prepare_watcher_create (unmanaged_callback, GCHandle.ToIntPtr (gc_handle));
        }

    public IEnumerator Routine(Loop loop,float loopTime)
    {
        if (loop.actionDictionary.Count > 0)
        {
            List<Action> actionList = new List<Action>();
            actionList.AddRange(loop.actionDictionary.Values);

            while (runningLoop)
            {

                foreach (Action action in actionList)
                switch (action.actionType)
                {
                    case Action.ActionTypes.Move:

                        Move move = (Move)action;
                        move.ExecuteAction(this.gameObject);
                        break;

                    default:

                        CodeInputHandler.abortPlay("type failed ! check your action type  - 66 action.cs ");
                            runningLoop = false;
                        break;

                }
                yield return new WaitForSeconds(loopTime);
            }
        }
        else
        {
            yield return new WaitForSeconds(loopTime);
        }
    }

		BlockingTcpListener(Loop loop)
			: base(loop)
		{
			TcpListener = new TcpListener(loop);
			Listener = TcpListener as Listener;
			Handle = TcpListener;
		}

 public void Dispose_should_do_nothing_if_called_multiple_times()
 {
     using (var loop = new Loop(Times.Once()))
     {
         loop.Dispose();
         loop.Dispose();
     }
 }

        public void A_new_step_should_be_added_directly_if_it_contains_no_child_loops()
        {
            using (var loop = new Loop(Times.Once()))
            {
                var step = loop.CreateStep("", Times.Once());

                Assert.That(loop.Steps.Contains(step));
            }
        }

		public MicroThread(Loop loop, Action callback)
		{
			Loop = loop;

			State = MicroThreadState.NotStarted;
			Loop.GetMicroThreadCollection().Add(this);

			cb = callback;
		}

        public FlatLoop(Loop sourceLoop, FlatFace flatFace)
        {
            this.sourceLoop = sourceLoop;
            this.flatFace = flatFace;

            fins = new List<FlatFin>();
            foreach (Fin fin in sourceLoop.Fins)
                fins.Add(new FlatFin(this, fin));
        }

 public void A_new_loop_should_be_added_directly_if_it_contains_no_child_loops()
 {
     using (var loop = new Loop(Times.Once()))
     {
         using (var child = loop.CreateLoop(Times.Once()))
         {
             Assert.That(loop.Steps.Contains(child));
         }
     }
 }

 public static void Compute(Loop loop, string file)
 {
     var @in = new UVFileStream(loop);
     @in.Open(file, UVFileAccess.Read, (ex) => {
         HashStream.ComputeString(SHA1Managed.Create(), @in, (str) => {
             Console.WriteLine ("{0} {1}", str, file);
         });
         @in.Resume();
     });
 }

        public void InvalidRange()
        {
            var stringlit = new StringLiteral("foo", 0);
            var range = new Range(stringlit, stringlit, 0);
            var variabledecl = new VariableDeclaration("foo", "int", 0);
            var variable = new VariableReference("foo", 0);
            var loop = new Loop(variable, range, new List<Statement>(), 0);
            statementlist.Add(variabledecl);
            statementlist.Add(loop);
            var parsetree = new Program(statementlist);

            Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
        }

            public void visit(Loop node)
            {
                if (symboltable.resolve(node.VarName).Type != "int")
                    throw new SemanticError("Loop variable " + node.VarName +
                        " on row " + node.Row + " is not an int.");

                for (int i = 0; i < 2; i++)
                { // Check twice to prevent variable declarations inside the loop body
                    // (would cause problems because of singular scope).
                    foreach (Statement statement in node.LoopBody)
                        statement.accept(this);
                }
            }

        //------------------------------------------------------------------
        protected Driver(Car car)
            : base(car)
        {
            Loop = new Loop();
            Sequence = new Sequence();
            AddInLoop (Sequence);

            Car = car;

            Velocity = Car.Lane.Velocity;
            ChangeLaneSpeed = 1;
            SafeZone = new SafeZone (this, 1);
            Primary = Direction.Left;
        }

        public void NonIntegerLoopVariable(string type)
        {
            var variabledecl = new VariableDeclaration("foo", type, 0);
            statementlist.Add(variabledecl);
            var variable = new VariableReference("foo", 0);
            var integer = new IntegerLiteral("5", 0);
            var range = new Range(integer, integer, 0);
            var variabledecl2 = new VariableDeclaration("bar", "int", 0);
            var loopbody = new List<Statement>();
            loopbody.Add(variabledecl2);
            var loop = new Loop(variable, range, loopbody, 0);
            statementlist.Add(loop);
            var parsetree = new Program(statementlist);

            Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
        }

 public static Task Create(Loop loop, string name, int mode)
 {
     var tcs = new TaskCompletionSource<object>();
     try {
         UVDirectory.Create(loop, name, mode, (e) => {
             if (e == null) {
                 tcs.SetResult(null);
             } else {
                 tcs.SetException(e);
             }
         });
     } catch (Exception e) {
         tcs.SetException(e);
     }
     return tcs.Task;
 }

 public static Task Delete(Loop loop, string path)
 {
     var tcs = new TaskCompletionSource<object>();
     try {
         UVDirectory.Delete(loop, path, (e) => {
             if (e == null) {
                 tcs.SetResult(null);
             } else {
                 tcs.SetException(e);
             }
         });
     } catch (Exception e) {
         tcs.SetException(e);
     }
     return tcs.Task;
 }

		public override void Compile(ByteCode bc)
		{
			bc.PushSourceRef(m_RefFor);

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

			bc.LoopTracker.Loops.Push(L);

			m_End.Compile(bc);
			bc.Emit_ToNum(3);
			m_Step.Compile(bc);
			bc.Emit_ToNum(2);
			m_Start.Compile(bc);
			bc.Emit_ToNum(1);

			int start = bc.GetJumpPointForNextInstruction();
			var jumpend = bc.Emit_Jump(OpCode.JFor, -1);
			bc.Emit_Enter(m_StackFrame);
			//bc.Emit_SymStorN(m_VarName);

			bc.Emit_Store(m_VarName, 0, 0);

			m_InnerBlock.Compile(bc);

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

			bc.Emit_Debug("..end");
			bc.Emit_Leave(m_StackFrame);
			bc.Emit_Incr(1);
			bc.Emit_Jump(OpCode.Jump, start);

			bc.LoopTracker.Loops.Pop();

			int exitpoint = bc.GetJumpPointForNextInstruction();

			foreach (Instruction i in L.BreakJumps)
				i.NumVal = exitpoint;

			jumpend.NumVal = exitpoint;
			bc.Emit_Pop(3);

			bc.PopSourceRef();
		}