public static void If(Executor exec)
 {
     var code = exec.DataStack.Pop<Tokens.CodeBlock>().Value;
     var condition = exec.DataStack.Pop<Tokens.Number>().Value != 0;
     if (condition)
         exec.CodeStack.PushRange(code);
 }

        public static void Bury(Executor exec)
        {
            var count = exec.DataStack.Pop<Tokens.Number>().Value;
            var token = exec.DataStack.Pop<IToken>();

            exec.DataStack.Bury(token, (int) count);
        }

        public static void Def(Executor exec)
        {
            var name = exec.DataStack.Pop<Tokens.Symbol>().Value;
            var code = exec.DataStack.Pop<Tokens.CodeBlock>().Value;

            exec.Methods[name] = new Executor.CodeblockFunction(code.ToList());
        }

 public static void Swap(Executor exec)
 {
     var a = exec.DataStack.Pop<IToken>();
     var b = exec.DataStack.Pop<IToken>();
     exec.DataStack.Push(a);
     exec.DataStack.Push(b);
 }

 public CharacterHandler(char toHandle, Executor Execute, bool stop)
 {
     this.toHandle = toHandle;
     this.Condition = SimpleCheck;
     this.Execute = Execute;
     this.stop = stop;
 }

        public static void Dig(Executor exec)
        {
            var count = exec.DataStack.Pop<Tokens.Number>().Value;
            var token = exec.DataStack.Dig<IToken>((int) count);

            exec.DataStack.Push(token);
        }

 public IOutputExecutor Create(Settings settings)
 {
     Executor = Executor.WithForsetiConfigurationFile(settings.ForsetiConfigurationFile, verbose: settings.VerboseOutput);
     Executor.ReportWith<Forseti.AppVeyor.Reporter>();
     Executor.RegisterWatcher<Forseti.ConsoleReporter.ConsoleHarnessWatcher>();
     return this;
 }

        /// <param name="options">Compile options</param>
        /// <param name="runInSeparateAppDomain">Should be set to true for production code, but there are issues with NUnit, so tests need to set this to false.</param>
        public bool Compile(CompilerOptions options, bool runInSeparateAppDomain)
        {
            try {
                AppDomain ad = null;
                var actualOut = Console.Out;
                try {
                    Console.SetOut(new StringWriter());	// I don't trust the third-party libs to not generate spurious random messages, so make sure that any of those messages are suppressed.

                    var er = new ErrorReporterWrapper(_errorReporter, actualOut);

                    Executor executor;
                    if (runInSeparateAppDomain) {
                        var setup = new AppDomainSetup { ApplicationBase = Path.GetDirectoryName(typeof(Executor).Assembly.Location) };
                        ad = AppDomain.CreateDomain("SCTask", null, setup);
                        executor = (Executor)ad.CreateInstanceAndUnwrap(typeof(Executor).Assembly.FullName, typeof(Executor).FullName);
                    }
                    else {
                        executor = new Executor();
                    }
                    return executor.Compile(options, er);
                }
                finally {
                    if (ad != null) {
                        AppDomain.Unload(ad);
                    }
                    if (actualOut != null) {
                        Console.SetOut(actualOut);
                    }
                }
            }
            catch (Exception ex) {
                _errorReporter.InternalError(ex, null, TextLocation.Empty);
                return false;
            }
        }

		public void WillThrowAnExceptionWithOnlyOneRetry()
		{
			var executor = new Executor(3, new InvalidOperationException());
			var proxy = (Executor)proxyGenerator.CreateClassProxyWithTarget(typeof(Executor), executor, new[] { new RetryInterceptor(1) });
			proxy.Execute();
			Assert.Fail();
		}

        public static void Redef(Executor exec)
        {
            var to = exec.DataStack.Pop<Tokens.Symbol>().Value;
            var from = exec.DataStack.Pop<Tokens.Symbol>().Value;

            exec.Methods[to] = exec.Methods[from];
        }

            public override void Eval(Executor exec)
            {
                string sHelpFile = Config.gsDataFolder + "\\help.html";
                StreamWriter sw = new StreamWriter(sHelpFile);
                sw.WriteLine("<html><head><title>Cat Help File</title></head><body>");

                /*
                sw.WriteLine("<h1><a name='level0prims'></a>Level 0 Primitives</h1>");
                OutputTable(sw, "level0", exec);
                sw.WriteLine("<h1><a name='level1prims'></a>Level 1 Primitives</h1>");
                OutputTable(sw, "level1", exec);               
                sw.WriteLine("<h1><a name='level2prims'></a>Level 2 Primitives</h1>");
                OutputTable(sw, "level2", exec);                
                sw.WriteLine("<h1><a name='otherprims'></a>Other Functions</h1>");
                OutputTable(sw, "", exec);
                 */

                sw.WriteLine("<h1>Instructions</h1>");
                OutputAllTable(sw, exec);

                sw.WriteLine("<h1>Definitions</h1>");
                sw.WriteLine("<pre>");
                foreach (Function f in exec.GetAllFunctions())
                {
                    sw.WriteLine(f.GetImplString(true));
                }
                sw.WriteLine("</pre>");

                sw.WriteLine("</body></html>");
                sw.Close();
                Output.WriteLine("saved help file to " + sHelpFile);
            }

            public override void Eval(Executor exec)
            {
                string s = exec.PopString();

                Executor aux = new Executor(exec);
                aux.Execute(s);
                exec.Push(aux.GetStackAsList());
            }

 public override ICommand Execute()
 {
     using (Executor executor = new Executor(this))
     {
         executor.Execute();
         return this;
     }
 }

        public void SetUp()
        {
            symbols = A.Fake<Symbols>();
              tokenizer = A.Fake<Tokenizer>();
              executor = A.Fake<Executor>();

              sut = new Interpreter(symbols, tokenizer, executor);
        }

        public static void Unpack(Executor exec)
        {
            var block = exec.DataStack.Pop<Tokens.PackedBlock>().Value;
            var count = block.Count;

            exec.DataStack.PushRange(block);
            exec.DataStack.Push(new Tokens.Number(count));
        }

 public static void PackedResize(Executor exec)
 {
     var size = (int) exec.DataStack.Pop<Tokens.Number>().Value;
     var value = exec.DataStack.Peek<Tokens.PackedBlock>().Value;
     if (value.Count > size)
         value.RemoveRange(value.Count - size - 1, size);
     else if (value.Count < size)
         value.AddRange(Enumerable.Repeat<IToken>(null, size - value.Count));
 }

        public static void Dive(Executor exec)
        {
            var count = exec.DataStack.Pop<Tokens.Number>().Value;
            var code = exec.DataStack.Pop<Tokens.CodeBlock>().Value;

            exec.DataStack.Dive += (int) count;

            exec.CodeStack.PushRange(new IToken[] { new Tokens.Number(-count), new Tokens.Method(" dive") });
            exec.CodeStack.PushRange(code);
        }

        public PartialViewExecutor( MethodInfo method )
        {
            var name = method.Name;
              if ( !name.StartsWith( PartialRenderAdapter.partialExecutorMethodPrefix ) )
            throw new InvalidOperationException();
              Name = name.Substring( PartialRenderAdapter.partialExecutorMethodPrefix.Length );
              _parameters = method.GetParameters();

              _executor = CreateExecutor( method );
        }

        public void SetUp()
        {
            instruction = new InstructionTestDouble();
              var registry = new Registry {
            { 0x00, opcode, instruction, AddressingMode.Implied} };

              model = new ProgrammingModel();
              memory = new Memory();
              executor = new Executor(registry, model, memory);
        }

 public static void Main(string[] args)
 {
     IExecutor executor = new Executor();
     executor.TaskCompleted += Completed;
     foreach (int i in Enumerable.Range(1, NumTasks))
     {
         executor.ExecuteAsync(i);
     }
     _countdown.Wait();
     Environment.Exit(0);
 }