Removed duplication in left recursive infix operator parsers

[fur] / parsing.py

diff --git a/parsing.py b/parsing.py
index 84e08de..462c2b4 100644 (file)
--- a/parsing.py
+++ b/parsing.py
@@ -1,8 +1,5 @@
 import collections
 
-# TODO Check max symbol length in assignments, function calls, and symbol expressions
-MAX_SYMBOL_LENGTH = 16
-
 def _or_parser(*parsers):
     def result_parser(index, tokens):
         failure = (False, index, None)
@@ -61,6 +58,13 @@ FurNegationExpression = collections.namedtuple(
     ],
 )
 
+FurParenthesizedExpression = collections.namedtuple(
+    'FurParenthesizedExpression',
+    [
+        'internal',
+    ],
+)
+
 FurAdditionExpression = collections.namedtuple(
     'FurAdditionExpression',
     [
@@ -101,6 +105,54 @@ FurModularDivisionExpression = collections.namedtuple(
     ],
 )
 
+FurEqualityExpression = collections.namedtuple(
+    'FurEqualityExpression',
+    [
+        'left',
+        'right',
+    ],
+)
+
+FurInequalityExpression = collections.namedtuple(
+    'FurInequalityExpression',
+    [
+        'left',
+        'right',
+    ],
+)
+
+FurLessThanOrEqualExpression = collections.namedtuple(
+    'FurLessThanOrEqualExpression',
+    [
+        'left',
+        'right',
+    ],
+)
+
+FurGreaterThanOrEqualExpression = collections.namedtuple(
+    'FurGreaterThanOrEqualExpression',
+    [
+        'left',
+        'right',
+    ],
+)
+
+FurLessThanExpression = collections.namedtuple(
+    'FurLessThanExpression',
+    [
+        'left',
+        'right',
+    ],
+)
+
+FurGreaterThanExpression = collections.namedtuple(
+    'FurGreaterThanExpression',
+    [
+        'left',
+        'right',
+    ],
+)
+
 def _integer_literal_expression_parser(index, tokens):
     failure = (False, index, None)
 
@@ -123,6 +175,28 @@ def _symbol_expression_parser(index, tokens):
 
     return (False, index, None)
 
+def _parenthesized_expression_parser(index, tokens):
+    failure = (False, index, None)
+
+    if tokens[index].type == 'open_parenthese':
+        index += 1
+    else:
+        return failure
+
+    success, index, internal = _expression_parser(index, tokens)
+    if not success:
+        return failure
+
+    if tokens[index].type == 'close_parenthese':
+        index += 1
+    else:
+        raise Exception('Expected ")" on line {}, found "{}"'.format(
+            tokens[index].line,
+            tokens[index].match,
+        ))
+
+    return True, index, FurParenthesizedExpression(internal=internal)
+
 def _negation_expression_parser(index, tokens):
     failure = (False, index, None)
 
@@ -140,64 +214,76 @@ def _literal_level_expression_parser(index, tokens):
     return _or_parser(
         _negation_expression_parser,
         _function_call_expression_parser,
+        _parenthesized_expression_parser,
         _integer_literal_expression_parser,
         _string_literal_expression_parser,
         _symbol_expression_parser,
     )(index, tokens)
 
-def _multiplication_level_expression_parser(index, tokens):
-    failure = (False, index, None)
-
-    success, index, result = _literal_level_expression_parser(index, tokens)
-
-    if not success:
-        return failure
-
-    while success and index < len(tokens) and tokens[index].type == 'multiplication_level_operator':
-        success = False
+def _left_recursive_infix_operator_parser(token_type, operand_parser, operator_to_expression_type_mapping):
+    def result_parser(index, tokens):
+        failure = (False, index, None)
 
-        if index + 1 < len(tokens):
-            success, try_index, value = _literal_level_expression_parser(index + 1, tokens)
+        success, index, result = operand_parser(index, tokens)
 
-        if success:
-            result = {
-                '*': FurMultiplicationExpression,
-                '//': FurIntegerDivisionExpression,
-                '%': FurModularDivisionExpression,
-            }[tokens[index].match](left=result, right=value)
-            index = try_index
+        if not success:
+            return failure
 
-    return True, index, result
+        while success and index < len(tokens) and tokens[index].type == token_type:
+            success = False
 
-def _addition_level_expression_parser(index, tokens):
-    failure = (False, index, None)
+            if index + 1 < len(tokens):
+                success, try_index, value = operand_parser(index + 1, tokens)
 
-    success, index, result = _multiplication_level_expression_parser(index, tokens)
+            if success:
+                result = operator_to_expression_type_mapping[tokens[index].match](left=result, right=value)
+                index = try_index
 
-    if not success:
-        return failure
+        return True, index, result
 
-    while success and index < len(tokens) and tokens[index].type == 'addition_level_operator':
-        success = False
+    return result_parser
 
-        if index + 1 < len(tokens):
-            success, try_index, value = _multiplication_level_expression_parser(index + 1, tokens)
+def _multiplication_level_expression_parser(index, tokens):
+    return _left_recursive_infix_operator_parser(
+        'multiplication_level_operator',
+        _literal_level_expression_parser,
+        {
+            '*': FurMultiplicationExpression,
+            '//': FurIntegerDivisionExpression,
+            '%': FurModularDivisionExpression,
+        },
+    )(index, tokens)
 
-        if success:
-            result = {
-                '+': FurAdditionExpression,
-                '-': FurSubtractionExpression,
-            }[tokens[index].match](left=result, right=value)
-            index = try_index
+def _addition_level_expression_parser(index, tokens):
+    return _left_recursive_infix_operator_parser(
+        'addition_level_operator',
+        _multiplication_level_expression_parser,
+        {
+            '+': FurAdditionExpression,
+            '-': FurSubtractionExpression,
+        },
+    )(index, tokens)
 
-    return True, index, result
+def _equality_level_expression_parser(index, tokens):
+    return _left_recursive_infix_operator_parser(
+        'equality_level_operator',
+        _addition_level_expression_parser,
+        {
+            '==': FurEqualityExpression,
+            '!=': FurInequalityExpression,
+            '>=': FurGreaterThanOrEqualExpression,
+            '<=': FurLessThanOrEqualExpression,
+            '>': FurGreaterThanExpression,
+            '<': FurLessThanExpression,
+        },
+    )(index, tokens)
 
 def _comma_separated_list_parser(index, tokens):
     failure = (False, index, None)
 
     expressions = []
 
-    success, index, expression = _addition_level_expression_parser(index, tokens)
+    success, index, expression = _expression_parser(index, tokens)
 
     if success:
         expressions.append(expression)
@@ -208,7 +294,7 @@ def _comma_separated_list_parser(index, tokens):
         success = False
 
         if index + 1 < len(tokens):
-            success, try_index, expression = _addition_level_expression_parser(index + 1, tokens)
+            success, try_index, expression = _expression_parser(index + 1, tokens)
 
         if success:
             expressions.append(expression)
@@ -267,10 +353,10 @@ def _function_call_expression_parser(index, tokens):
 
     return True, index, FurFunctionCallExpression(function=function, arguments=arguments)
 
-_expression_parser = _multiplication_level_expression_parser
+_expression_parser = _equality_level_expression_parser
 
 def _assignment_statement_parser(index, tokens):
-    # TODO Use a FurSymbolExpression for the target
+    # TODO Use a FurSymbolExpression for the target? Maybe this is actually not a good idea
     failure = (False, index, None)
 
     if tokens[index].type != 'symbol':
@@ -294,6 +380,7 @@ def _assignment_statement_parser(index, tokens):
     return True, index, FurAssignmentStatement(target=target, expression=expression)
 
 def _statement_parser(index, tokens):
+    # TODO It would be good to include newlines in the parsing of this because it removes the ambiguity between "function(argument)" (one statement) and "function\n(argument)" (two statements)
     return _or_parser(
         _assignment_statement_parser,
         _expression_parser,