You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
117 lines
4.9 KiB
117 lines
4.9 KiB
#!/usr/bin/env python3
|
|
import json
|
|
import sys
|
|
|
|
def find(needle: str, haystack: str) -> bool:
|
|
return haystack.find(needle) != -1
|
|
|
|
def parse_lparen(line: str) -> list:
|
|
tokens = list()
|
|
split_on_lparen = line.split('(')
|
|
name = split_on_lparen[0].strip()
|
|
if find('=', line):
|
|
name = name.split('=')[1].strip()
|
|
without_name = '('.join(split_on_lparen[1:])
|
|
split_on_rparen = without_name.split(')')
|
|
params_str = ')'.join(split_on_rparen[:-1])
|
|
params = list(map(str.strip,params_str.split(',')))
|
|
if name not in ['if', 'while']:
|
|
function_call = {"variant": "function_call", "value": name, "params": params, "line_number": lineno}
|
|
tokens.append(function_call)
|
|
elif name == "if":
|
|
conditional = {"variant": "conditional", "value": name, "condition": ','.join(params), "line_number": lineno}
|
|
tokens.append(conditional)
|
|
expression = {"variant": "start_block", "value": "{", "line_number": lineno}
|
|
tokens.append(expression)
|
|
else:
|
|
loop = {"variant": "loop", "value": name, "condition": ','.join(params), "line_number": lineno}
|
|
tokens.append(loop)
|
|
expression = {"variant": "start_block", "value": "{", "line_number": lineno}
|
|
tokens.append(expression)
|
|
return tokens
|
|
|
|
source: list = list()
|
|
program = './prog.mn'
|
|
if len(sys.argv) > 1:
|
|
program = sys.argv[1]
|
|
|
|
with open(program, 'r') as prog:
|
|
source = prog.readlines()
|
|
|
|
num_lines = len(source)
|
|
tokens = list()
|
|
for lineno in range(1, num_lines + 1):
|
|
line = source[lineno - 1].strip('\n')
|
|
split_on_colon = line.split(':')
|
|
colon_lhs = split_on_colon[0]
|
|
split_on_equals = line.split('=')
|
|
equals_lhs = split_on_equals[0]
|
|
if find(':', line):
|
|
colon_rhs = ':'.join(split_on_colon[1:])
|
|
colon_rhs_split_on_equals = colon_rhs.split('=')
|
|
colon_equals_lhs = colon_rhs_split_on_equals[0]
|
|
type = {"variant": "type", "value": colon_lhs.strip(), "line_number": lineno}
|
|
tokens.append(type)
|
|
operator = {"variant": "operator", "value": ':', "line_number": lineno}
|
|
tokens.append(operator)
|
|
signifier = {"variant": "signifier", "value": colon_equals_lhs.strip(), "line_number": lineno}
|
|
if colon_lhs.strip() == 'func':
|
|
split_on_lparen = colon_equals_lhs.strip().split('(')
|
|
name = split_on_lparen[0]
|
|
raw_params = list(map(str.strip,'('.join(split_on_lparen[1:]).split(',')))
|
|
params = list()
|
|
for raw in raw_params:
|
|
raw_split_on_colon = raw.split(':')
|
|
raw_split_on_rparen = raw_split_on_colon[1].split(')')
|
|
ptype = raw_split_on_colon[0].strip()
|
|
pname = raw_split_on_rparen[0].strip()
|
|
params.append({"type": ptype, "name": pname})
|
|
signifier = {"variant": "function_declaration", "value": name, "params": params, "line_number": lineno}
|
|
tokens.append(signifier)
|
|
if find('=', line):
|
|
expressions = list()
|
|
colon_equals_rhs = '='.join(colon_rhs_split_on_equals[1:])
|
|
operator = {"variant": "operator", "value": '=', "line_number": lineno}
|
|
tokens.append(operator)
|
|
expr = colon_equals_rhs.strip()
|
|
expressions.append({"variant": "expression", "value": expr, "line_number": lineno})
|
|
if expr == '{':
|
|
expressions[0] = {"variant": "start_block", "value": expr, "line_number": lineno}
|
|
elif find('(', line) and find(')', line):
|
|
expressions = parse_lparen(line)
|
|
for expression in expressions:
|
|
tokens.append(expression)
|
|
|
|
elif find('=', line):
|
|
equals_rhs = '='.join(split_on_equals[1:])
|
|
signifier = {"variant": "signifier", "value": equals_lhs.strip(), "line_number": lineno}
|
|
tokens.append(signifier)
|
|
operator = {"variant": "operator", "value": '=', "line_number": lineno}
|
|
tokens.append(operator)
|
|
expr = equals_rhs.strip()
|
|
expression = {"variant": "expression", "value": expr, "line_number": lineno}
|
|
if expr == '{':
|
|
expression = {"variant": "start_block", "value": expr, "line_number": lineno}
|
|
tokens.append(expression)
|
|
elif find('}',line):
|
|
expression = {"variant": "end_block", "value": '}', "line_number": lineno}
|
|
tokens.append(expression)
|
|
elif find('(', line):
|
|
for expression in parse_lparen(line):
|
|
tokens.append(expression)
|
|
elif find('return', line):
|
|
rhs = line.strip().split()[1]
|
|
expression = {"variant": "return", "value": rhs, "line_number": lineno}
|
|
tokens.append(expression)
|
|
else:
|
|
if line.strip() == '{':
|
|
expression = {"variant": "start_block", "value": '{', "line_number": lineno}
|
|
tokens.append(expression)
|
|
elif line != "":
|
|
error = {"variant": "syntax_error", "value": line, "line_number": lineno}
|
|
tokens.append(error)
|
|
print(json.dumps(tokens))
|
|
|
|
|
|
|