private void WriteBlock(BlockAst block, List<string> vars, string prefix, bool writeLE)
 {
     foreach (BaseAst ast in block.Statements)
     {
         WriteStatement(ast, vars, prefix, writeLE);
     }
 }
        private BlockAst ConvertFncBodyAST(BlockAst body)
        {
            BlockAst cb = ConvertTo <BlockAst>(body, AstNodeTypes.Block);

            foreach (BaseAst st in body.Statements)
            {
                cb.Statements.AddRange(ConvertStatement(st));
            }

            return(cb);
        }
 private BaseAst CheckFunctionCallsInBlockAST(ProgramAst program, BlockAst block)
 {
     foreach (BaseAst node in block.Statements)
     {
         BaseAst err = CheckFunctionCallsInStatementAST(program, node);
         if ((err != null) && (err.Token != TokenTypes.End) && (err.IsError))
         {
             return(err);
         }
     }
     return(BaseAst.GetEndAstNode());
 }
        private void PrintSAFncDecl(string fncName, BlockAst body)
        {
            if (body != null)
            {
                Console.WriteLine();
                Console.WriteLine("function {0}()", fncName);
                Console.WriteLine("{");

                foreach (BaseAst st in body.Statements)
                {
                    if (st is OperatorAst)
                    {
                        PrintSAOper(st as OperatorAst);
                    }
                    else if (st is ConditionAst)
                    {
                        PrintSACond(st as ConditionAst);
                    }
                    else if ((st is BaseAst) && (st.AstType == AstNodeTypes.Label))
                    {
                        PrintSALabel(st as BaseAst);
                    }
                    else if (st is GotoAst)
                    {
                        PrintSAGoto(st as GotoAst);
                    }
                    else if ((st is BaseAst) && (st.AstType == AstNodeTypes.FunctionCall))
                    {
                        PrintSAFncCall(st as BaseAst);
                    }
                    else if ((st is BaseAst) && (st.AstType == AstNodeTypes.Return))
                    {
                        PrintSAReturn(st as BaseAst);
                    }
                    else
                    {
                        Console.WriteLine("Neco neni v poradku :-)...");
                        break;
                    }
                }

                Console.WriteLine("}");
            }
        }
        private BaseAst GetBlockAST(BlockAst block)
        {
            if (block == null)
            {
                return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetBlockAST(BlockAst block)', parametr 'block' je null"));
            }

            BaseAst node = BaseAst.GetInitLoopAstNode();

            while ((node.Token != TokenTypes.BraceRight) && !(node.IsError))
            {
                node = GetStatementAST();

                switch (node.Token)
                {
                case TokenTypes.End:
                    return(BaseAst.GetErrorAstNode(string.Format("Konec programu, blok neni korektne ukoncen, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn)));

                case TokenTypes.BraceLeft:
                    node = GetBlockAST(node as BlockAst);
                    break;
                }

                if (node.IsError)
                {
                    return(node);
                }

                if (node.Token == TokenTypes.BraceRight)
                {
                    break;
                }

                block.Statements.Add(node);
            }

            return(block);
        }