public ForLoopNode(VariableIdNode idNode, Dictionary <string, IProperty> symbolTable, Token token) { this.idNode = idNode; this.token = token; this.indexAccumulator = createIndexAccumulator(idNode, symbolTable, token); }
/// <summary> /// Checks the static semantic constraints of an AssignNode. /// </summary> /// <returns>An ISemanticCheckValue.</returns> /// <param name="node">Node.</param> public ISemanticCheckValue VisitAssignNode(AssignNode node) { // Check that the id property in this AssignNode is ok. IProperty property = getVariableProperty(node); // if the property was voidProperty, return at this point, // an error has been reported already if (property == voidProperty) { return(voidProperty); } VariableIdNode idNode = node.IDNode; // check that the id variable is declared checkPropertyDeclared(idNode, property, true); // check that the id property we should be assigning to is not constant // at this point of its lifecycle (i.e. not a current block's control variable) if (property.Constant) { analyzer.notifyError(new IllegalAssignmentError(node)); } // evaluate the type of this property IProperty evaluated = node.Accept(this.typeChecker).asProperty(); // check the type of the expression in the assign node matches the one in the symbol table if (!checkPropertyType(property, evaluated.GetTokenType())) { analyzer.notifyError(new IllegalTypeError(idNode)); } return(voidProperty); }
public AssignNode CreateAssignNode(VariableIdNode idNode, StatementsNode statementsNode, Token t) { AssignNode assignNode = new AssignNode(idNode, symbolTable, t); statementsNode.Statement = assignNode; return(assignNode); }
/// <summary> /// Visits the assign node. /// </summary> /// <returns>An ISemanticCheckValue.</returns> /// <param name="node">Node.</param> public ISemanticCheckValue VisitAssignNode(AssignNode node) { // assign the idNode's value to the one in the expression node VariableIdNode idNode = node.IDNode; IProperty assignValue = node.ExprNode.Accept(this).asProperty(); symbolTable [idNode.ID] = assignValue; return(voidProperty); }
private AssignNode createIndexAccumulator(VariableIdNode idNode, Dictionary <string, IProperty> symbolTable, Token token) { AssignNode accumulator = new AssignNode(idNode, symbolTable, token); BinOpNode accumulationOperation = new BinOpNode(token); accumulationOperation.Operation = TokenType.BINARY_OP_ADD; accumulationOperation.AddExpression(idNode); accumulationOperation.AddExpression(new IntValueNode(1, token)); accumulator.ExprNode = accumulationOperation; return(accumulator); }
/// <summary> /// Parses an assign statement. /// </summary> /// <returns>The next token.</returns> /// <param name="token">Token.</param> /// <param name="statementsNode">Statements node.</param> private Token ParseVariableAssign(Token token, StatementsNode statementsNode) { try { VariableIdNode idNode = nodeBuilder.CreateIdNode(); // parse the target id Token next = ParseVarId(token, idNode); match(next, TokenType.ASSIGN); AssignNode assignNode = nodeBuilder.CreateAssignNode(idNode, statementsNode, token); // parses the expression of the assignment return(ParseExpression(scanner.getNextToken(next), assignNode)); } catch (UnexpectedTokenException ex) { return(FastForwardToStatementEnd(ex)); } }
/// <summary> /// Visits the IO read node. /// </summary> /// <returns>An ISemanticCheckValue.</returns> /// <param name="node">Node.</param> public ISemanticCheckValue VisitIOReadNode(IOReadNode node) { // read an input string input = reader.readLine(); // select the first word of the input input = input.Split(new[] { ' ', '\t', '\n' })[0]; // set the input to the ioreadnode's assignment AssignNode assignNode = node.AssignNode; setAssignValue(input, assignNode); // execute the assign node assignNode.Accept(this); return(voidProperty); }
/// <summary> /// Parses an assignment during a declaration statement into an AssignNode. /// </summary> /// <returns>The next token.</returns> /// <param name="token">Token.</param> /// <param name="assignNode">An AssignNode.</param> private Token ParseAssign(Token token, AssignNode assignNode) { switch (token.Type) { case TokenType.ASSIGN: // if assignment during a declaration was made, parse the expression to the AssignNode assignNode.Token = token; Token next = scanner.getNextToken(token); return(ParseExpression(next, assignNode)); case TokenType.END_STATEMENT: // otherwise, set a default assignment setDefaultAssignment(assignNode); return(token); default: throw new UnexpectedTokenException(token, TokenType.UNDEFINED, ParserConstants.EXPECTATION_SET_ASSIGN); } }
/// <summary> /// Sets a default assignment to an AssignNode. /// </summary> /// <param name="assignNode">An AssignNode.</param> private void setDefaultAssignment(AssignNode assignNode) { TokenType idType = assignNode.IDNode.EvaluationType; switch (idType) { case TokenType.STR_VAL: nodeBuilder.CreateDefaultStringValueNode(assignNode.Token, assignNode); break; case TokenType.INT_VAL: nodeBuilder.CreateDefaultIntValueNode(assignNode.Token, assignNode); break; case TokenType.BOOL_VAL: nodeBuilder.CreateDefaultBoolValueNode(assignNode.Token, assignNode); break; default: throw new UnexpectedTokenException(assignNode.IDNode.Token, TokenType.UNDEFINED, ParserConstants.EXPECTATION_SET_ID_VAL); } }
/// <summary> /// Sets the value of a variable read from user. /// </summary> /// <param name="input">Input.</param> /// <param name="assignNode">Assign node.</param> private void setAssignValue(string input, AssignNode assignNode) { TokenType expectedType = assignNode.IDNode.EvaluationType; // based on the variable's type, we try to parse the user's input switch (expectedType) { case TokenType.INT_VAL: // if its supposed to be an integer but its not, throw a runtime exception if (!StringUtils.isInteger(input)) { throw new RuntimeException(ErrorConstants.NOT_AN_INTEGER_MESSAGE, assignNode.Token); } assignNode.AddExpression(new IntValueNode(StringUtils.parseToInt(input))); break; case TokenType.STR_VAL: assignNode.AddExpression(new StringValueNode(input)); break; default: throw new RuntimeException(ErrorConstants.RUNTIME_ERROR_MESSAGE, assignNode.Token); } }
/// <summary> /// Visits the assign node. /// </summary> /// <returns>a VoidProperty.</returns> /// <param name="node">Node.</param> public ISemanticCheckValue VisitAssignNode(AssignNode node) { // nothing to evaluate here, it's done from the ExecutionVisitor return(voidProperty); }
public IOReadNode(VariableIdNode idNode, Dictionary <string, IProperty> symbolTable, Token t) { this.idNode = idNode; this.assignNode = new AssignNode(this.idNode, symbolTable, t); this.token = t; }
/// <summary> /// Visits the assign node. /// </summary> /// <returns>An ISemanticCheckValue.</returns> /// <param name="node">Node.</param> public ISemanticCheckValue VisitAssignNode(AssignNode node) { // return the evaluation of the node's expression return(getEvaluation(node.ExprNode)); }