],
)
+FurListLiteralExpression = collections.namedtuple(
+ 'FurListLiteralExpression',
+ [
+ 'item_expression_list',
+ ],
+)
+
+FurIfExpression = collections.namedtuple(
+ 'FurIfExpression',
+ [
+ 'condition_expression',
+ 'if_statement_list',
+ 'else_statement_list',
+ ],
+)
+
def _integer_literal_expression_parser(index, tokens):
failure = (False, index, None)
return (False, index, None)
-def _parenthese_wrapped_parser(internal_parser):
+def _wrapped_parser(open_token, close_token, internal_parser):
def result_parser(index, tokens):
failure = (False, index, None)
- if tokens[index].type == 'open_parenthese':
+ if tokens[index].type == open_token:
index += 1
else:
return failure
if not success:
return failure
- if tokens[index].type == 'close_parenthese':
+ if tokens[index].type == close_token:
index += 1
else:
- raise Exception('Expected ")" on line {}, found "{}"'.format(
+ # TODO Put the actual expected character in the error message
+ raise Exception('Expected closing token on line {}, found "{}"'.format(
tokens[index].line,
tokens[index].match,
))
return result_parser
+def _bracket_wrapped_parser(internal_parser):
+ return _wrapped_parser('open_bracket', 'close_bracket', internal_parser)
+
+def _parenthese_wrapped_parser(internal_parser):
+ return _wrapped_parser('open_parenthese', 'close_parenthese', internal_parser)
+
def _parenthesized_expression_parser(index, tokens):
return _parenthese_wrapped_parser(_expression_parser)(index, tokens)
+def _list_literal_expression_parser(index, tokens):
+ failure = (False, index, None)
+
+ success, index, item_expression_list = _bracket_wrapped_parser(_comma_separated_expression_list_parser)(index, tokens)
+
+ if success:
+ return success, index, FurListLiteralExpression(
+ item_expression_list=item_expression_list,
+ )
+ else:
+ return failure
+
def _negation_expression_parser(index, tokens):
failure = (False, index, None)
def _literal_level_expression_parser(index, tokens):
return _or_parser(
_negation_expression_parser,
+ _list_item_expression_parser,
_function_call_expression_parser,
_parenthesized_expression_parser,
_integer_literal_expression_parser,
_string_literal_expression_parser,
+ _list_literal_expression_parser,
_symbol_expression_parser,
)(index, tokens)
items = []
+ _, index, _ = consume_newlines(index, tokens)
+
success, index, item = subparser(index, tokens)
if success:
return (True, start_index, ())
while success and index < len(tokens) and tokens[index].type == 'comma':
+ index += 1
success = False
- if index + 1 < len(tokens):
- success, try_index, item = subparser(index + 1, tokens)
+ _, index, _ = consume_newlines(index, tokens)
+
+ if index < len(tokens):
+ success, try_index, item = subparser(index, tokens)
if success:
items.append(item)
def _comma_separated_expression_list_parser(index, tokens):
return _comma_separated_list_parser(_expression_parser)(index, tokens)
+FurListItemExpression = collections.namedtuple(
+ 'FurListItemExpression',
+ [
+ 'list_expression',
+ 'index_expression',
+ ],
+)
+
FurFunctionCallExpression = collections.namedtuple(
'FurFunctionCallExpression',
[
],
)
+def _list_item_expression_parser(index, tokens):
+ failure = (False, index, None)
+
+ # We have to be careful what expressions we add here. Otherwise expressions
+ # like "a + b[0]" become ambiguous to the parser.
+ success, index, list_expression = _or_parser(
+ _symbol_expression_parser,
+ _parenthesized_expression_parser,
+ )(index, tokens)
+
+ if not success:
+ return failure
+
+ success, index, index_expression = _bracket_wrapped_parser(_expression_parser)(
+ index,
+ tokens,
+ )
+
+ if not success:
+ return failure
+
+ while success and index < len(tokens):
+ # "list_expression" is actually the full list item expression if the next parse attempt doesn't succeed
+ # We can't give this a better name without a bunch of checks, however.
+ list_expression = FurListItemExpression(
+ list_expression=list_expression,
+ index_expression=index_expression,
+ )
+
+ success, index, index_expression = _bracket_wrapped_parser(_expression_parser)(
+ index,
+ tokens,
+ )
+
+ return True, index, list_expression
+
def _function_call_expression_parser(index, tokens):
failure = (False, index, None)
return True, index, function
-_expression_parser = _or_level_expression_parser
+def _if_expression_parser(index, tokens):
+ failure = (False, index, None)
+
+ if tokens[index].match == 'if':
+ index += 1
+ else:
+ return failure
+
+ success, index, condition_expression = _or_level_expression_parser(index, tokens)
+
+ if not success:
+ raise Exception('Expected condition after "if" on line {}'.format(tokens[index].line))
+
+ if tokens[index].match == 'do':
+ index += 1
+ else:
+ raise Exception('Expected "do" after "if" on line {}'.format(tokens[index].line))
+
+
+ success, index, if_statement_list = _zero_or_more_parser(tuple, _statement_parser)(index, tokens)
+ _, index, _ = consume_newlines(index, tokens)
+
+ if tokens[index].match == 'else':
+ index += 1
+ success, index, else_statement_list = _zero_or_more_parser(tuple, _statement_parser)(index, tokens)
+ _, index, _ = consume_newlines(index, tokens)
+ else:
+ else_statement_list = ()
+
+ if tokens[index].match == 'end':
+ index += 1
+ else:
+ raise Exception('Expected "end" after "if" on line {}'.format(tokens[index].line))
+
+ return (
+ True,
+ index,
+ FurIfExpression(
+ condition_expression=condition_expression,
+ if_statement_list=if_statement_list,
+ else_statement_list=else_statement_list,
+ ),
+ )
+
+
+
+
+_expression_parser = _or_parser(
+ _or_level_expression_parser,
+ _if_expression_parser, # This should always be at the top level
+)
def _expression_statement_parser(index, tokens):
failure = (False, index, None)