private BaseAst GetAssignmentAST(BaseAst var) { if ((var == null) || (var.AstType != AstNodeTypes.Variable)) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetAssignmentAST(BaseAst var)', parametr 'var' je null")); } if (!program.VarsDecl.Keys.Contains(var.TokenText)) { return(BaseAst.GetErrorAstNode(string.Format("Promenna '{0}' doposud nebyla deklarovana, radek {1}, sloupec {2}", var.TokenText, var.TokenStartLine, var.TokenStartColumn))); } ReadNextAst(); OperatorAst cmd = actualNode as OperatorAst; if ((cmd == null) || (cmd.Token != TokenTypes.Equals)) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan operator '=', radek {0}, sloupec {1}", cmd.TokenStartLine, cmd.TokenStartColumn))); } cmd.Left = var; BaseAst expr; BaseAst tmp = GetExprAST(out expr); if (tmp.IsError) { return(tmp); } cmd.Right = expr; return(cmd); }
private BaseAst GetWhileAST(WhileAst cmd) { if (cmd == null) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetWhileAST(WhileAst cmd)', parametr 'cmd' je null")); } BaseAst cond; BaseAst tmp = GetCondAST(out cond); if (tmp.IsError) { return(tmp); } cmd.Condition = cond; BaseAst st = StatementOrBlock(); if (st.IsError) { return(st); } cmd.WhileBody = st; return(cmd); }
private bool GetExprBinaryOperationNode(out BaseAst node, bool isCond) { ReadNextAst(); node = actualNode; switch (node.Token) { case TokenTypes.End: node = BaseAst.GetErrorAstNode(string.Format("Konec programu, vyraz neni korektne ukoncen, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)); return(false); case TokenTypes.Plus: case TokenTypes.Minus: case TokenTypes.Multi: return(true); case TokenTypes.EqualsEquals: case TokenTypes.Less: case TokenTypes.More: case TokenTypes.LessOrEquals: case TokenTypes.MoreOrEquals: case TokenTypes.NotEquals: case TokenTypes.Or: case TokenTypes.And: return(isCond); default: return(false); } }
private BaseAst GetReturnAST(BaseAst cmd) { if ((cmd == null) || (cmd.AstType != AstNodeTypes.Return)) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetReturnAST(BaseAst cmd)', parametr 'cmd' je null")); } cmd.AstType = AstNodeTypes.Return; return(cmd); }
private BaseAst GetVariables() { ReadNextAst(); while ((actualNode.Token != TokenTypes.Semicolon) && !(actualNode.IsError)) { if (actualNode.Token != TokenTypes.Identifier) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan identifikator promenne, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } if (program.VarsDecl.Keys.Contains(actualNode.TokenText)) { return(BaseAst.GetErrorAstNode(string.Format("Promenna '{0}' j*z byla deklarovana, radek {1}, sloupec {2}", actualNode.TokenText, actualNode.TokenStartLine, actualNode.TokenStartColumn))); } BaseAst var = actualNode; BaseAst expr = null; if (nextNode.Token == TokenTypes.Equals) { ReadNextAst(); OperatorAst op = actualNode as OperatorAst; BaseAst node = GetExprAST(out expr); if (node.IsError) { return(node); } op.Left = var; op.Right = expr; expr = op; } program.Vars.Add(var.TokenText); program.VarsDecl.Add(var.TokenText, expr); ReadNextAst(); switch (actualNode.Token) { case TokenTypes.Comma: ReadNextAst(); break; case TokenTypes.Semicolon: break; default: return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan znak oddeleni ',' nebo ';' nebo znak prirazeni '=', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } } return(actualNode); }
private BaseAst GetFunctionAST(FunctionAst fnc) { if (fnc == null) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetFunctionNode(FunctionAst fnc)', parametr 'fnc' je null")); } ReadNextAst(); if (actualNode.Token != TokenTypes.Identifier) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan identifikator funkce, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } if (program.OrigFncs.Keys.Contains(actualNode.TokenText)) { return(BaseAst.GetErrorAstNode(string.Format("Funkce '{0}' j*z byla deklarovana, radek {1}, sloupec {2}", actualNode.TokenText, actualNode.TokenStartLine, actualNode.TokenStartColumn))); } program.OrigFncs.Add(actualNode.TokenText, fnc); ReadNextAst(); if (actualNode.Token != TokenTypes.ParenthesisLeft) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavana leva zavorka '(', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } ReadNextAst(); if (actualNode.Token != TokenTypes.ParenthesisRight) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavana prava zavorka ')', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } ReadNextAst(); if ((actualNode.Token != TokenTypes.BraceLeft) && !(actualNode is BlockAst)) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavana leva slozena zavorka '{{', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } BaseAst node = GetFncBodyAST(actualNode as BlockAst); if (node.IsError) { return(node); } fnc.Body = node as BlockAst; return(fnc); }
private BaseAst GetUnaryOpAST(OperatorAst cmd) { if (cmd == null) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetUnaryOpAST(OperatorAst cmd)', parametr 'cmd' je null")); } ReadNextAst(); if (actualNode.Token != TokenTypes.Identifier) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavano navesti, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } cmd.Right = actualNode; return(cmd); }
private BaseAst GetLabelAST(BaseAst label) { if ((label == null) || (label.AstType != AstNodeTypes.Variable)) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetLabelAST(BaseAst label)', parametr 'label' je null")); } label.AstType = AstNodeTypes.Label; ReadNextAst(); if (actualNode.Token != TokenTypes.Colon) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavana ':', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } return(label); }
private BaseAst AssignmentOrUnaryOrFnc() { ReadNextAst(); BaseAst node = actualNode; switch (actualNode.Token) { case TokenTypes.End: return(BaseAst.GetErrorAstNode(string.Format("Konec programu, blok neni korektne ukoncen, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); case TokenTypes.Identifier: switch (nextNode.Token) { case TokenTypes.ParenthesisLeft: node = GetFunctionCallAST(node); break; case TokenTypes.Equals: node = GetAssignmentAST(node); break; case TokenTypes.PlusPlus: case TokenTypes.MinusMinus: node = GetUnaryOpAST(node); break; default: return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan znak prirazeni '=', radek {0}, sloupec {1}", nextNode.TokenStartLine, nextNode.TokenStartColumn))); } break; case TokenTypes.PlusPlus: case TokenTypes.MinusMinus: node = GetUnaryOpAST(node as OperatorAst); break; default: return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan prikaz, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } return(node); }
private BaseAst GetUnaryOpAST(BaseAst var) { if ((var == null) || (var.AstType != AstNodeTypes.Variable)) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetUnaryOpAST(BaseAst var)', parametr 'var' je null")); } ReadNextAst(); OperatorAst cmd = actualNode as OperatorAst; if ((cmd == null) || ((cmd.Token != TokenTypes.PlusPlus) && (cmd.Token != TokenTypes.MinusMinus))) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan operator '++' nebo '--', radek {0}, sloupec {1}", cmd.TokenStartLine, cmd.TokenStartColumn))); } cmd.Left = var; return(cmd); }
public bool GetAST(out ProgramAst prg) { program = new ProgramAst(); prg = program; BaseAst node = BaseAst.GetInitLoopAstNode(); while ((node.Token != TokenTypes.End) && (!node.IsError)) { ReadNextAst(); node = actualNode; switch (actualNode.Token) { case TokenTypes.VarRW: // deklarace globalni promenne node = GetVariables(); break; case TokenTypes.FunctionRW: // deklarace funkce node = GetFunctionAST(node as FunctionAst); break; case TokenTypes.End: // konec programu break; default: node = BaseAst.GetErrorAstNode(string.Format("Je ocekavano klicove slovo 'var' nebo 'function', radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn)); break; } } if (node.IsError) { Console.WriteLine("Error: '{0}'", node.ErrorMessage); return(false); } return(true); }
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); }
private BaseAst GetFunctionCallAST(BaseAst cmd) { if ((cmd == null) || (cmd.AstType != AstNodeTypes.Variable)) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetFunctionCallAST(BaseAst cmd)', parametr 'cmd' je null")); } cmd.AstType = AstNodeTypes.FunctionCall; ReadNextAst(); if (actualNode.Token != TokenTypes.ParenthesisLeft) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan '(', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } ReadNextAst(); if (actualNode.Token != TokenTypes.ParenthesisRight) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan ')', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } return(cmd); }
private BaseAst GetIfAST(IfAst cmd) { if (cmd == null) { return(BaseAst.GetErrorAstNode("Chybne volana funkce 'GetIfAST(IfAst cmd)', parametr 'cmd' je null")); } BaseAst cond; BaseAst tmp = GetCondAST(out cond); if (tmp.IsError) { return(tmp); } cmd.Condition = cond; BaseAst block = StatementOrBlock(); if (block.IsError) { return(block); } cmd.IfBody = block; if (nextNode.Token == TokenTypes.ElseRW) { ReadNextAst(); block = StatementOrBlock(); if (block.IsError) { return(block); } cmd.ElseBody = block; } return(cmd); }
private BaseAst CheckFunctionCallsInStatementAST(ProgramAst program, BaseAst st) { if ((st != null) && (st.AstType == AstNodeTypes.FunctionCall)) { if (!program.OrigFncs.Keys.Contains(st.TokenText)) { return(BaseAst.GetErrorAstNode(string.Format("Funkce '{0}' doposud nebyla deklarovana, radek {1}, sloupec {2}", st.TokenText, st.TokenStartLine, st.TokenStartColumn))); } } BaseAst inner = null; if (st is BlockAst) { inner = CheckFunctionCallsInBlockAST(program, st as BlockAst); } if (st is IfAst) { inner = CheckFunctionCallsInIfAST(program, st as IfAst); } if (st is WhileAst) { inner = CheckFunctionCallsInWhileAST(program, st as WhileAst); } if (st is ForAst) { inner = CheckFunctionCallsInForAST(program, st as ForAst); } if ((inner != null) && (inner.Token != TokenTypes.End) && (inner.IsError)) { return(inner); } return(BaseAst.GetEndAstNode()); }
private BaseAst GetSubExprAST(out BaseAst expr, int level, bool isCond) { expr = null; BaseAst node = null; List <BaseAst> nodes = new List <BaseAst>(); // cislo, identifikator nebo leva zavorka if (!GetOperandNode(out node)) { switch (node.Token) { case TokenTypes.Neg: if (isCond) { OperatorAst nodeN = (OperatorAst)node; GetOperandNode(out node); if (node.Token != TokenTypes.ParenthesisLeft) { return(BaseAst.GetErrorAstNode(string.Format("Po operaci negace je ocekavana leva zavorka, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } BaseAst nodePRn = GetSubExprAST(out node, level + 1, isCond); if (nodePRn.IsError) { return(nodePRn); } if (nodePRn.Token != TokenTypes.ParenthesisRight) { return(BaseAst.GetErrorAstNode(string.Format("Vyraz neni korektne ukoncen pravou zavorkou, radek {0}, sloupec {1}", nodePRn.TokenStartLine, nodePRn.TokenStartColumn))); } nodeN.Right = node; node = nodeN; } else { return(BaseAst.GetErrorAstNode(string.Format("Chybna operace negace, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } break; case TokenTypes.ParenthesisLeft: BaseAst nodePR = GetSubExprAST(out node, level + 1, isCond); if (nodePR.IsError) { return(nodePR); } if (nodePR.Token != TokenTypes.ParenthesisRight) { return(BaseAst.GetErrorAstNode(string.Format("Vyraz neni korektne ukoncen pravou zavorkou, radek {0}, sloupec {1}", nodePR.TokenStartLine, nodePR.TokenStartColumn))); } break; case TokenTypes.ParenthesisRight: return(BaseAst.GetErrorAstNode(string.Format("Chybna prava zavorka, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); case TokenTypes.Error: return(node); default: return(BaseAst.GetErrorAstNode(string.Format("Prazdny vyraz, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } } nodes.Add(node); while (IsWantedToken(nextNode.Token, isCond)) { if (!GetExprBinaryOperationNode(out node, isCond)) { switch (node.Token) { case TokenTypes.Identifier: case TokenTypes.Number: case TokenTypes.ParenthesisLeft: return(BaseAst.GetErrorAstNode(string.Format("Nespravne formatovany vyraz, je ocekavan operator, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } if (node.Token == TokenTypes.ParenthesisRight) { if (level == 0) { return(BaseAst.GetErrorAstNode(string.Format("Chybna prava zavorka, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } break; } continue; } nodes.Add(node); if (!GetOperandNode(out node)) { switch (node.Token) { case TokenTypes.Neg: if (isCond) { OperatorAst nodeN = (OperatorAst)node; GetOperandNode(out node); if (node.Token != TokenTypes.ParenthesisLeft) { return(BaseAst.GetErrorAstNode(string.Format("Po operaci negace je ocekavana leva zavorka, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } BaseAst nodePRn = GetSubExprAST(out node, level + 1, isCond); if (nodePRn.IsError) { return(nodePRn); } if (nodePRn.Token != TokenTypes.ParenthesisRight) { return(BaseAst.GetErrorAstNode(string.Format("Vyraz neni korektne ukoncen pravou zavorkou, radek {0}, sloupec {1}", nodePRn.TokenStartLine, nodePRn.TokenStartColumn))); } nodeN.Right = node; node = nodeN; } else { return(BaseAst.GetErrorAstNode(string.Format("Chybna operace negace, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } break; case TokenTypes.ParenthesisLeft: BaseAst nodePR = GetSubExprAST(out node, level + 1, isCond); if (nodePR.IsError) { return(nodePR); } if (nodePR.Token != TokenTypes.ParenthesisRight) { return(BaseAst.GetErrorAstNode(string.Format("Vyraz neni korektne ukoncen pravou zavorkou, radek {0}, sloupec {1}", nodePR.TokenStartLine, nodePR.TokenStartColumn))); } break; case TokenTypes.Error: return(node); default: return(BaseAst.GetErrorAstNode(string.Format("Nespravne formatovany vyraz, je ocekavan cislo, promenna nebo leva zavorka, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } } nodes.Add(node); } if (nodes.Count == 0) { return(BaseAst.GetErrorAstNode(string.Format("Nespravne formatovany vyraz, je ocekavan cislo, promenna nebo leva zavorka, radek {0}, sloupec {1}", node.TokenStartLine, node.TokenStartColumn))); } int op = 10; while ((op < opMax) && (nodes.Count > 1)) { int i = 1; while (i < nodes.Count) { if (i >= (nodes.Count - 1)) { return(BaseAst.GetErrorAstNode("Nespravne formatovany vyraz... chybny pocet operandu")); } OperatorAst oper = nodes[i] as OperatorAst; if (oper == null) { return(BaseAst.GetErrorAstNode("Nespravne formatovany vyraz... uzel neni operace")); } if (oper.Priority == op) { oper.Left = nodes[i - 1]; oper.Right = nodes[i + 1]; nodes.RemoveAt(i + 1); nodes.RemoveAt(i - 1); } else { i += 2; } } op += 10; } if (nodes.Count != 1) { return(BaseAst.GetErrorAstNode("Nespravne formatovany vyraz... nedobre utvoreny AST")); } expr = nodes[0]; return(node); }
private BaseAst GetAstNode(TokenModel token) { switch (token.Token) { case TokenTypes.FunctionRW: return(ConvertTo <FunctionAst>(token, AstNodeTypes.Function)); case TokenTypes.IfRW: return(ConvertTo <IfAst>(token, AstNodeTypes.If)); case TokenTypes.ForRW: return(ConvertTo <ForAst>(token, AstNodeTypes.For)); case TokenTypes.WhileRW: return(ConvertTo <WhileAst>(token, AstNodeTypes.While)); case TokenTypes.GotoRW: return(ConvertTo <GotoAst>(token, AstNodeTypes.Goto)); case TokenTypes.ReturnRW: return(ConvertTo <BaseAst>(token, AstNodeTypes.Return)); case TokenTypes.Number: NumberAst number = ConvertTo <NumberAst>(token, AstNodeTypes.Number); int num; if (!TryParseNumber(number.TokenText, out num)) { return(BaseAst.GetErrorAstNode(string.Format("Nespravny format cisla, radek {0}, sloupec {1}", number.TokenStartLine, number.TokenStartColumn))); } number.Number = num; return(number); case TokenTypes.BraceLeft: return(ConvertTo <BlockAst>(token, AstNodeTypes.Block)); case TokenTypes.Equals: case TokenTypes.Plus: case TokenTypes.Minus: case TokenTypes.Multi: case TokenTypes.PlusPlus: case TokenTypes.MinusMinus: case TokenTypes.EqualsEquals: case TokenTypes.Less: case TokenTypes.More: case TokenTypes.LessOrEquals: case TokenTypes.MoreOrEquals: case TokenTypes.NotEquals: case TokenTypes.Or: case TokenTypes.And: case TokenTypes.Neg: OperatorAst op = ConvertTo <OperatorAst>(token, AstNodeTypes.Operator); SetOperatorPriority(op); return(op); case TokenTypes.Error: return(ConvertTo <BaseAst>(token, AstNodeTypes.None)); default: return(ConvertTo <BaseAst>(token, AstNodeTypes.Variable)); } }
private bool GetOperandNode(out BaseAst node) { OperatorAst nodeO; ReadNextAst(); switch (actualNode.Token) { case TokenTypes.End: node = BaseAst.GetErrorAstNode(string.Format("Konec programu, vyraz neni korektne ukoncen, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)); return(false); case TokenTypes.Identifier: if (!program.VarsDecl.Keys.Contains(actualNode.TokenText)) { node = BaseAst.GetErrorAstNode(string.Format("Promenna '{0}' doposud nebyla deklarovana, radek {1}, sloupec {2}", actualNode.TokenText, actualNode.TokenStartLine, actualNode.TokenStartColumn)); return(false); } node = actualNode; if ((nextNode.Token == TokenTypes.PlusPlus) || (nextNode.Token == TokenTypes.MinusMinus)) { ReadNextAst(); nodeO = actualNode as OperatorAst; if (nodeO == null) { node = BaseAst.GetErrorAstNode(string.Format("Nespravny AST datovy typ operatoru, radek {0}, sloupec {1}", nodeO.TokenStartLine, nodeO.TokenStartColumn)); return(false); } nodeO.Left = node; node = nodeO; } return(true); case TokenTypes.Number: node = actualNode; return(true); case TokenTypes.Plus: case TokenTypes.Minus: BaseAst sgn = actualNode; int sign = 1; if (sgn.Token == TokenTypes.Minus) { sign = -1; } ReadNextAst(); switch (actualNode.Token) { case TokenTypes.VarRW: node = BaseAst.GetErrorAstNode("Momentalne nepodporujeme '- variable'"); return(false); case TokenTypes.Number: node = ConvertTo <NumberAst>(sgn, AstNodeTypes.Number); node.TokenText = sgn.TokenText + actualNode.TokenText; ((NumberAst)node).Number = sign * ((NumberAst)actualNode).Number; return(true); default: node = BaseAst.GetErrorAstNode(string.Format("Je ocekavan identifikator promenne, radek {0}, sloupec {1}'", actualNode.TokenStartLine, actualNode.TokenStartColumn)); return(false); } case TokenTypes.PlusPlus: case TokenTypes.MinusMinus: nodeO = (OperatorAst)actualNode; if (nodeO == null) { node = BaseAst.GetErrorAstNode(string.Format("Nespravny AST datovy typ operatoru, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)); return(false); } ReadNextAst(); if (actualNode.Token != TokenTypes.Identifier) { node = BaseAst.GetErrorAstNode(string.Format("Je ocekavan identifikator promenne, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn)); return(false); } if (!program.VarsDecl.Keys.Contains(actualNode.TokenText)) { node = BaseAst.GetErrorAstNode(string.Format("Promenna '{0}' doposud nebyla deklarovana, radek {1}, sloupec {2}", actualNode.TokenText, actualNode.TokenStartLine, actualNode.TokenStartColumn)); return(false); } nodeO.Right = actualNode; node = nodeO; return(true); default: node = actualNode; return(false); } }
private BaseAst GetStatementAST() { bool semicolon = false; ReadNextAst(); BaseAst node = null; switch (actualNode.Token) { case TokenTypes.End: return(BaseAst.GetErrorAstNode(string.Format("Konec programu, blok neni korektne ukoncen, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); case TokenTypes.IfRW: node = GetIfAST(actualNode as IfAst); break; case TokenTypes.ForRW: node = GetForAST(actualNode as ForAst); break; case TokenTypes.WhileRW: node = GetWhileAST(actualNode as WhileAst); break; case TokenTypes.GotoRW: node = GetGotoAST(actualNode as GotoAst); semicolon = true; break; case TokenTypes.ReturnRW: node = GetReturnAST(actualNode); semicolon = true; break; case TokenTypes.BraceLeft: case TokenTypes.BraceRight: node = actualNode; break; case TokenTypes.Identifier: switch (nextNode.Token) { case TokenTypes.ParenthesisLeft: node = GetFunctionCallAST(actualNode); semicolon = true; break; case TokenTypes.Equals: node = GetAssignmentAST(actualNode); semicolon = true; break; case TokenTypes.PlusPlus: case TokenTypes.MinusMinus: node = GetUnaryOpAST(actualNode); semicolon = true; break; case TokenTypes.Colon: node = GetLabelAST(actualNode); break; default: return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan znak prirazeni '=', radek {0}, sloupec {1}", nextNode.TokenStartLine, nextNode.TokenStartColumn))); } break; case TokenTypes.PlusPlus: case TokenTypes.MinusMinus: node = GetUnaryOpAST(actualNode as OperatorAst); semicolon = true; break; case TokenTypes.VarRW: return(BaseAst.GetErrorAstNode(string.Format("Lokalni promenne nejsou povoleny, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); case TokenTypes.FunctionRW: return(BaseAst.GetErrorAstNode(string.Format("Vnorene funkce nejsou povoleny, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); default: return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan prikaz, radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } if (node == null) { return(BaseAst.GetErrorAstNode("Vnitrni chyba funkce 'GetStatementAST'")); } if (node.IsError) { return(node); } if (semicolon) { ReadNextAst(); if (actualNode.Token != TokenTypes.Semicolon) { return(BaseAst.GetErrorAstNode(string.Format("Je ocekavan ';', radek {0}, sloupec {1}", actualNode.TokenStartLine, actualNode.TokenStartColumn))); } } return(node); }
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); }