private BodyNode(ImmutableArray <IAstNode> elements, ExpressionNode returnExpressionNode, IDictionary <string, IEntityType> scopeTypeTable, IScopedTable <IEntityType, string> parentTypeTable) { Elements = elements; ReturnExpressionNode = returnExpressionNode; ScopeTypeTable = scopeTypeTable; ParentTypeTable = parentTypeTable; }
private ExpressionNode(RelationNode relation1, List <RelationNode> relations, List <IToken> tokens, IScopedTable <IEntityType, string> parentTypeTable) { Relation1 = relation1; Relations = relations; Tokens = tokens; ParentTypeTable = parentTypeTable; }
private SimpleNode(FactorNode factor, List <IToken> tokens, List <FactorNode> factors, IScopedTable <IEntityType, string> parentTypeTable) { Factor = factor; Tokens = tokens; Factors = factors; ParentTypeTable = parentTypeTable; }
private FactorNode(SummandNode summand, List <IToken> tokens, List <SummandNode> summands, IScopedTable <IEntityType, string> parentTypeTable) { Summand = summand; Tokens = tokens; Summands = summands; ParentTypeTable = parentTypeTable; }
private RelationNode(SimpleNode simple1, IToken token, SimpleNode simple2, IScopedTable <IEntityType, string> parentTypeTable) { Simple1 = simple1; Token = token; Simple2 = simple2; ParentTypeTable = parentTypeTable; }
private ModifiablePrimaryNode(IdentifierToken identifier, List <IdentifierToken> identifiers, List <ExpressionNode> expressions, IScopedTable <IEntityType, string> parentTypeTable) { Identifier = identifier; Identifiers = identifiers; Expressions = expressions; ParentTypeTable = parentTypeTable; }
private VariableDeclarationNode(IdentifierToken identifier, Option <TypeNode> type, Option <ExpressionNode> expression, IScopedTable <IEntityType, string> parentTypeTable) { Identifier = identifier; Type = type; Expression = expression; ParentTypeTable = parentTypeTable; }
private ForLoopNode(IdentifierToken identifier, RangeNode range, BodyNode body, SymT symT, IDictionary <string, IEntityType> scopeTypeTable, IScopedTable <IEntityType, string> parentTypeTable) { Identifier = identifier; Range = range; Body = body; SymbolTable = symT; ScopeTypeTable = scopeTypeTable; ParentTypeTable = parentTypeTable; }
private RoutineDeclarationNode(IdentifierToken identifier, IEnumerable <ParameterNode> parameters, Option <TypeNode> returnType, BodyNode body, SymT symT, IDictionary <string, IEntityType> scopeTypeTable, IScopedTable <IEntityType, string> parentTypeTable) { Identifier = identifier; Parameters = parameters.ToImmutableArray(); ReturnType = returnType; Body = body; ScopeTypeTable = scopeTypeTable; ParentTypeTable = parentTypeTable; SymbolTable = symT; }
private StatementNode(AssignmentNode assignment, IScopedTable <IEntityType, string> parentTypeTable) { Assignment = assignment; ParentTypeTable = parentTypeTable; }
public static Either <ParseException, Pair <List <IToken>, TypeDeclarationNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("TypeDeclarationNode"); if (tokens.Count < 3) { return(NotATypeDeclarationException); } if (!(tokens[0] is TypeKeywordToken) || !(tokens[1] is IdentifierToken) || !(tokens[2] is IsKeywordToken)) { return(NotATypeDeclarationException); } IdentifierToken identifier = (IdentifierToken)tokens[1]; tokens = tokens.Skip(3).ToList(); var maybeType = TypeNode.Parse(tokens, symT, parentTypeTable); if (maybeType.IsLeft) { return(maybeType.LeftToList()[0]); } tokens = maybeType.RightToList()[0].First; while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } if (symT.Contain(identifier)) { // TODO: return an exception instead Console.WriteLine("Repeating identifier in the same scope"); } else { symT.Add(identifier); } return(new Pair <List <IToken>, TypeDeclarationNode>(tokens, new TypeDeclarationNode( identifier, maybeType.RightToList()[0].Second, parentTypeTable))); }
private TypeDeclarationNode(IdentifierToken identifier, TypeNode type, IScopedTable <IEntityType, string> parentTypeTable) { Identifier = identifier; Type = type; ParentTypeTable = parentTypeTable; }
public static Either <ParseException, Pair <List <IToken>, AssignmentNode> > Parse(List <IToken> tokens, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("AssignmentNode"); var maybeModifiablePrimary = ModifiablePrimaryNode.Parse(tokens, parentTypeTable); if (maybeModifiablePrimary.IsLeft) { return(maybeModifiablePrimary.LeftToList()[0]); } tokens = maybeModifiablePrimary.RightToList()[0].First; if (tokens.Count < 1) { return(NotAnAssignmentNodeException); } if (!(tokens[0] is AssignmentOperatorToken)) { return(NotAnAssignmentNodeException); } tokens = tokens.Skip(1).ToList(); var maybeExpression = ExpressionNode.Parse(tokens, parentTypeTable); if (maybeExpression.IsLeft) { return(maybeExpression.LeftToList()[0]); } tokens = maybeExpression.RightToList()[0].First; while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } return(new Pair <List <IToken>, AssignmentNode>(tokens, new AssignmentNode( maybeModifiablePrimary.RightToList()[0].Second, maybeExpression.RightToList()[0].Second))); }
public static Either <ParseException, Pair <List <IToken>, RoutineDeclarationNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { var NewSymT = new SymT(symT); Console.WriteLine("RoutineDeclarationNode"); if (tokens.Count <= 3) { return(NotARoutineException); } var maybeRoutine = tokens[0]; var maybeIdentifier = tokens[1]; var maybeLp = tokens[2]; if ( !(maybeRoutine is RoutineKeywordToken) || !(maybeIdentifier is IdentifierToken) || !(maybeLp is LeftParenthSymbolToken) ) { return(NotARoutineException); } IdentifierToken identifier = (IdentifierToken)maybeIdentifier; tokens = tokens.Skip(3).ToList(); var parameters = new List <ParameterNode>(); var typeTable = new Dictionary <string, IEntityType>(); while (true) { var maybeParameter = ParameterNode.Parse(tokens, NewSymT, parentTypeTable); if (maybeParameter.IsLeft) { break; } var parameter = maybeParameter.RightToList()[0].Second; parameters.Add(parameter); typeTable.TryAdd(parameter.Name.Lexeme, new VariableType(parameter.Type.ToTypeRepresentation())); tokens = maybeParameter.RightToList()[0].First; if (tokens.Count < 1) { return(NotARoutineException); } if (tokens[0] is ComaSymbolToken) { tokens = tokens.Skip(1).ToList(); continue; } break; } if (tokens[0] is RightParenthSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { return(NotARoutineException); } if (tokens.Count < 2) { return(NotARoutineException); } Either <ParseException, Pair <List <IToken>, TypeNode> > maybeType = new ParseException("Dummy"); if (tokens[0] is ColonSymbolToken) { tokens = tokens.Skip(1).ToList(); maybeType = TypeNode.Parse(tokens, symT, parentTypeTable); if (maybeType.IsLeft) { return(NotARoutineException); } tokens = maybeType.RightToList()[0].First; } if (tokens.Count < 1) { return(NotARoutineException); } if (!(tokens[0] is IsKeywordToken)) { return(NotARoutineException); } tokens = tokens.Skip(1).ToList(); var result = new RoutineDeclarationNode( identifier, parameters, maybeType.Map <TypeNode>(pr => pr.Second).ToOption(), null, NewSymT, typeTable, parentTypeTable ); var maybeBody = BodyNode.Parse(tokens, NewSymT, result); if (maybeBody.IsLeft) { return(maybeBody.LeftToList()[0]); } tokens = maybeBody.RightToList()[0].First; if (tokens.Count < 1) { return(NotARoutineException); } if (!(tokens[0] is EndKeywordToken)) { return(NotARoutineException); } tokens = tokens.Skip(1).ToList(); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } result.Body = maybeBody.RightToList()[0].Second; return(new Pair <List <IToken>, RoutineDeclarationNode>(tokens, result)); }
public static Either <ParseException, Pair <List <IToken>, StatementNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("StatementNode"); var maybeAssignment = AssignmentNode.Parse(tokens, parentTypeTable); if (maybeAssignment.IsRight) { tokens = maybeAssignment.RightToList()[0].First; return(new Pair <List <IToken>, StatementNode>(tokens, new StatementNode( maybeAssignment.RightToList()[0].Second, parentTypeTable))); } var maybeRoutineCall = RoutineCallNode.Parse(tokens, symT, parentTypeTable); if (maybeRoutineCall.IsRight) { tokens = maybeRoutineCall.RightToList()[0].First; return(new Pair <List <IToken>, StatementNode>(tokens, new StatementNode( maybeRoutineCall.RightToList()[0].Second, parentTypeTable))); } var maybeWhileLoop = WhileLoopNode.Parse(tokens, symT, parentTypeTable); if (maybeWhileLoop.IsRight) { tokens = maybeWhileLoop.RightToList()[0].First; return(new Pair <List <IToken>, StatementNode>(tokens, new StatementNode( maybeWhileLoop.RightToList()[0].Second, parentTypeTable))); } var maybeForLoop = ForLoopNode.Parse(tokens, symT, parentTypeTable); if (maybeForLoop.IsRight) { tokens = maybeForLoop.RightToList()[0].First; return(new Pair <List <IToken>, StatementNode>(tokens, new StatementNode( maybeForLoop.RightToList()[0].Second, parentTypeTable))); } var maybeIfStatement = IfStatementNode.Parse(tokens, symT, parentTypeTable); if (maybeIfStatement.IsRight) { tokens = maybeIfStatement.RightToList()[0].First; return(new Pair <List <IToken>, StatementNode>(tokens, new StatementNode( maybeIfStatement.RightToList()[0].Second, parentTypeTable))); } return(NotAStatementException); }
private StatementNode(ForLoopNode forLoop, IScopedTable <IEntityType, string> parentTypeTable) { ForLoop = forLoop; ParentTypeTable = parentTypeTable; }
public static Either <ParseException, Pair <List <IToken>, ForLoopNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("ForLoopNode"); SymT NewSymT = new SymT(symT); if (tokens.Count < 1) { return(NotAForLoopException); } if (!(tokens[0] is ForKeywordToken)) { return(NotAForLoopException); } tokens = tokens.Skip(1).ToList(); if (tokens.Count < 1) { return(NotAForLoopException); } if (!(tokens[0] is IdentifierToken)) { return(NotAForLoopException); } IdentifierToken identifier = (IdentifierToken)tokens[0]; var typeTable = new Dictionary <string, IEntityType>(); typeTable.TryAdd( identifier.Lexeme, new VariableType(new PrimitiveTypeRepresentation(new IntegerTypeNode())) ); tokens = tokens.Skip(1).ToList(); var result = new ForLoopNode( identifier, null, null, NewSymT, typeTable, parentTypeTable); var maybeRange = RangeNode.Parse(tokens, result); if (NewSymT.Contain(identifier)) { // TODO: return an exception instead Console.WriteLine("Repeating identifier in the same scope"); } else { NewSymT.Add(identifier); } if (maybeRange.IsLeft) { return(maybeRange.LeftToList()[0]); } RangeNode range = maybeRange.RightToList()[0].Second; tokens = maybeRange.RightToList()[0].First; if (tokens.Count < 1) { return(NotAForLoopException); } if (!(tokens[0] is LoopKeywordToken)) { return(NotAForLoopException); } tokens = tokens.Skip(1).ToList(); var maybeBody = BodyNode.Parse(tokens, NewSymT, result); if (maybeBody.IsLeft) { return(maybeBody.LeftToList()[0]); } BodyNode body = maybeBody.RightToList()[0].Second; tokens = maybeBody.RightToList()[0].First; if (tokens.Count < 1) { return(NotAForLoopException); } if (!(tokens[0] is EndKeywordToken)) { return(NotAForLoopException); } tokens = tokens.Skip(1).ToList(); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } result.Range = range; result.Body = body; return(new Pair <List <IToken>, ForLoopNode>(tokens, result)); }
public static Either <ParseException, Pair <List <IToken>, SummandNode> > Parse(List <IToken> tokens, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("SummandNode"); var maybePrimary = PrimaryNode.Parse(tokens, parentTypeTable); if (maybePrimary.IsRight) { tokens = maybePrimary.RightToList()[0].First; while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } return(new Pair <List <IToken>, SummandNode>(tokens, new SummandNode(maybePrimary.RightToList()[0].Second, parentTypeTable))); } if (tokens.Count < 1) { return(NotASummandException); } if (!(tokens[0] is LeftParenthSymbolToken)) { return(NotASummandException); } tokens = tokens.Skip(1).ToList(); var maybeExpression = ExpressionNode.Parse(tokens, parentTypeTable); if (maybeExpression.IsLeft) { return(maybeExpression.LeftToList()[0]); } tokens = maybeExpression.RightToList()[0].First; if (tokens.Count < 1) { return(NotASummandException); } if (!(tokens[0] is RightParenthSymbolToken)) { return(NotASummandException); } tokens = tokens.Skip(1).ToList(); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } return(new Pair <List <IToken>, SummandNode>(tokens, new SummandNode(maybeExpression.RightToList()[0].Second, parentTypeTable))); }
public static Either <ParseException, Pair <List <IToken>, ModifiablePrimaryNode> > Parse(List <IToken> tokens, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("ModifiablePrimaryNode"); if (tokens.Count < 1) { return(NotAModifiablePrimaryException); } if (!(tokens[0] is IdentifierToken)) { return(NotAModifiablePrimaryException); } IdentifierToken identifier = (IdentifierToken)tokens[0]; tokens = tokens.Skip(1).ToList(); var identifiers = new List <IdentifierToken>(); var expressions = new List <ExpressionNode>(); while (true) { if (tokens.Count < 1) { return(new Pair <List <IToken>, ModifiablePrimaryNode> (tokens, new ModifiablePrimaryNode(identifier, parentTypeTable))); } if (tokens[0] is DotSymbolToken) { tokens = tokens.Skip(1).ToList(); if (tokens.Count < 1) { return(NotAModifiablePrimaryException); } if (!(tokens[0] is IdentifierToken)) { return(NotAModifiablePrimaryException); } identifiers.Add((IdentifierToken)tokens[0]); tokens = tokens.Skip(1).ToList(); } else if (tokens[0] is LeftBracketSymbolToken) { tokens = tokens.Skip(1).ToList(); var maybeExpression = ExpressionNode.Parse(tokens, parentTypeTable); if (maybeExpression.IsLeft) { return(maybeExpression.LeftToList()[0]); } tokens = maybeExpression.RightToList()[0].First; if (tokens.Count < 1) { return(NotAModifiablePrimaryException); } if (!(tokens[0] is RightBracketSymbolToken)) { return(NotAModifiablePrimaryException); } expressions.Add(maybeExpression.RightToList()[0].Second); tokens = tokens.Skip(1).ToList(); } else { break; } } while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } return(new Pair <List <IToken>, ModifiablePrimaryNode> (tokens, new ModifiablePrimaryNode(identifier, identifiers, expressions, parentTypeTable)));; }
private ModifiablePrimaryNode(IdentifierToken identifier, IScopedTable <IEntityType, string> parentTypeTable) { Identifier = identifier; ParentTypeTable = parentTypeTable; }
public static Either <ParseException, Pair <List <IToken>, RangeNode> > Parse(List <IToken> tokens, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("RangeNode"); if (tokens.Count < 1) { return(NotARangeException); } if (!(tokens[0] is InKeywordToken)) { return(NotARangeException); } tokens = tokens.Skip(1).ToList(); Boolean reverse = false; if (tokens.Count >= 1) { if (tokens[0] is ReverseKeywordToken) { reverse = true; tokens = tokens.Skip(1).ToList(); } } var maybeExpression1 = ExpressionNode.Parse(tokens, parentTypeTable); if (maybeExpression1.IsLeft) { return(maybeExpression1.LeftToList()[0]); } tokens = maybeExpression1.RightToList()[0].First; if (tokens.Count < 1) { return(NotARangeException); } if (!(tokens[0] is RangeSymbolToken)) { return(NotARangeException); } tokens = tokens.Skip(1).ToList(); var maybeExpression2 = ExpressionNode.Parse(tokens, parentTypeTable); if (maybeExpression2.IsLeft) { return(maybeExpression2.LeftToList()[0]); } tokens = maybeExpression2.RightToList()[0].First; while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } return(new Pair <List <IToken>, RangeNode>(tokens, new RangeNode( maybeExpression1.RightToList()[0].Second, maybeExpression2.RightToList()[0].Second, reverse))); }
public static Either <ParseException, Pair <List <IToken>, RecordTypeNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("RecordTypeNode"); var declarations = new List <VariableDeclarationNode>(); if (tokens.Count < 1) { return(NotARecordTypeException); } if (!(tokens[0] is RecordKeywordToken)) { return(NotARecordTypeException); } tokens = tokens.Skip(1).ToList(); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } while (true) { var maybeVariableDeclaration = VariableDeclarationNode.Parse(tokens, symT, parentTypeTable); if (maybeVariableDeclaration.IsLeft) { break; } declarations.Add(maybeVariableDeclaration.RightToList()[0].Second); tokens = maybeVariableDeclaration.RightToList()[0].First; } if (tokens.Count < 1) { return(NotARecordTypeException); } if (!(tokens[0] is EndKeywordToken)) { return(NotARecordTypeException); } tokens = tokens.Skip(1).ToList(); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } return(new Pair <List <IToken>, RecordTypeNode>(tokens, new RecordTypeNode(declarations, symT))); }
private StatementNode(RoutineCallNode routineCall, IScopedTable <IEntityType, string> parentTypeTable) { RoutineCall = routineCall; ParentTypeTable = parentTypeTable; }
private SummandNode(ExpressionNode expression, IScopedTable <IEntityType, string> parentTypeTable) { Expression = expression; ParentTypeTable = parentTypeTable; }
private StatementNode(WhileLoopNode whileLoop, IScopedTable <IEntityType, string> parentTypeTable) { WhileLoop = whileLoop; ParentTypeTable = parentTypeTable; }
public static Either <ParseException, Pair <List <IToken>, BodyNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("BodyNode"); ImmutableArray <IAstNode> elements = ImmutableArray <IAstNode> .Empty; var typeTable = new Dictionary <string, IEntityType>(); var result = new BodyNode(ImmutableArray <IAstNode> .Empty, typeTable, parentTypeTable); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } while (true) { var maybeSimpleDeclaration1 = VariableDeclarationNode.Parse(tokens, symT, result); if (maybeSimpleDeclaration1.IsRight) { tokens = maybeSimpleDeclaration1.RightToList()[0].First; var varDecl = maybeSimpleDeclaration1.RightToList()[0].Second; elements = elements.Add(varDecl); typeTable.TryAdd(varDecl.Identifier.Lexeme, varDecl.ToVariableType()); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeSimpleDeclaration2 = TypeDeclarationNode.Parse(tokens, symT, result); if (maybeSimpleDeclaration2.IsRight) { tokens = maybeSimpleDeclaration2.RightToList()[0].First; var typeDecl = maybeSimpleDeclaration2.RightToList()[0].Second; elements = elements.Add(typeDecl); typeTable.TryAdd(typeDecl.Identifier.Lexeme, typeDecl.ToTypeAliasType()); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeStatement = StatementNode.Parse(tokens, symT, result); if (maybeStatement.IsRight) { tokens = maybeStatement.RightToList()[0].First; elements = elements.Add(maybeStatement.RightToList()[0].Second); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } var maybeExpression = StatementNode.Parse(tokens, symT, result); if (maybeExpression.IsRight) { tokens = maybeExpression.RightToList()[0].First; elements = elements.Add(maybeExpression.RightToList()[0].Second); while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } continue; } break; } if (tokens.Count < 1) { return(NotABodyException); } if (!(tokens[0] is ReturnKeywordToken)) { return(NotABodyException); } tokens = tokens.Skip(1).ToList(); var maybeExpression1 = ExpressionNode.Parse(tokens, result); if (maybeExpression1.IsRight) { while (tokens.Count > 0) { if (tokens[0] is NewLineSymbolToken || tokens[0] is CommentToken || tokens[0] is SemicolonSymbolToken) { tokens = tokens.Skip(1).ToList(); } else { break; } } tokens = maybeExpression1.RightToList()[0].First; result.Elements = elements; result.ReturnExpressionNode = maybeExpression1.RightToList()[0].Second; var res = new Pair <List <IToken>, BodyNode>(tokens, result); return(res); } result.Elements = elements; return(new Pair <List <IToken>, BodyNode>(tokens, result)); }
private StatementNode(IfStatementNode ifStatement, IScopedTable <IEntityType, string> parentTypeTable) { IfStatement = ifStatement; ParentTypeTable = parentTypeTable; }
public static Either <ParseException, Pair <List <IToken>, ParameterNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("ParameterNode"); if (tokens.Count < 3) { return(NotAParameterException); } if (!(tokens[0] is IdentifierToken)) { return(NotAParameterException); } IdentifierToken name = (IdentifierToken)tokens[0]; tokens = tokens.Skip(1).ToList(); if (!(tokens[0] is IsKeywordToken)) { return(NotAParameterException); } tokens = tokens.Skip(1).ToList(); var maybeType = TypeNode.Parse(tokens, symT, parentTypeTable); if (maybeType.IsLeft) { return(maybeType.LeftToList()[0]); } ITypeNode type = maybeType.RightToList()[0].Second; tokens = maybeType.RightToList()[0].First; return(new Pair <List <IToken>, ParameterNode>(tokens, new ParameterNode(name, type))); }
public static Either <ParseException, Pair <List <IToken>, TypeNode> > Parse(List <IToken> tokens, SymT symT, IScopedTable <IEntityType, string> parentTypeTable) { Console.WriteLine("TypeNode"); var maybePrimitiveType = PrimitiveTypeNode.Parse(tokens); if (maybePrimitiveType.IsLeft) { var maybeArrayType = ArrayTypeNode.Parse(tokens, symT, parentTypeTable); if (maybeArrayType.IsLeft) { SymT NewSymT = new SymT(symT); var maybeRecordType = RecordTypeNode.Parse(tokens, NewSymT, parentTypeTable); if (maybeRecordType.IsLeft) { if (tokens.Count < 1) { return(NotATypeException); } if (!(tokens[0] is IdentifierToken)) { return(NotATypeException); } IdentifierToken identifier = (IdentifierToken)tokens[0]; if (!(symT.ContainRec(identifier))) { // TODO: return an exception instead Console.Write("No such identifier"); } tokens = tokens.Skip(1).ToList(); return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode(identifier))); } tokens = maybeRecordType.RightToList()[0].First; return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode( maybeRecordType.RightToList()[0].Second))); } tokens = maybeArrayType.RightToList()[0].First; return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode( maybeArrayType.RightToList()[0].Second))); } tokens = maybePrimitiveType.RightToList()[0].First; return(new Pair <List <IToken>, TypeNode> (tokens, new TypeNode( maybePrimitiveType.RightToList()[0].Second))); }
private RoutineDeclarationNode(IDictionary <string, IEntityType> scopeTypeTable, IScopedTable <IEntityType, string> parentTypeTable) { ScopeTypeTable = scopeTypeTable; ParentTypeTable = parentTypeTable; }