Enable parsing lists

2019-07-01 14:16:24 +02:00
parent 5a552823b7
commit d560b89b94
3 changed files with 196 additions and 251 deletions
--- a/Parser.py
+++ b/Parser.py
@@ -1,230 +1,117 @@
-from Tokenizer import *
-from Note import *
 from AST import *
+from Tokenizer import TokenType
 from Error import SyntaxException

-def expectedFound(expected, found):
-    raise SyntaxException(None, f"Expected: {expected}, found: {found}")
+def assertToken(expected, input):
+    if expected != input.current().type:
+        raise SyntaxException(input.current().pos, f"Expected '{expected}', found '{input.current().value}'")

-def assertType(expected, found):
-    if expected != found:
-        raise SyntaxException(None, f"Expected: {expected}, found: {found}")
+def runParsers(input, parent, parsers):
+    for parser in parsers:
+        value = parser(input, parent)
+        if value is not None:
+            return value
+    return None

-def parseInteger(input, parent):
-    token = input.pop(0)
-    return IntegerLiteralNode(int(token.value), parent, token.pos)
-    
-def parseString(input, parent):   
-    token = input.pop(0)
-    return StringLiteralNode(token.value[1:-1], parent, token.pos)
-    
-def parseNote(input, parent): 
-    token = input.pop(0)
-    value = token.value
-    consumedChars = 1
-    notePitch = value[consumedChars]
-    consumedChars += 1
-    octave = 4
-    duration = 4
-    dot = False
-    if consumedChars < len(value) and value[consumedChars] in ('b', '#'):
-        notePitch += value[consumedChars]
-        consumedChars += 1
-    if consumedChars < len(value) and re.match(r'\d', value[consumedChars]):
-        octave = int(value[consumedChars])
-        consumedChars += 1
-    if consumedChars < len(value) and value[consumedChars] == '.':
-        consumedChars += 1
-        durationString = ''            
-        while consumedChars < len(value) and re.match(r'\d', value[consumedChars]):
-            durationString += value[consumedChars]      
-            consumedChars += 1  
-            duration = int(durationString)
-        if consumedChars < len(value) and value[consumedChars] == '.':
-            dot = True
-            consumedChars += 1
-    
-    return NoteLiteralNode(Note(notePitch, octave, duration, dot), parent, token.pos)
+def returnAndGoAhead(input, getValue):
+    value = getValue(input.current())
+    input.ahead()
+    return value

-def parseComma(input, parent):
-    token = input.pop(0)
-    return CommaNode(parent, token.pos)
-
-def parseList(input, parent):       
-    token = input.pop(0)
-    
-    node = ListNode(parent, token.pos)
-    
-    while input[0].type != TokenType.CLOSE_PAREN:  
-        element = parseArrayElement(input, node)
-        if element is None:
-            raise SyntaxException(input[0].pos, "Invalid element '{input[0].value}'")
-        node.append(element)
-    
-    if input[0].type != TokenType.CLOSE_PAREN:
-        expectedFound(TokenType.CLOSE_PAREN, input[0].type)
-    input.pop(0)
-    
-    return node
-            
-def parseBlock(input, parent):
-    token = input.pop(0)
-    
-    block = BlockNode(parent, token.pos)
-    
-    while input[0].type != TokenType.CLOSE_BRACKET:
-        block.append(parseToken(input, block))
-    
-    if input[0].type != TokenType.CLOSE_BRACKET:
-        expectedFound(TokenType.CLOSE_BRACKET, input[0].type)
-    input.pop(0)
-    
-    return block
-
-
-def parseAsterisk(input, parent):
-    token = input.pop(0)
-    
-    iterator = parent.pop(-1)
-    value = parseStatement(input, parent)
-    
-    asterisk = AsteriskStatementNode(iterator, value, parent, token.pos)        
-    iterator.parent = asterisk
-    value.parent = asterisk
-    return asterisk
-   
-def parseNoteOrColon(input, parent):
-    note = parseNote(input, parent)    
-    if len(input) > 1 and input[0].type == TokenType.COLON:
-        token = input.pop(0)                
-        b = parseNote(input, parent)
-        if b is None:
-            raise SyntaxException(input[0].pos, f"Invalid colon argument '{input[0].value}'")
-        colon = ColonNode(note, b, parent, token.pos)
-        note.parent = colon
-        b.parent = colon
-        return colon
-    
-    return note
-   
-def parseIntegerOrColonOrPercent(input, parent):
-    integer = parseInteger(input, parent)    
-    if len(input) > 1 and input[0].type == TokenType.COLON:
-        token = input.pop(0)                
-        b = parseInteger(input, parent) 
-        if b is None:
-            raise SyntaxException(input[0].pos, f"Invalid colon argument '{input[0].value}'")
-        colon = ColonNode(integer, b, parent, token.pos)
-        integer.parent = colon
-        b.parent = colon
-        return colon
-    
-    if len(input) > 0 and input[0].type == TokenType.PERCENT:
-        input.pop(0)
-        percent = PercentNode(integer, parent, integer.pos)
-        integer.parent = percent
-        return percent
-    
-    return integer   
-   
-def parseFunctionCallOrAssignOrIdentifier(input, parent):   
-    token = input.pop(0)
-    identifier = IdentifierNode(token.value, parent, token.pos)
-    # Function call
-    if len(input) > 0 and input[0].type == TokenType.OPEN_PAREN:            
-        arguments = parseList(input, parent)        
-        func = FunctionCallNode(identifier, arguments, parent, token.pos)
-        identifier.parent = func
-        arguments.parent = func
-        return func
-    # Assign
-    if len(input) > 1 and input[0].type == TokenType.ASSIGN:          
-        token = input.pop(0)            
-        value = parseExpression(input, parent) #
-        assign = AssignExpression(identifier, value, parent, token.pos)
-        identifier.parent = assign
-        value.parent = assign
-        return assign
+# int -> INTEGER
+def parseInteger(input, parent):    
+    if input.current().type == TokenType.INTEGER:
+        integer = IntegerLiteralNode(input.current().value, parent, input.current().pos)
+        input.ahead()
        
-    return identifier
+        return integer
+    return None

-def parseMinus(input, parent):
-    token = input.pop(0)
-    
-    value = parseInteger(input, parent)
-    
-    return IntegerLiteralNode(-value.value, parent, token.pos)
+# list -> CLOSE_PAREN | expr listTail
+def parseList(input, parent):      
+    if input.current().type == TokenType.OPEN_PAREN:
+        node = ListNode(parent, input.current().pos)                
+        input.ahead()
+        
+        # list -> CLOSE_PAREN (end of list)
+        if input.current().type == TokenType.CLOSE_PAREN:
+            close = CloseListNode(node, input.current().pos)
+            node.append(close)
+            input.ahead()
+            return node                
+        
+        # list -> expr listTail
+        token = input.current()
+        expr = parseExpression(input, node)
+        item = ListItemNode(expr, node, token.pos)
+        node.append(item)
+        listTail = parseListTail(input, item)
+        item.append(listTail)
+        
+        #while input.current().type != TokenType.CLOSE_PAREN:                        
+            #elem = parseListTail(input, node)            
+            #if elem is None:
+                #raise SyntaxException(input.current().pos, f"Invalid element '{input.current().value}'")
+            #node.append(elem)
+        return node
+    return None
+            

-def parseFunctionDefinition(input, parent):
-    input.pop(0)
+# listTail -> COMMA expr listTail | CLOSE_PAREN
+def parseListTail(input, parent):        
+    # listTail -> CLOSE_PAREN
+    if input.current().type == TokenType.CLOSE_PAREN:   
+        close = CloseListNode(parent, input.current().pos)
+        input.ahead()
+        return close
    
-    assertType(TokenType.IDENTIFIER, input[0].type)
-    token = input.pop(0)
-    name = IdentifierNode(token.value, parent, token.pos)
+    assertToken(TokenType.COMMA, input)
+    input.ahead()
+        
+    expr = parseExpression(input, parent)        
+    if expr is not None: 
+        item = ListItemNode(expr, parent, expr.pos)            
+        expr.parent = item           
+        listTail = parseListTail(input, item)
+        item.append(listTail)
+        listTail.parent = item
+        input.ahead()
+        return item
    
-    assertType(TokenType.OPEN_PAREN, input[0].type)
-    parameters = parseList(input, parent)
-    
-    assertType(TokenType.OPEN_BRACKET, input[0].type)
-    body = parseBlock(input, parent)
-    
-    func = FunctionDefinitionNode(name, parameters, body, parent, token.pos)
-    name.parent = func
-    parameters.parent = func
-    body.parent = func
-    return func
+    return None

-def parseReturn(input, parent):
-    token = input.pop(0)
+def parseExpression(input, parent):
+    value = runParsers(input, parent, [
+        parseInteger,
+        parseList        
+    ])
    
-    value = parseExpression(input, parent)
+    if value is None:
+        raise SyntaxException(input.current().pos, f"Expression expected")
+    
+    return value
    
-    returnNode = ReturnNode(value, parent, token.pos)
-    value.parent = returnNode
-    return returnNode

-def parseExpression(input, parent):    
-    type = input[0].type
-    if type == TokenType.FUNCTION:
-        return parseFunctionDefinition(input, parent)
-    if type == TokenType.RETURN:
-        return parseReturn(input, parent)
-    if type == TokenType.MINUS:
-        return parseMinus(input, parent)
-    if type == TokenType.INTEGER:
-        return parseIntegerOrColonOrPercent(input, parent)
-    if type == TokenType.STRING:
-        return parseString(input, parent)    
-    if type == TokenType.NOTE:
-        return parseNoteOrColon(input, parent)    
-    if type == TokenType.IDENTIFIER:
-        return parseFunctionCallOrAssignOrIdentifier(input, parent)    
-    if type == TokenType.OPEN_PAREN:
-        return parseList(input, parent)     
-    raise SyntaxException(input[0].pos, f"Unexpected character '{input[0].value}'")
- 
-def parseArrayElement(input, parent):
-    type = input[0].type
-    if type == TokenType.COMMA:
-        return parseComma(input, parent)
-    return parseExpression(input, parent)
- 
-def parseStatement(input, parent):
-    type = input[0].type
-    if type == TokenType.OPEN_BRACKET:
-        return parseBlock(input, parent)
-    if type == TokenType.ASTERISK:
-        return parseAsterisk(input, parent)
+def parseToken(input, parent):
+    value = runParsers(input, parent, [
+        parseExpression
+    ])
    
-    return parseExpression(input, parent)
+    if value is None:
+        raise SyntaxException(input.current().pos, "Unknown statement")
    
-def parseToken(input, parent):      
-    #import pdb; pdb.set_trace()
-    return parseStatement(input, parent)    
-    
-  
-def parse(input):    
+    return value
+
+def parse(input):
    root = Program()
-    while len(input) > 0:
-        root.append(parseToken(input, root))
+    while input.notParsedTokensRemain():
+        root.append(parseToken(input, root))    
    return root
+
+
+
+
+
+
+def parseNote(input, parent):
+    pass