コード例 #1
0
        private IEnumerable <BaseAst> ConvertFor(ForAst node)
        {
            List <BaseAst> block = new List <BaseAst>();

            internalLabelIdx++;
            int idx = internalLabelIdx;

            block.Add(new BaseAst {
                Token = TokenTypes.Identifier, AstType = AstNodeTypes.Label, TokenText = string.Format("$ForBegin{0}", idx)
            });

            IEnumerable <BaseAst> st = ConvertStatement(node.Init);

            block.AddRange(st);
            node.ConvertInit = st.First();

            block.Add(new BaseAst {
                Token = TokenTypes.Identifier, AstType = AstNodeTypes.Label, TokenText = string.Format("$ForCondition{0}", idx)
            });

            ConditionAst cond = ConvertTo <ConditionAst>(node, AstNodeTypes.Condition);

            cond.Condition = NegateCondition(node.Condition);
            block.Add(cond);
            node.ConvertCondition = cond;

            GotoAst gt = new GotoAst {
                Token = TokenTypes.GotoRW, AstType = AstNodeTypes.Goto, TokenText = "goto", Label = string.Format("$ForEnd{0}", idx)
            };

            block.Add(gt);
            node.ConvertForEndBody = gt;

            block.Add(new BaseAst {
                Token = TokenTypes.Identifier, AstType = AstNodeTypes.Label, TokenText = string.Format("$ForTrue{0}", idx)
            });
            block.AddRange(ConvertStatement(node.ForBody));

            st = ConvertStatement(node.Close);
            block.AddRange(st);
            node.ConvertClose = st.First();
            block.Add(new GotoAst {
                Token = TokenTypes.GotoRW, AstType = AstNodeTypes.Goto, TokenText = "goto", Label = string.Format("$ForCondition{0}", idx)
            });

            block.Add(new BaseAst {
                Token = TokenTypes.Identifier, AstType = AstNodeTypes.Label, TokenText = string.Format("$ForEnd{0}", idx)
            });

            return(block);
        }
コード例 #2
0
        private BaseAst CheckFunctionCallsInForAST(ProgramAst program, ForAst cmd)
        {
            BaseAst err = CheckFunctionCallsInStatementAST(program, cmd.Init);

            if ((err != null) && (err.Token != TokenTypes.End) && (err.IsError))
            {
                return(err);
            }
            err = CheckFunctionCallsInStatementAST(program, cmd.Close);
            if ((err != null) && (err.Token != TokenTypes.End) && (err.IsError))
            {
                return(err);
            }
            return(CheckFunctionCallsInStatementAST(program, cmd.ForBody));
        }
コード例 #3
0
 private void WriteFor(ForAst ast, List<string> vars, string p, bool writeLE)
 {
     file.WriteLine("{0}for ({1}; {2}; {3})", p, GetExpr(ast.Init), GetExpr(ast.Condition), GetExpr(ast.Close));
     if (writeLE)
     {
         file.WriteLine("{0}// #1", p);
         WriteLinearEquations(ast.ConvertInit.Node, vars, p); // init
         file.WriteLine("{0}// #2", p);
         WriteLinearEquations(ast.ConvertCondition.Node, vars, p); // condition
         file.WriteLine("{0}// #3", p);
         WriteLinearEquations(ast.ConvertClose.Node, vars, p); // close
     }
     WriteBody(ast.ForBody, vars, p, writeLE);
     if (writeLE)
         WriteLinearEquations(ast.ConvertForEndBody.Node, vars, p);
 }
コード例 #4
0
        private BaseAst GetForAST(ForAst cmd)
        {
            if (cmd == null)
            {
                return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetForAST(ForAst cmd)', parametr 'cmd' je null"));
            }

            // '('
            ReadNextAst();
            if (actualNode.Token != TokenTypes.ParenthesisLeft)
            {
                return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan '(', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)));
            }

            // init command
            if (nextNode.Token != TokenTypes.Semicolon)
            {
                BaseAst init = AssignmentOrUnaryOrFnc();
                if (init.IsError)
                {
                    return(init);
                }
                cmd.Init = init;
            }

            // ';'
            ReadNextAst();
            if (actualNode.Token != TokenTypes.Semicolon)
            {
                return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan ';', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)));
            }

            // condition
            BaseAst cond;
            BaseAst tmp = GetCondAST(out cond);

            if (tmp.IsError)
            {
                return(tmp);
            }
            cmd.Condition = cond;

            // ';'
            ReadNextAst();
            if (actualNode.Token != TokenTypes.Semicolon)
            {
                return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan ';', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)));
            }

            // close command
            if (nextNode.Token != TokenTypes.ParenthesisRight)
            {
                BaseAst close = AssignmentOrUnaryOrFnc();
                if (close.IsError)
                {
                    return(close);
                }
                cmd.Close = close;
            }

            // ')'
            ReadNextAst();
            if (actualNode.Token != TokenTypes.ParenthesisRight)
            {
                return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan ')', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)));
            }

            // body
            BaseAst st = StatementOrBlock();

            if (st.IsError)
            {
                return(st);
            }
            cmd.ForBody = st;

            return(cmd);
        }