示例#1
0
        public CodeObject Compile(AstNode syntaxNode, CodeProgram prog)
        {
            var syntax = (ScriptWhileStatement)syntaxNode;

            var code = new CodeWhileStatement(
                AstDomCompiler.Compile <CodeExpression>(syntax.Condition.Expression, prog),
                AstDomCompiler.Compile <CodeStatement>(syntax.Statement, prog));

            return(code);
        }
    public CodeObject Compile(AstNode syntaxNode, CodeProgram prog)
    {
      var syntax = (ScriptWhileStatement)syntaxNode;

      var code = new CodeWhileStatement(
         AstDomCompiler.Compile<CodeExpression>(syntax.Condition.Expression, prog),
         AstDomCompiler.Compile<CodeStatement>(syntax.Statement, prog));

      return code;
    }
示例#3
0
        public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
        {
            var forStatement = (CodeForEachStatement)code;

            //foreach (i in c) statement ~
            //
            //f_ = c.GetEnumerator();
            //while(f_.Next()) {i = f_.Current; statement; }

            _sid++;
            string fName = "#ForEach_" + _sid;

            var fblock = new CodeBlockStatement();

            var f  = new CodeAssignExpression(fName, forStatement.Container);
            var f1 = new CodeAssignExpression(fName,
                                              new CodeObjectReference(fName,
                                                                      new CodeObjectReference("GetEnumerator", null,
                                                                                              new CodeObject[] { new CodeObjectFunctionCall(new CodeExpression[0]) }), new CodeObject[0]));

            var fwhileBlock = new CodeBlockStatement();

            var i = new CodeAssignExpression(forStatement.Id.Id,
                                             new CodeObjectReference(fName,
                                                                     new CodeObjectReference("get_Current", null,
                                                                                             new CodeObject[] { new CodeObjectFunctionCall(new CodeExpression[0]) }), new CodeObject[0]));

            fwhileBlock.Statements.Add(new CodeExpressionStatement(i));
            fwhileBlock.Statements.Add(forStatement.Statement);

            var fwhile = new CodeWhileStatement(
                new CodeObjectReference(fName,
                                        new CodeObjectReference("MoveNext", null,
                                                                new CodeObject[] { new CodeObjectFunctionCall(new CodeExpression[0]) }), new CodeObject[0]),
                fwhileBlock);

            fblock.Statements.Add(new CodeExpressionStatement(f));
            fblock.Statements.Add(new CodeExpressionStatement(f1));
            fblock.Statements.Add(fwhile);

            CodeDomCompiler.Compile(fblock, machine);

            return(machine);
        }
    public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
    {
      var forStatement = (CodeForEachStatement)code;

      //foreach (i in c) statement ~
      //
      //f_ = c.GetEnumerator();
      //while(f_.Next()) {i = f_.Current; statement; }

      _sid++;
      string fName = "#ForEach_" + _sid;

      var fblock = new CodeBlockStatement();

      var f = new CodeAssignExpression(fName, forStatement.Container);
      var f1 = new CodeAssignExpression(fName, 
        new CodeObjectReference(fName, 
           new CodeObjectReference("GetEnumerator", null,
            new CodeObject[] { new CodeObjectFunctionCall(new CodeExpression[0]) }), new CodeObject[0]));

      var fwhileBlock = new CodeBlockStatement();

      var i = new CodeAssignExpression(forStatement.Id.Id,
        new CodeObjectReference(fName,
           new CodeObjectReference("get_Current", null,
            new CodeObject[] { new CodeObjectFunctionCall(new CodeExpression[0]) }), new CodeObject[0]));

      fwhileBlock.Statements.Add(new CodeExpressionStatement(i));
      fwhileBlock.Statements.Add(forStatement.Statement);

      var fwhile = new CodeWhileStatement(
        new CodeObjectReference(fName,
           new CodeObjectReference("MoveNext", null,
            new CodeObject[] { new CodeObjectFunctionCall(new CodeExpression[0]) }), new CodeObject[0]),
        fwhileBlock);

      fblock.Statements.Add(new CodeExpressionStatement(f));
      fblock.Statements.Add(new CodeExpressionStatement(f1));
      fblock.Statements.Add(fwhile);

      CodeDomCompiler.Compile(fblock, machine);

      return machine;
    }
    public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
    {
      var forStatement = (CodeForStatement)code;

      //for (init; cond; next) statement ~
      //
      //init;
      //while(cond) { statement; next;}

      CodeDomCompiler.Compile(forStatement.Init, machine);

      var body = new CodeBlockStatement();
      body.Statements.Add(forStatement.Statement);
      body.Statements.Add(new CodeExpressionStatement(forStatement.Next));
      var newWhile = new CodeWhileStatement(forStatement.Condition, body);

      CodeDomCompiler.Compile(newWhile, machine);
      return machine;
    }
        public ExecutableMachine Compile(CodeObject code, ExecutableMachine machine)
        {
            var forStatement = (CodeForStatement)code;

            //for (init; cond; next) statement ~
            //
            //init;
            //while(cond) { statement; next;}

            CodeDomCompiler.Compile(forStatement.Init, machine);

            var body = new CodeBlockStatement();

            body.Statements.Add(forStatement.Statement);
            body.Statements.Add(new CodeExpressionStatement(forStatement.Next));
            var newWhile = new CodeWhileStatement(forStatement.Condition, body);

            CodeDomCompiler.Compile(newWhile, machine);
            return(machine);
        }
示例#7
0
        private bool WriteWhileLoop(BasicBlock block, Loop loop, List<CodeStatement> stmts, Context context)
        {
            var loopContext = context.NewLoop(loop);

            CodeWhileStatement whileStmt;
            if (block.Statements.Count > 1) {
                // emit a while(true) { $bb.stmts; if($condition) { $then_stmts; break; } ... }
                whileStmt = new CodeWhileStatement {
                    TestExpression = new CodePrimitiveExpression(true)
                };

                var conditional = new Conditional(this.graph, block);
                WriteIf(block, conditional, whileStmt.Statements, loopContext);
            }
            else {
                var last = (CodeExpressionStatement)block.Statements.Last();
                var test = last.Expression;

                if (block.ElseEdge == loop.Follow) {
                    test = test.Invert();
                }

                // emit a pre-tested loop
                whileStmt = new CodeWhileStatement {
                    TestExpression = test
                };
            }

            AddStatement(stmts, whileStmt);

            if (!loop.Tails.Contains(block)) {
                WriteLoopInner(block, loop, whileStmt.Statements, loopContext);
            }

            if (loop.Follow != null) {
                return WriteCode(null, (BasicBlock)loop.Follow, stmts, context);
            }
            return false;
        }
示例#8
0
        private bool WriteEndlessLoop(BasicBlock block, Loop loop, List<CodeStatement> stmts, Context context)
        {
            var loopContext = context.NewLoop(loop);

            CodeWhileStatement whileStmt = new CodeWhileStatement {
                TestExpression = new CodePrimitiveExpression(true)
            };

            AddStatement(stmts, whileStmt);

            if (block.Successors.Count > 1) {
                var conditional = new Conditional(this.graph, block);
                WriteIf(block, conditional, whileStmt.Statements, loopContext);
            }
            else {
                WriteBasicBlock(block, whileStmt.Statements);
            }

            if (!loop.Tails.Contains(block)) {
                WriteLoopInner(block, loop, whileStmt.Statements, loopContext);
            }

            if (loop.Follow != null) {
                return WriteCode(null, (BasicBlock)loop.Follow, stmts, context);
            }
            return false;
        }