public Node ParameterDeclaration() { var paramList = new ParameterDeclarationList(); while (CurrentToken == TokenCategory.IDENTIFIER) { var tempList = new VariableDeclarationList(); Node idToken = new Identifier() { AnchorToken = Expect(TokenCategory.IDENTIFIER) }; tempList.Add(idToken); while (CurrentToken == TokenCategory.COMMA) { Expect(TokenCategory.COMMA); tempList.Add(new Identifier() { AnchorToken = Expect(TokenCategory.IDENTIFIER) }); } Expect(TokenCategory.DECLARATION); var tipo = Type(); //declarationList.Add(Type()); foreach (var node in tempList) { tipo.Add(node); } paramList.Add(tipo); Expect(TokenCategory.ENDLINE); } return(paramList); }
public ForVarIterationStatement(VariableDeclarationList variableDeclarations, AbstractExpression?conditionExpression, AbstractExpression?endExpression, Statement doStatement, bool isStrictMode) : base(isStrictMode) { this.doStatement = doStatement; this.variableDeclarations = variableDeclarations; this.conditionExpression = conditionExpression; this.endExpression = endExpression; }
public virtual void VisitVariableDeclarationList(VariableDeclarationList node, TContext context) { this.Visit(node.Type, context); foreach (var n in node.Declarations) { this.Visit(n, context); } }
public void ReadonlyNodeCollection_IsNotEditable() { var subject = new VariableDeclarationList(); subject.MakeReadonly(); Action action = () => subject.Declarations.Add(new VariableDeclaration()); action.Should().Throw <InvalidOperationException>(); }
public override void VisitVariableDeclarationList(VariableDeclarationList node, CloningAstVisitorContext context) { var result = new VariableDeclarationList() { Type = this.CloneNode(node.Type, context) }; this.CloneNodeCollection(node.Declarations, result.Declarations, context); context.Result = result; }
/* * LL(1) Grammar: * PROGRAM ::= ("const" CONST_DECL+)? ("var" VAR_DECL+)? PROC_DECL* "program" STATEMENT* "end" ";" * CONST_DECL ::= IDENTIFIER ":=" LITERAL ";" * VAR_DECL ::= IDENTIFIER ("," IDENTIFIER)* ":" TYPE ";" * LITERAL ::= SIMPLE_LITERAL | LIST * SIMPLE_LITERAL ::= INTEGER_LITERAL | STRING_LITERAL | TRUE | FALSE * TYPE ::= SIMPLE_TYPE | LIST_TYPE * SIMPLE_TYPE ::= "integer" | "string" | "boolean" * LIST_TYPE ::= "list" "of" SIMPLE_TYPE * LIST ::= "{" (SIMPLE_LITERAL ("," SIMPLE_LITERAL )*)? "}" * PROC_DECL ::= "procedure" IDENTIFIER "(" PARAM_DECL* ")" (":" TYPE)? ";" ("const" CONST_DECL+)? ("var" VAR_DECL+)? "begin" STATEMENT* "end" ";" * PARAM_DECL ::= IDENTIFIER ("," IDENTIFIER)* ":" TYPE ";" * STATEMENT ::= (IDENTIFIER (ASS_STAT | CALL_STAT) ) | IF_STAT | LOOP_STAT | FOR_STAT | RET_STAT | EXIT_STAT * ASS_STAT ::= ("[" EXPR "]")? ":=" EXPR ";" * CALL_STAT ::= "(" (EXPR ("," EXPR)*)? ")" ";" * IF_STAT ::= "if" EXPR "then" STATEMENT* ("elseif" EXPR "THEN" STATEMENT*)* ("else" STATEMENT*)? "end" ";" * LOOP_STAT ::= "loop" STATEMENT* "end" ";" * FOR_STAT ::= "for" IDENTIFIER "in" EXPR "do" STATEMENT* "end" ";" * RET_STAT ::= "return" EXPR? ";" * EXIT_STAT ::= "exit" ";" * EXPR ::= LOGIC_EXPR * LOGIC_EXPR ::= REL_EXPR (LOGIC_OP REL_EXPR)* * LOGIC_OP ::= "and" | "or" | "xor" * REL_EXPR ::= SUM_EXPR (REL_OP SUM_EXPR)* * REL_OP ::= "=" | "<>" | "<" | ">" | "<=" | ">=" * SUM_EXPR ::= MUL_EXPR (SUM_OP MUL_EXPR)* * SUM_OP ::= "+" | "-" * MUL_EXPR ::= UN_EXPR (MUL_OP UN_EXPR)* * MUL_OP ::= "*" | "div" | "rem" * UN_EXPR ::= ("not" UN_EXPR) | ("-" UN_EXPR) | SIMP_EXPR * SIMP_EXPR ::= ("(" Expression ")" | (IDENTIFIER CALL?) | LITERAL ) ("[" EXPR "]")? * CALL ::= "(" (EXPR ("," EXPR)*)? ")" */ public Node Program() { var result = new Program(); var constantDeclarationList = new ConstantDeclarationList(); if (CurrentToken == TokenCategory.CONST) { Expect(TokenCategory.CONST); do { constantDeclarationList.Add(ConstantDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); } result.Add(constantDeclarationList); var variableDeclarationList = new VariableDeclarationList(); if (CurrentToken == TokenCategory.VAR) { Expect(TokenCategory.VAR); do { variableDeclarationList.Add(VariableDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); } result.Add(variableDeclarationList); var procedureDeclarationList = new ProcedureDeclarationList(); if (CurrentToken == TokenCategory.PROCEDURE) { do { procedureDeclarationList.Add(ProcedureDeclaration()); } while (CurrentToken == TokenCategory.PROCEDURE); } result.Add(procedureDeclarationList); Expect(TokenCategory.PROGRAM); var statementList = new StatementList(); while (firstOfStatement.Contains(CurrentToken)) { statementList.Add(Statement()); } result.Add(statementList); Expect(TokenCategory.END); Expect(TokenCategory.SEMICOLON); Expect(TokenCategory.EOF); return(result); }
private Struct ParseStruct() { Accept(Token.TokenType.KEBAB); var structName = new UserCreatableID(Accept(Token.TokenType.USER_CREATABLE_ID)); Accept(Token.TokenType.LEFT_SQUARE); VariableDeclarationList variableDeclarationList = ParseVariableDeclarationList(); Accept(Token.TokenType.RIGHT_SQUARE); return(new Struct(structName, variableDeclarationList)); }
public Node Program() { var constantList = new ConstantDeclarationList(); var varList = new VariableDeclarationList(); var procedureList = new ProcedureDeclarationList(); var stmtlist = new StatementList(); //IF-> do while because it's one or more times if (firstOfDeclaration.Contains(CurrentToken) && CurrentToken == TokenCategory.CONST) { constantList.AnchorToken = Expect(TokenCategory.CONST); do { constantList.Add(ConstantDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); } if (firstOfDeclaration.Contains(CurrentToken) && CurrentToken == TokenCategory.VAR) { varList.AnchorToken = Expect(TokenCategory.VAR); do { varList.Add(VariableDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); } //just while because it's zero or more times while (firstOfDeclaration.Contains(CurrentToken) && CurrentToken == TokenCategory.PROCEDURE) { procedureList.Add(ProcedureDeclaration()); } Expect(TokenCategory.PROGRAM); while (firstOfStatement.Contains(CurrentToken)) { stmtlist.Add(Statement()); } Expect(TokenCategory.END); Expect(TokenCategory.SEMICOLON); return(new Program() { constantList, varList, procedureList, stmtlist }); }
public object VisitVariableDeclarationList(VariableDeclarationList variableDeclarationList, object o) { variableDeclarationList.VariableDeclarations.ForEach(item => { var count = variableDeclarationList.VariableDeclarations.Count(i => i.Name == item.Name); if (count != 1) { throw new Exception("Duplicate name in struct definition"); } item.Visit(this); }); return(null); }
public void ParentNodeReadonlyMode_WillPropagateToChildNodes() { var subjectIdentifier = new Identifier(); var subject = new VariableDeclarationList(); var declaration = new VariableDeclaration(); declaration.Name = subjectIdentifier; subject.Declarations.Add(declaration); subject.MakeReadonly(); Action action = () => subjectIdentifier.Name = "NewValue"; action.Should().Throw <InvalidOperationException>(); }
private void InferType(VariableDeclarationList node) { if (node.Type == null) { if (node.Declarations.Count > 0) { VariableDeclarationNode variableNode = (node.Declarations[0] as VariableDeclarationNode); if (variableNode.Type == null) { this.Visit(variableNode); } node.SetType(variableNode.Type, false); } else { node.SetType(NodeHelper.CreateNode(NodeKind.AnyKeyword)); } } }
public override void VisitVariableDeclarationList(VariableDeclarationList node, AstPrinterContext context) { this.Visit(node.Type, context); if (node.Declarations.Count > 0) { context.Write(" "); var i = 0; foreach (var n in node.Declarations) { this.Visit(n, context); i++; if (i < node.Declarations.Count) { context.Write(", "); } } } context.Write(";"); }
public CSharpSyntaxNode Convert(VariableDeclarationList node) { bool isVar = false; Node type = node.Type; if (type.Kind == NodeKind.AnyKeyword && node.Declarations.Count > 0) { VariableDeclarationNode variableNode = node.Declarations[0] as VariableDeclarationNode; if (variableNode.Initializer != null && variableNode.Initializer.Kind != NodeKind.NullKeyword) { isVar = true; } } TypeSyntax csType = isVar ? SyntaxFactory.IdentifierName("var") : node.Type.ToCsNode <TypeSyntax>(); return(SyntaxFactory .VariableDeclaration(csType) .AddVariables(node.Declarations.ToCsNodes <VariableDeclaratorSyntax>())); }
public Node VariableDeclaration() { var declarationList = new VariableDeclarationList(); declarationList.AnchorToken = Expect(TokenCategory.VAR); do { var tempList = new VariableDeclarationList(); var firstIdentifier = new Identifier() { AnchorToken = Expect(TokenCategory.IDENTIFIER) }; tempList.Add(firstIdentifier); //declarationList.Add(firstIdentifier); while (CurrentToken == TokenCategory.COMMA) { Expect(TokenCategory.COMMA); tempList.Add(new Identifier() { AnchorToken = Expect(TokenCategory.IDENTIFIER) }); } Expect(TokenCategory.DECLARATION); var tipo = Type(); Console.WriteLine("PERIQUEAR" + tipo); //declarationList.Add(Type()); foreach (var node in tempList) { tipo.Add(node); } declarationList.Add(tipo); Expect(TokenCategory.ENDLINE); } while (CurrentToken == TokenCategory.IDENTIFIER); return(declarationList); }
public object VisitVariableDeclarationList(VariableDeclarationList variableDeclarationList, object o) { return(null); }
public TypeG Visit(VariableDeclarationList node) { foreach (var n in node) { TypeG tipo = Visit((dynamic)n); foreach (var i in n) { var variableName = i.AnchorToken.Lexeme; dynamic variableValue = false; switch (tipo) { case TypeG.BOOLEAN: variableValue = false; break; case TypeG.INTEGER: variableValue = 0; break; case TypeG.STRING: variableValue = ""; break; case TypeG.INTEGER_LIST: variableValue = new int[] { 0 }; break; case TypeG.BOOLEAN_LIST: variableValue = new bool[] { false }; break; case TypeG.STRING_LIST: variableValue = new string[] { "" }; break; default: throw new Exception($"Type {tipo} wasn't found"); } if (CurrentContext.context == "GLOBAL") { if (GloabalDeclaratonT.Contains(variableName)) { throw new SemanticError( "Duplicated variable (" + CurrentContext.context + "): " + variableName, n[0].AnchorToken); } else { GloabalDeclaratonT[variableName] = new GlobalDeclarationType(variableName, TypeG.INTEGER, variableValue, TypeG.VAR); } } else if (CurrentContext.context == "LOCAL") { if (ListLocalDeclarationTable[CurrentContext.index].Contains(variableName)) { throw new SemanticError( "Duplicated variable: " + variableName, n[0].AnchorToken); } else { ListLocalDeclarationTable[CurrentContext.index][variableName] = new LocalDeclarationType(variableName, TypeG.INTEGER, variableValue, -1, TypeG.VAR); } } } } //VisitChildren(node); return(TypeG.VOID); }
public Node ProcedureDeclaration() { var result = new ProcedureDeclaration() { AnchorToken = Expect(TokenCategory.PROCEDURE) }; result.Add(new Identifier() { AnchorToken = Expect(TokenCategory.IDENTIFIER) }); Expect(TokenCategory.PARENTHESIS_OPEN); var parameterList = new ParameterDeclarationList(); if (CurrentToken == TokenCategory.IDENTIFIER) { while (CurrentToken == TokenCategory.IDENTIFIER) { parameterList.Add(VariableDeclaration()); } } result.Add(parameterList); Expect(TokenCategory.PARENTHESIS_CLOSE); var type = new TypeNode(); if (CurrentToken == TokenCategory.COLON) { Expect(TokenCategory.COLON); if (CurrentToken != TokenCategory.LIST) { type.Add(SimpleType()); } else if (CurrentToken == TokenCategory.LIST) { type.Add(ListType()); } } result.Add(type); Expect(TokenCategory.SEMICOLON); var constantList = new ConstantDeclarationList(); if (firstOfDeclaration.Contains(CurrentToken) && CurrentToken == TokenCategory.CONST) { constantList.AnchorToken = Expect(TokenCategory.CONST); do { constantList.Add(ConstantDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); } result.Add(constantList); var variableList = new VariableDeclarationList(); if (firstOfDeclaration.Contains(CurrentToken) && CurrentToken == TokenCategory.VAR) { variableList.AnchorToken = Expect(TokenCategory.VAR); do { variableList.Add(VariableDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); } result.Add(variableList); Expect(TokenCategory.BEGIN); var statementList = new StatementList(); if (firstOfStatement.Contains(CurrentToken)) { while (firstOfStatement.Contains(CurrentToken)) { statementList.Add(Statement()); } } result.Add(statementList); Expect(TokenCategory.END); Expect(TokenCategory.SEMICOLON); return(result); }
public Node ProcedureDeclaration() { var result = new ProcedureDeclaration(); Expect(TokenCategory.PROCEDURE); result.AnchorToken = Expect(TokenCategory.IDENTIFIER); Expect(TokenCategory.LEFT_PAR); var parameterDeclarationList = new ParameterDeclarationList(); while (CurrentToken == TokenCategory.IDENTIFIER) { parameterDeclarationList.Add(ParameterDeclaration()); } result.Add(parameterDeclarationList); Expect(TokenCategory.RIGHT_PAR); if (CurrentToken == TokenCategory.COLON) { Expect(TokenCategory.COLON); result.Add(Type()); } Expect(TokenCategory.SEMICOLON); if (CurrentToken == TokenCategory.CONST) { var constantDeclarationList = new ConstantDeclarationList() { AnchorToken = Expect(TokenCategory.CONST) }; do { constantDeclarationList.Add(ConstantDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); result.Add(constantDeclarationList); } if (CurrentToken == TokenCategory.VAR) { var variableDeclarationList = new VariableDeclarationList() { AnchorToken = Expect(TokenCategory.VAR) }; do { variableDeclarationList.Add(VariableDeclaration()); } while (CurrentToken == TokenCategory.IDENTIFIER); result.Add(variableDeclarationList); } Expect(TokenCategory.BEGIN); var statementList = new StatementList(); while (firstOfStatement.Contains(CurrentToken)) { statementList.Add(Statement()); } result.Add(statementList); Expect(TokenCategory.END); Expect(TokenCategory.SEMICOLON); return(result); }
public override AstNode VisitDeclaratorlist([NotNull] GLSL_ES300Parser.DeclaratorlistContext context) { VariableDeclarationList declaratorList = new VariableDeclarationList(); var currentContext = context; while (currentContext != null) { var dec = currentContext.declarator(); if (dec != null) { if (dec.fully_specified_type() != null) { declaratorList.Type = (TypeSpecifier)this.Visit(dec.fully_specified_type()); } VariableDeclaration declaration = new VariableDeclaration(); if (dec.Identifier() != null) { declaration.Name = new Identifier() { Name = dec.Identifier().Symbol.Text }; if (dec.LeftBracket() != null) { declaration.ArraySpecifier = new ArraySpecifier(); if (dec.constant_expression() != null) { declaration.ArraySpecifier.ArraySizeExpression = (Expression)this.Visit(dec.constant_expression()); } } if (dec.initializer() != null) { declaration.Initializer = (Expression)this.Visit(dec.initializer().assignment_expression()); } declaratorList.Declarations.Add(declaration); } currentContext = null; } else { VariableDeclaration declaration = new VariableDeclaration(); if (currentContext.Identifier() != null) { declaration.Name = new Identifier() { Name = currentContext.Identifier().Symbol.Text }; } if (currentContext.LeftBracket() != null) { declaration.ArraySpecifier = new ArraySpecifier(); if (currentContext.constant_expression() != null) { declaration.ArraySpecifier.ArraySizeExpression = (Expression)this.Visit(currentContext.constant_expression()); } } if (currentContext.initializer() != null) { declaration.Initializer = (Expression)this.Visit(currentContext.initializer().assignment_expression()); } currentContext = currentContext.declaratorlist(); declaratorList.Declarations.Add(declaration); } } declaratorList.Declarations.Reverse(); return(declaratorList); }
public VariableStatement(VariableDeclarationList variableDeclarations, bool isStrictMode) : base(isStrictMode) { this.variableDeclarations = variableDeclarations; }
//----------------------------------------------------------- private string Visit(VariableDeclarationList node, Table table) { return(VisitChildren(node, table)); }
public Type Visit(VariableDeclarationList node) { VisitChildren(node); return(Type.VOID); }
//----------------------------------------------------------- private Type Visit(VariableDeclarationList node, Table table) { VisitChildren(node, table); return(Type.VOID); }