AST now contains coordinates of tokens

Lack of the substraction in the AST - issue repaired

Author: jakseluz

README.md

@@ -21,7 +21,9 @@ GreekBase
 │       └── GreekBaseParserVisitor.py ← generated visitor (used by AST tree builder)
 ├── src/
 │   ├── ast_builder.py                ← used for generating AST tree from ANTLR tree
-│   └── astGreek.py                   ← AST tree node classes
+│   ├── astGreek.py                   ← AST tree node classes
+│   ├── semantic_checker.py           ← semantic errors handling etc.
+│   └──
 ├── examples/                         ← example source files
 ├── output/                           ← generated C source files
 ├── run.sh                            ← bash script for generating ANTLR files
@@ -40,6 +42,7 @@ GreekBase
 in order to generate the parser and its tools needed later.
 
 For now, printing the AST tree is possible.
+To do so, please run [main.py](./main.py).
 
 ### 3. Example #1
 1. Source file:
@@ -57,5 +60,5 @@ print y;
 ```
 2. AST tree:
 ```python
-Program(statements=[Assignment(id='x', value=IntLiteral(value=5)), Assignment(id='y', value=IntLiteral(value=10)), IfStatement(condition=Condition(left=Identifier(value='x'), operator='<', right=Identifier(value='y')), then_branch=[Assignment(id='x', value=AdditionOperator(left=Identifier(value='x'), operator='+', right=IntLiteral(value=1)))], else_branch=[Assignment(id='y', value=IntLiteral(value=1))]), PrintStatement(value=Identifier(value='x')), PrintStatement(value=Identifier(value='y'))])
+Program(line=1, column=0, statements=[Assignment(line=1, column=0, id='x', value=IntLiteral(line=1, column=5, value=5)), Assignment(line=2, column=0, id='y', value=IntLiteral(line=2, column=5, value=10)), IfStatement(line=4, column=0, condition=Condition(line=4, column=3, left=Identifier(line=4, column=3, value='x'), operator='<', right=Identifier(line=4, column=7, value='y')), then_branch=[Assignment(line=5, column=4, id='x', value=AdditionOperator(line=5, column=9, left=Identifier(line=5, column=9, value='x'), operator='+', right=IntLiteral(line=5, column=13, value=1)))], else_branch=[Assignment(line=6, column=5, id='y', value=AdditionOperator(line=6, column=10, left=Identifier(line=6, column=10, value='y'), operator='-', right=IntLiteral(line=6, column=14, value=1)))]), PrintStatement(line=9, column=0, value=Identifier(line=9, column=6, value='x')), PrintStatement(line=10, column=0, value=Identifier(line=10, column=6, value='y'))])
 ```

antlr/GreekBaseLexer.g4

@@ -21,7 +21,7 @@ KW_CONST      : 'const';
 KW_USE        : 'use';
 KW_WITH       : 'with';
 KW_NEW        : 'new';
-KW_PRINT     : 'print';
+KW_PRINT      : 'print';
 KW_LCURL : '{';
 KW_RCURL : '}';
 
@@ -33,8 +33,8 @@ OP_LESS       : '<';
 OP_LESS_EQ    : '<=';
 OP_GREATER    : '>';
 OP_GREATER_EQ : '>=';
-OP_ADD       : '+';
-OP_SUB      : '-';
+OP_ADD        : '+';
+OP_SUB        : '-';
 OP_MUL        : '*';
 OP_DIV        : '/';
 OP_MOD        : 'mod';

src/astGreek.py

@@ -2,8 +2,10 @@
 from typing import List
 
 
+@dataclass
 class ASTNode:
-    pass
+    line: int
+    column: int
 
 class Statement(ASTNode):
     pass

src/ast_builder.py

@@ -7,66 +7,67 @@
 class GreekASTBuilder(GreekBaseParserVisitor):
     def visitProgram(self, ctx: GreekBaseParser.ProgramContext):
         # Visit all statements in the program
-        return ast.Program([self.visit(stmt) for stmt in ctx.statement()])
+        return ast.Program(ctx.start.line, ctx.start.column, [self.visit(stmt) for stmt in ctx.statement()])
 
     def visitVariableDeclaration(self, ctx: GreekBaseParser.VariableDeclarationContext):
         var_name = ctx.Identifier().getText()
         var_type = self.visit(ctx.literal())
-        return ast.VariableDeclaration(var_type, var_name)
+        return ast.VariableDeclaration(ctx.start.line, ctx.start.column, var_type, var_name)
 
     def visitAssignment(self, ctx: GreekBaseParser.AssignmentContext):
         # Handles: IDENTIFIER := expression;
         var_name = ctx.IDENTIFIER().getText()
         value = self.visit(ctx.expression())
-        return ast.Assignment(var_name, value)
+        return ast.Assignment(ctx.start.line, ctx.start.column, var_name, value)
 
 
     def visitExpression(self, ctx: GreekBaseParser.ExpressionContext):
+        token = ctx.IDENTIFIER
         if ctx.literal():
             return self.visit(ctx.literal())
 
     def visitIdExpr(self, ctx: GreekBaseParser.IdExprContext):
         if ctx.IDENTIFIER():
-            return ast.Identifier(ctx.IDENTIFIER().getText())
+            return ast.Identifier(ctx.start.line, ctx.start.column, ctx.IDENTIFIER().getText())
 
     def visitLiteral(self, ctx: GreekBaseParser.LiteralContext):
         if ctx.LIT_INT():
-            return ast.IntLiteral(int(ctx.LIT_INT().getText()))
+            return ast.IntLiteral(ctx.start.line, ctx.start.column, int(ctx.LIT_INT().getText()))
         elif ctx.LIT_FLOAT():
-            return ast.FloatLiteral(float(ctx.LIT_FLOAT().getText()))
+            return ast.FloatLiteral(ctx.start.line, ctx.start.column, float(ctx.LIT_FLOAT().getText()))
         elif ctx.LIT_STRING():
-            return ast.StringLiteral(ctx.LIT_STRING().getText().strip('"'))
+            return ast.StringLiteral(ctx.start.line, ctx.start.column, ctx.LIT_STRING().getText().strip('"'))
         elif ctx.LIT_CHAR():
-            return ast.CharLiteral(ctx.LIT_CHAR().getText().strip("'")[0])
+            return ast.CharLiteral(ctx.start.line, ctx.start.column, ctx.LIT_CHAR().getText().strip("'")[0])
 
     def visitIfStatement(self, ctx: GreekBaseParser.IfStatementContext):
         # note that there are two possibilities of IF "scoping"
         # Handles if <cond> then {statements} [else {statements}] end if;
         condition = self.visit(ctx.condition())
         then_branch = [self.visit(nondecl_stmt) for nondecl_stmt in ctx.thenBranch]
         else_branch = [self.visit(nondecl_stmt) for nondecl_stmt in ctx.elseBranch] if ctx.elseBranch else []
-        return ast.IfStatement(condition, then_branch, else_branch)
+        return ast.IfStatement(ctx.start.line, ctx.start.column, condition, then_branch, else_branch)
 
     def visitLoopStatement(self, ctx: GreekBaseParser.LoopStatementContext):
         # Handles while <cond> loop {statements} end loop;
         condition = self.visit(ctx.condition())
         then = [self.visit(nondecl_stmt) for nondecl_stmt in ctx.nonDeclarativeStatement()]
-        return ast.LoopStatement(condition, then)
+        return ast.LoopStatement(ctx.start.line, ctx.start.column, condition, then)
 
     def visitCondition(self, ctx: GreekBaseParser.ConditionContext):
         # Handles condition: expr <relop> expr
         left = self.visit(ctx.expression(0))
         operator = ctx.relop().getText()
         right = self.visit(ctx.expression(1))
-        return ast.Condition(left, operator, right)
+        return ast.Condition(ctx.start.line, ctx.start.column, left, operator, right)
 
 
     def visitProcedureDeclaration(self, ctx: GreekBaseParser.ProcedureDeclarationContext):
         # Store the procedure definition by its name
         name = ctx.IDENTIFIER().getText()
         formalParameterPart = self.visit(ctx.formalParameterPart()) if ctx.formalParameterPart() else []
         body = [self.visit(nondecl_stmt) for nondecl_stmt in ctx.nonDeclarativeStatement()]
-        return ast.Procedure(name, formalParameterPart, body)
+        return ast.Procedure(ctx.start.line, ctx.start.column, name, formalParameterPart, body)
 
 
     # Optional: stub for functionDeclaration if added
@@ -80,34 +81,36 @@ def visitAddExpr(self, ctx: GreekBaseParser.AddExprContext):
         left = self.visit(ctx.expression(0))
         operator = '+'
         right = self.visit(ctx.expression(1))
-        return ast.AdditionOperator(left, operator, right)
+        return ast.AdditionOperator(ctx.start.line, ctx.start.column, left, operator, right)
 
-    def visitMinusExpr(self, ctx: GreekBaseParser.SubExprContext):
+    def visitSubExpr(self, ctx: GreekBaseParser.SubExprContext):
         left = self.visit(ctx.expression(0))
         operator = '-'
         right = self.visit(ctx.expression(1))
-        return ast.AdditionOperator(left, operator, right)
+        return ast.AdditionOperator(ctx.start.line, ctx.start.column, left, operator, right)
 
     def visitMulExpr(self, ctx: GreekBaseParser.MulExprContext):
         left = self.visit(ctx.expression(0))
         operator = '*'
         right = self.visit(ctx.expression(1))
-        return ast.MultiplicationOperator(left, operator, right)
+        return ast.MultiplicationOperator(ctx.start.line, ctx.start.column, left, operator, right)
 
     def visitDivExpr(self, ctx: GreekBaseParser.DivExprContext):
         left = self.visit(ctx.expression(0))
         operator = '/'
         right = self.visit(ctx.expression(1))
-        return ast.MultiplicationOperator(left, operator, right)
+        return ast.MultiplicationOperator(ctx.start.line, ctx.start.column, left, operator, right)
 
     # Grouping
     def visitParensExpr(self, ctx: GreekBaseParser.ParensExprContext):
         return ast.ParenthesisExpression(
+            ctx.start.line, ctx.start.column, 
             self.visit(ctx.expression())
         )
 
     # Printing
     def visitPrintStatement(self, ctx:GreekBaseParser.PrintStatementContext):
         return ast.PrintStatement(
+            ctx.start.line, ctx.start.column, 
             self.visit(ctx.expression())
         )