Use order instead of operator to normalize infix expressions

[fur] / parsing.py

diff --git a/parsing.py b/parsing.py
index df29c0d..23bf65e 100644 (file)
--- a/parsing.py
+++ b/parsing.py
@@ -1,5 +1,11 @@
 import collections
 
+def consume_newlines(index, tokens):
+    while index < len(tokens) and tokens[index].type == 'newline':
+        index += 1
+
+    return True, index, None
+
 def _or_parser(*parsers):
     def result_parser(index, tokens):
         failure = (False, index, None)
@@ -142,7 +148,7 @@ def _literal_level_expression_parser(index, tokens):
         _symbol_expression_parser,
     )(index, tokens)
 
-def _left_recursive_infix_operator_parser(token_type, operand_parser, order):
+def _left_recursive_infix_operator_parser(operator_token_matcher, operand_parser, order):
     def result_parser(index, tokens):
         failure = (False, index, None)
 
@@ -151,7 +157,7 @@ def _left_recursive_infix_operator_parser(token_type, operand_parser, order):
         if not success:
             return failure
 
-        while success and index < len(tokens) and tokens[index].type == token_type:
+        while success and index < len(tokens) and operator_token_matcher(tokens[index]):
             success = False
 
             if index + 1 < len(tokens):
@@ -172,23 +178,37 @@ def _left_recursive_infix_operator_parser(token_type, operand_parser, order):
 
 def _multiplication_level_expression_parser(index, tokens):
     return _left_recursive_infix_operator_parser(
-        'multiplication_level_operator',
+        lambda token: token.type == 'multiplication_level_operator',
         _literal_level_expression_parser,
         'multiplication_level',
     )(index, tokens)
 
 def _addition_level_expression_parser(index, tokens):
     return _left_recursive_infix_operator_parser(
-        'addition_level_operator',
+        lambda token: token.type == 'addition_level_operator',
         _multiplication_level_expression_parser,
         'addition_level',
     )(index, tokens)
 
-def _equality_level_expression_parser(index, tokens):
+def _comparison_level_expression_parser(index, tokens):
     return _left_recursive_infix_operator_parser(
-        'equality_level_operator',
+        lambda token: token.type == 'comparison_level_operator',
         _addition_level_expression_parser,
-        'equality_level',
+        'comparison_level',
+    )(index, tokens)
+
+def _and_level_expression_parser(index, tokens):
+    return _left_recursive_infix_operator_parser(
+        lambda token: token.type == 'symbol' and token.match == 'and',
+        _comparison_level_expression_parser,
+        'and_level',
+    )(index, tokens)
+
+def _or_level_expression_parser(index, tokens):
+    return _left_recursive_infix_operator_parser(
+        lambda token: token.type == 'symbol' and token.match == 'or',
+        _and_level_expression_parser,
+        'or_level',
     )(index, tokens)
 
 def _comma_separated_list_parser(index, tokens):
@@ -224,6 +244,13 @@ FurFunctionCallExpression = collections.namedtuple(
     ],
 )
 
+FurExpressionStatement = collections.namedtuple(
+    'FurExpressionStatement',
+    [
+        'expression',
+    ],
+)
+
 FurAssignmentStatement = collections.namedtuple(
     'FurAssignmentStatement',
     [
@@ -266,7 +293,17 @@ def _function_call_expression_parser(index, tokens):
 
     return True, index, FurFunctionCallExpression(function=function, arguments=arguments)
 
-_expression_parser = _equality_level_expression_parser
+_expression_parser = _or_level_expression_parser
+
+def _expression_statement_parser(index, tokens):
+    failure = (False, index, None)
+
+    success, index, expression = _expression_parser(index, tokens)
+
+    if not success:
+        return failure
+
+    return (True, index, FurExpressionStatement(expression=expression))
 
 def _assignment_statement_parser(index, tokens):
     # TODO Use a FurSymbolExpression for the target? Maybe this is actually not a good idea
@@ -293,10 +330,14 @@ 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)
+    _, index, _ = consume_newlines(index, tokens)
+
+    if index == len(tokens):
+        return (False, index, None)
+
     return _or_parser(
         _assignment_statement_parser,
-        _expression_parser,
+        _expression_statement_parser,
     )(index, tokens)
 
 def _program_formatter(statement_list):