def generateBuiltinFuncs():
builtin_functions = OrderedDict()
for f_id, f_list in BUILTIN_FUNCTIONS.items():
builtin_functions[(FunUniq.FUNC, f_id)] = []
for typesig_str, _ in f_list:
vals = typesig_str.split()
if vals[0] == '->':
from_types = []
to_type = abstractToConcreteType((vals[1]))
else:
from_types = abstractToConcreteType(vals[0])
to_type = abstractToConcreteType(vals[2])
builtin_functions[(FunUniq.FUNC, f_id)].append({
'type':
AST.FUNTYPE(from_types=[] if len(from_types) == 0 else
[AST.TYPE(val=from_types[0])],
to_type=AST.TYPE(val=to_type[0])),
'module':
BUILTINS_NAME,
'orig_id':
f_id,
'fixity':
None,
'kind':
FunKind.FUNC
})
return builtin_functions
def mergeCustomOps(op_table, symbol_table, module_name):
for x in symbol_table.functions:
f = symbol_table.functions[x]
if x[0] is FunUniq.INFIX:
if x[1] not in op_table['infix_ops']:
op_table['infix_ops'][x[1]] = (f[0]['def'].fixity.val,
f[0]['def'].kind, [])
for o in f:
if op_table['infix_ops'][x[1]][0] == o[
'def'].fixity.val and op_table['infix_ops'][
x[1]][1] == o['def'].kind:
ft = AST.FUNTYPE(from_types=[
o['type'].from_types[0].val,
o['type'].from_types[1].val
],
to_type=o['type'].to_type.val)
cnt = 0
for ot in op_table['infix_ops'][x[1]][2]:
if AST.equalVals(ft, ot):
cnt += 1
if cnt == 0:
op_table['infix_ops'][x[1]][2].append(
(ft, module_name))
else:
ERROR_HANDLER.addError(ERR.DuplicateOpDef,
[o['def'].id.val, o['def'].id])
else:
ERROR_HANDLER.addError(ERR.InconsistentOpDecl,
[o['def'].id.val, o['def'].id])
elif x[0] is FunUniq.PREFIX:
if x[1] not in op_table['prefix_ops']:
op_table['prefix_ops'][x[1]] = []
for o in f:
op_table['prefix_ops'][x[1]].append(
(AST.FUNTYPE(from_types=[o['type'].from_types[0].val],
to_type=o['type'].to_type.val), module_name))
def import_headers(json_string): # Can return exception, so put in try-except
load_packet = json.loads(json_string)
temp_packet = {}
temp_packet["depends"] = load_packet["depends"]
temp_packet["globals"] = OrderedDict([(k, parse_type(v))
for k, v in load_packet["globals"]])
temp_packet["typesyns"] = OrderedDict([
(k, parse_type(v)) for k, v in load_packet["typesyns"]
])
temp_packet["functions"] = OrderedDict()
for (uq, k), fix, kind, from_ts, to_t in load_packet["functions"]:
if (FunUniq[uq], k) not in temp_packet["functions"]:
temp_packet["functions"][(FunUniq[uq], k)] = []
temp_packet["functions"][(FunUniq[uq], k)].append({
"fixity":
fix,
"kind":
FunKind[kind],
"type":
AST.FUNTYPE(from_types=list(map(parse_type, from_ts)),
to_type=parse_type(to_t))
})
return temp_packet
def InfFunType():
a = yield Type
b = yield Type
yield ps.token(TOKEN.OP_IDENTIFIER, cond=(lambda x: x == "->"))
out = yield Type
return AST.FUNTYPE(from_types=[a, b], to_type=out)
def PreFunType():
a = yield Type
yield ps.token(TOKEN.OP_IDENTIFIER, cond=(lambda x: x == "->"))
b = yield Type
return AST.FUNTYPE(from_types=[a], to_type=b)
def FunType():
a = yield ps.many(Type)
yield ps.token(TOKEN.OP_IDENTIFIER, cond=(lambda x: x == "->"))
b = yield RetType
return AST.FUNTYPE(from_types=a, to_type=b)
def_type=AST.TYPE(val=AST.LISTTYPE(type=AST.TYPE(
val=AST.BASICTYPE(type_id=Token(
None, TOKEN.TYPE_IDENTIFIER, "Char")))))),
AST.FUNDECL(
kind=FunKind.INFIXL,
fixity=Token(None, TOKEN.INT, 4),
id=Token(None, TOKEN.OP_IDENTIFIER, "%%"),
params=[
Token(None, TOKEN.IDENTIFIER, "x"),
Token(None, TOKEN.IDENTIFIER, "y")
],
type=AST.FUNTYPE(from_types=[
AST.TYPE(val=AST.BASICTYPE(
type_id=Token(None, TOKEN.TYPE_IDENTIFIER, "Char"))),
AST.TYPE(val=AST.BASICTYPE(
type_id=Token(None, TOKEN.TYPE_IDENTIFIER, "Char")))
],
to_type=AST.TYPE(val=AST.BASICTYPE(
type_id=Token(None, TOKEN.TYPE_IDENTIFIER,
"Char")))),
vardecls=[],
stmts=[]),
AST.FUNDECL(kind=FunKind.INFIXL,
fixity=Token(None, TOKEN.INT, 4),
id=Token(None, TOKEN.OP_IDENTIFIER, "%%"),
params=[
Token(None, TOKEN.IDENTIFIER, "x"),
Token(None, TOKEN.IDENTIFIER, "y")
],
type=None,
vardecls=[],
def generateBuiltinOps():
op_table = OrderedDict()
for op_id in BUILTIN_INFIX_OPS:
op_table[(FunUniq.INFIX, op_id)] = []
for typesig_str in BUILTIN_INFIX_OPS[op_id][0]:
#print(typesig_str)
first_type, second_type, _, output_type = typesig_str.split()
first_types = abstractToConcreteType(first_type)
second_types = abstractToConcreteType(second_type)
output_types = abstractToConcreteType(output_type)
for ft in first_types:
for st in second_types:
for ot in output_types:
if len(first_types) == len(second_types) == len(
BASIC_TYPES):
if AST.equalVals(ft, st) or (
type(st) == AST.LISTTYPE
and AST.equalVals(ft, st.type.val)
and AST.equalVals(ft, ot.type.val)):
op_table[(FunUniq.INFIX, op_id)].append({
'type':
AST.FUNTYPE(from_types=[
AST.TYPE(val=ft),
AST.TYPE(val=st)
],
to_type=AST.TYPE(val=ot)),
'module':
BUILTINS_NAME,
'orig_id':
op_id,
'fixity':
BUILTIN_INFIX_OPS[op_id][1],
'kind':
BUILTIN_INFIX_OPS[op_id][2]
})
else:
op_table[(FunUniq.INFIX, op_id)].append({
'type':
AST.FUNTYPE(from_types=[
AST.TYPE(val=ft),
AST.TYPE(val=st)
],
to_type=AST.TYPE(val=ot)),
'module':
BUILTINS_NAME,
'orig_id':
op_id,
'fixity':
BUILTIN_INFIX_OPS[op_id][1],
'kind':
BUILTIN_INFIX_OPS[op_id][2]
})
for op_id, (typesig_str, _) in BUILTIN_PREFIX_OPS.items():
op_table[(FunUniq.PREFIX, op_id)] = []
in_type, _, out_type = typesig_str.split()
in_type_node = abstractToConcreteType(in_type)
out_type_node = abstractToConcreteType(out_type)
for in_t in in_type_node:
for out_t in out_type_node:
op_table[(FunUniq.PREFIX, op_id)].append({
'type':
AST.FUNTYPE(from_types=[AST.TYPE(val=in_t)],
to_type=AST.TYPE(val=out_t)),
'module':
BUILTINS_NAME,
'orig_id':
op_id[0],
'fixity':
None,
'kind':
FunKind.PREFIX
})
return op_table
