Improve errors

Parser.py

@@ -1,19 +1,22 @@
 from Tokenizer import *
 from Note import *
 from AST import *
-from Error import ParseError
+from Error import SyntaxException
 
 def expectedFound(expected, found):
-    raise ParseError(f"Expected: {expected}, found: {found}")
+    raise SyntaxException(None, f"Expected: {expected}, found: {found}")
 
 def parseInteger(input, parent):
-    return IntegerLiteralNode(int(input.pop(0).value))
+    token = input.pop(0)
+    return IntegerLiteralNode(int(token.value), token.pos)
     
-def parseString(input, parent):    
-    return StringLiteralNode(input.pop(0).value[1:-1])
+def parseString(input, parent):   
+    token = input.pop(0)
+    return StringLiteralNode(token.value[1:-1], token.pos)
     
 def parseNote(input, parent): 
-    value = input.pop(0).value
+    token = input.pop(0)
+    value = token.value
     consumedChars = 1
     notePitch = value[consumedChars]
     consumedChars += 1
@@ -33,21 +36,21 @@ def parseNote(input, parent):
             consumedChars += 1  
             duration = int(durationString)
     
-    return NoteLiteralNode(Note(notePitch, octave, duration))
+    return NoteLiteralNode(Note(notePitch, octave, duration), token.pos)
 
 def parseComma(input, parent):
-    input.pop(0)
-    return CommaNode()
+    token = input.pop(0)
+    return CommaNode(token.pos)
 
 def parseList(input, parent):       
-    input.pop(0)
+    token = input.pop(0)
     
-    node = ListNode()
+    node = ListNode(token.pos)
     
     while input[0].type != TokenType.CLOSE_PAREN:  
         element = parseArrayElement(input, node)
         if element is None:
-            raise ParseError(f"Line: {input[0].pos[0]+1}, col: {input[0].pos[1]+1}: Invalid element '{input[0].value}'")
+            raise SyntaxException(input[0].pos, "Invalid element '{input[0].value}'")
         node.append(element)
     
     if input[0].type != TokenType.CLOSE_PAREN:
@@ -57,9 +60,9 @@ def parseList(input, parent):
     return node
             
 def parseBlock(input, parent):
-    input.pop(0)
+    token = input.pop(0)
     
-    block = BlockNode()
+    block = BlockNode(token.pos)
     
     while input[0].type != TokenType.CLOSE_BRACKET:
         block.append(parseToken(input, block))
@@ -72,62 +75,63 @@ def parseBlock(input, parent):
 
 
 def parseAsterisk(input, parent):
-    input.pop(0)
+    token = input.pop(0)
     
     iterator = parent.pop(-1)
     value = parseStatement(input, parent) #TODO: only statements! (?)
     
-    return AsteriskStatementNode(iterator, value)        
+    return AsteriskStatementNode(iterator, value, token.pos)        
    
 def parseNoteOrColon(input, parent):
     note = parseNote(input, parent)    
     if len(input) > 1 and input[0].type == TokenType.COLON:
-        input.pop(0)                
+        token = input.pop(0)                
         b = parseNote(input, parent) #TODO: only expressions!
         if b is None:
-            raise ParseError(f"Line {input[0].pos[0]+1}, col {input[0].pos[1]+1}: Invalid colon argument '{input[0].value}'")
-        return ColonNode(note, b)
+            raise SyntaxException(input[0].pos, f"Invalid colon argument '{input[0].value}'")
+        return ColonNode(note, b, token.pos)
     
     return note
    
 def parseIntegerOrColon(input, parent):
     integer = parseInteger(input, parent)    
     if len(input) > 1 and input[0].type == TokenType.COLON:
-        input.pop(0)                
+        token = input.pop(0)                
         b = parseInteger(input, parent) #TODO: only expressions!
         if b is None:
-            raise ParseError(f"Line {input[0].pos[0]+1}, col {input[0].pos[1]+1}: Invalid colon argument '{input[0].value}'")
-        return ColonNode(integer, b)
+            raise SyntaxException(input[0].pos, f"Invalid colon argument '{input[0].value}'")
+        return ColonNode(integer, b, token.pos)
     
     return integer   
    
-def parseFunctionCallOrAssignOrIdentifier(input, parent):    
-    identifier = IdentifierNode(input.pop(0).value)
+def parseFunctionCallOrAssignOrIdentifier(input, parent):   
+    token = input.pop(0)
+    identifier = IdentifierNode(token.value, token.pos)
     # Function call
     if len(input) > 0 and input[0].type == TokenType.OPEN_PAREN:            
         arguments = parseList(input, parent)        
-        return FunctionCallNode(identifier, arguments)
+        return FunctionCallNode(identifier, arguments, token.pos)
     # Assign
     if len(input) > 1 and input[0].type == TokenType.ASSIGN:          
-        input.pop(0)            
+        token = input.pop(0)            
         value = parseExpression(input, parent) #TODO: only expressions!
-        return AssignExpression(identifier, value)
+        return AssignExpression(identifier, value, token.pos)
         
     return identifier
 
 def parsePercent(input, parent):
-    input.pop(0)
+    token = input.pop(0)
     
     value = parent.pop(-1)
     
-    return PercentNode(value)
+    return PercentNode(value, token.pos)
 
 def parseMinus(input, parent):
-    input.pop(0)
+    token = input.pop(0)
     
     value = parseInteger(input, parent)
     
-    return IntegerLiteralNode(-value.value)
+    return IntegerLiteralNode(-value.value, token.pos)
 
 def parseExpression(input, parent):    
     type = input[0].type
@@ -145,7 +149,7 @@ def parseExpression(input, parent):
         return parsePercent(input, parent)
     if type == TokenType.OPEN_PAREN:
         return parseList(input, parent)     
-    raise ParseError(f"Line {input[0].pos[0]+1}, col {input[0].pos[1]+1}: Unexpected character '{input[0].value}'")
+    raise SyntaxException(input[0].pos, f"Unexpected character '{input[0].value}'")
  
 def parseArrayElement(input, parent):
     type = input[0].type
@@ -172,20 +176,3 @@ def parse(input):
     while len(input) > 0:
         root.append(parseToken(input, root))
     return root
-
-if __name__ == "__main__":      
-    try:
-        with open(sys.argv[1], 'r') as source:
-            lines = [line.rstrip('\n') for line in source.readlines()]
-            
-        tokens = [token for token in tokenize(lines) if token.type != TokenType.COMMENT]
-        
-        ast = parse(tokens)
-        
-        print(ast)
-    except TokenizerError as e:
-        print(str(e))
-        
-    except ParseError as e:
-        print(str(e))
-