/// <summary> /// Parses a for command /// </summary> private ICommandNode ParseForCommand() { Debugger.Write("Parsing For Command"); Position startPosition = CurrentToken.Position; Accept(TokenType.For); IdentifierNode identifier = ParseIdentifier(); // Declare I as a new variable of type integer with an undefined value VarDeclarationNode declaration = new VarDeclarationNode(identifier, new TypeDenoterNode( new IdentifierNode( new Token(TokenType.Identifier, "Integer", startPosition))), startPosition); // Evaluate E1 Accept(TokenType.Becomes); IExpressionNode becomesExpression = ParseExpression(); // Assign I to the value of E1 AssignCommandNode assign = new AssignCommandNode(identifier, becomesExpression); // Evaluate E2 Accept(TokenType.To); IExpressionNode toExpression = ParseExpression(); Accept(TokenType.Do); // Execute command ICommandNode command = ParseSingleCommand(); Accept(TokenType.Next); return(new ForCommandNode(declaration, assign, toExpression, command, startPosition)); }
public void visitVarDeclaration(VarDeclarationNode node) { IdentifierNode identifier = (IdentifierNode)node.getChildren()[0]; string variableName = identifier.getVariableName(); if (this.forLoopControlVariables.Count > 0) { throw new SemanticException("Declaring variables inside for loop is not allowed."); } if (variableAlreadyDeclared(variableName)) { throw new SemanticException("Variable '" + variableName + "' already declared."); } TypeNode typeNode = (TypeNode)node.getChildren()[1]; MiniPLTokenType type = (MiniPLTokenType)typeNode.getValue(); if (type == MiniPLTokenType.TYPE_IDENTIFIER_INTEGER) { this.symbolTable.addVariable(variableName, 0); } else if (type == MiniPLTokenType.TYPE_IDENTIFIER_STRING) { this.symbolTable.addVariable(variableName, ""); } else if (type == MiniPLTokenType.TYPE_IDENTIFIER_BOOL) { this.symbolTable.addVariable(variableName, false); } else { throw new Exception("Unknown type usage in semantic analyzer."); } }
/// <inheritdoc /> public Node Visit(VarDeclarationParseNode vdpn) { Node val = null; Node type = null; if (vdpn.Value != null) { val = vdpn.Value.Visit(this); } if (vdpn.Type != null) { type = vdpn.Type.Visit(this); } var ret = new VarDeclarationNode(vdpn.Token, vdpn, val, type); addAnnotations(vdpn.Annotations, ret.Annotations); if (vdpn.Annotations != null && vdpn.Annotations.HasAnnotation("public")) { ret.Readable = true; ret.Writable = true; } else { ret.Readable = (vdpn.Annotations != null && vdpn.Annotations.HasAnnotation("readable")); ret.Writable = (vdpn.Annotations != null && vdpn.Annotations.HasAnnotation("writable")); } return(ret); }
public string VisitVarDeclaration(VarDeclarationNode declaration) { var symbol = new VariableSymbol(declaration.VarNode.VariableName, CurrentScope.LookupSymbol(declaration.TypeNode.TypeValue, true)); CurrentScope.Define(symbol); return($"{AddSpaces()}var {declaration.VarNode.VariableName}{CurrentScope.ScopeLevel} : {declaration.TypeNode.TypeValue.ToUpper()};\r\n"); }
/// <summary> /// Creates a new for node /// </summary> /// <param name="varDeclaration"></param> /// <param name="assignCommand"></param> /// <param name="toExpression"></param> /// <param name="command"></param> /// <param name="position"></param> public ForCommandNode(VarDeclarationNode varDeclaration, AssignCommandNode assignCommand, IExpressionNode toExpression, ICommandNode command, Position position) { VarDeclaration = varDeclaration; AssignCommand = assignCommand; ToExpression = toExpression; Command = command; Position = position; }
public void visitVarDeclaration(VarDeclarationNode node) { IdentifierNode identifier = (IdentifierNode)node.getChildren()[0]; string variableName = identifier.getVariableName(); TypeNode typeNode = (TypeNode)node.getChildren()[1]; MiniPLTokenType type = (MiniPLTokenType)typeNode.getValue(); typeCheck(typeNode, type); }
/// <summary> /// Generates code for a var declaration node /// </summary> /// <param name="varDeclaration">The node to generate code for</param> private void GenerateCodeForVarDeclaration(VarDeclarationNode varDeclaration) { Debugger.Write("Generating code for Var Declaration"); byte variableSize = varDeclaration.EntityType.Size; short currentScopeSize = scopes.GetLocalScopeSize(); code.AddInstruction(OpCode.PUSH, 0, 0, variableSize); varDeclaration.RuntimeEntity = new RuntimeVariable(currentScopeSize, variableSize); scopes.AddToLocalScope(variableSize); }
public override string VisitVarDeclaration(VarDeclarationNode varDeclaration) { var typeValue = varDeclaration.TypeNode.TypeValue.ToUpper(); typeValue = this.typesConverter.GetTypeName(typeValue); if (varDeclaration.Annotations.ContainsKey("Global")) { return($"{AddSpaces()}static {typeValue} {varDeclaration.VarNode.VariableName};"); } return($"{AddSpaces()}{typeValue} {varDeclaration.VarNode.VariableName}"); }
public XmlElement Visit(VarDeclarationNode n) { var el = makeNode(n, "var-declaration"); addProperty(el, "name", n.Name); addProperty(el, "value", n.Value); addProperty(el, "annotations", n.Annotations); addProperty(el, "type", n.Type); addProperty(el, "readable", n.Readable); addProperty(el, "writable", n.Writable); return(el); }
protected override List <AssemblyElement> VisitVarDeclaration(VarDeclarationNode node) { List <AssemblyElement> instructions = new List <AssemblyElement>(); if (node.RightSideNode != null) { instructions.AddRange(Visit(node.RightSideNode)); instructions.Add(new PushVar(node.Symbol)); instructions.Add(GetAssignInstruction(node.Symbol)); } return(instructions); }
/// <summary> /// Carries out identification on a var declaration node /// </summary> /// <param name="varDeclaration">The node to perform identification on</param> private void PerformIdentificationOnVarDeclaration(VarDeclarationNode varDeclaration) { Token token = varDeclaration.Identifier.IdentifierToken; bool success = SymbolTable.Enter(token.Spelling, varDeclaration); if (!success) { Reporter.ReportError($"{token.Position} -> Var declaration with {token.Spelling} " + $"already exists in the current scope"); } PerformIdentification(varDeclaration.TypeDenoter); }
/// <summary> /// Carries out identification on a var declaration node /// </summary> /// <param name="varDeclaration">The node to perform identification on</param> private void PerformIdentificationOntypeDenoterDeclaration(VarDeclarationNode varDeclaration) { Token token = varDeclaration.Identifier.IdentifierToken; bool success = SymbolTable.Enter(token.Spelling, varDeclaration); if (success) { PerformIdentification(varDeclaration.TypeDenoter); } else { IsItDirty(); Reporter.IdentifierErrorPositions.Add($"Error has occured here: {token.Position}, var already declared"); } }
protected override void VisitVarDeclaration(VarDeclarationNode node) { if (node.RightSideNode != null) { ASTNode ancestorNode = node.GetFirstSignificantAncestorNode(); switch (ancestorNode) { case PrototypeDefinitionNode _: case InstanceDefinitionNode _: case FunctionDefinitionNode _: break; default: node.Annotations.Add(new VarAssignmentNotAllowedHereError(node.Location)); break; } } //base.VisitVarDeclaration(node); }
public override dynamic Visit(VarDeclarationNode node) { foreach (var idNode in node.Ids) { var id = idNode.Accept(this); if (idNode.Type is ArrayTypeNode at) { var size = at.Size.Accept(this); if (size != null && size != PrimitiveType.Integer) { Context.ErrorService.Add( ErrorType.Unknown, idNode.Token, $"array {id} size must be empty or an integer expression" ); } //throw new Exception($"array {id} size must be empty or an integer expression"); } } return(null); }
public override dynamic Visit(VarDeclarationNode node) { CurrentBlock.AddStatement(node); return(null); }
/// <summary> /// Carries out identification on a var declaration node /// </summary> /// <param name="varDeclaration">The node to perform identification on</param> private void PerformIdentificationOnVarDeclaration(VarDeclarationNode varDeclaration) { PerformIdentification(varDeclaration.TypeDenoter); Token token = varDeclaration.Identifier.IdentifierToken; bool success = SymbolTable.Enter(token.Spelling, varDeclaration); }
public virtual T VisitVarDeclaration(VarDeclarationNode varDeclaration) { throw new NotImplementedException(); }
public override dynamic Visit(VarDeclarationNode node) { return(null); }
public void visitVarDeclaration(VarDeclarationNode node) { updateValue(node); }
public abstract dynamic Visit(VarDeclarationNode node);
public CodeBlock CreateStatement(VarDeclarationNode node) { var output = new CodeBlock(); foreach (var id in node.Ids) { var t = NextTemporary; var v = new Variable { Name = id.Token.Content, Scope = CurrentScope }; AddTemporary(v, t); if (node.Type is SimpleTypeNode) { output.Add(CodeLine.Of($"{VarSignature(node, t.Representation)};", id.Token.Content, id.Token.Line)); } else { HasArrays = true; var at = (ArrayTypeNode)node.Type; var size = -1; var type = _types[at.SubType]; var sizeStr = ""; switch (at.Size) { case NoOpNode _: t.Dynamic = true; t.Size = 0; sizeStr = "0"; break; case ValueNode vn: t.Size = vn.Value; sizeStr = $"{t.Size}"; break; default: { var(sizeTemp, sizeCode) = ComputeTemporary(at.Size); output.Add(sizeCode); sizeStr = sizeTemp.Representation; break; } } // TODO: skip this if value _arrayDefinitions.Add($"typedef _array({type}, {at.SubType});"); output.Add(CodeLine.Of($"_array_{at.SubType} {t.Representation};")); output.Add(CodeLine.Of($"_initArray({t.Representation}, {sizeStr});", $"{id}: array[{(at.Size is NoOpNode ? "" : at.Size.ToString())}] of {at.Type.Token.Content}", node.Token.Line)); AddFreeable(t); } } return(output); }
public string VisitVarDeclaration(VarDeclarationNode varDeclaration) { throw new NotImplementedException(); }
public AddressNode VisitVarDeclaration(VarDeclarationNode varDeclaration) { throw new System.NotImplementedException(); }