def generate(self, element:Element, GC:GenerationContext):
assert len(element.code) > 1
asts = [Quote.generate_quote_ast(subcode, GC) for subcode in element.code[1:]]
if len(asts) == 1:
return expr_wrap(asts[0], GC)
else:
return expr_wrap(ast.List(asts, ast.Load()), GC)
def generate(self, element: Element, GC: GenerationContext):
assert len(element.code) > 1
asts = [
Quote.generate_quote_ast(subcode, GC)
for subcode in element.code[1:]
]
if len(asts) == 1:
return expr_wrap(asts[0], GC)
else:
return expr_wrap(ast.List(asts, ast.Load()), GC)
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
operand_element = acode[1]
with GC.let(domain=ExDom):
operand_code = GC.generate(operand_element)
return expr_wrap(ast.UnaryOp(self.OP(), operand_code), GC)
def generate(self, element: Element, GC: GenerationContext):
acode = element.code
operand_element = acode[1]
with GC.let(domain=ExDom):
operand_code = GC.generate(operand_element)
return expr_wrap(ast.UnaryOp(self.OP(), operand_code), GC)
def generate(self, element: Element, GC: GenerationContext):
acode = element.code
left_element, right_element = acode[1], acode[2]
with GC.let(domain=ExDom):
left_code = GC.generate(left_element)
right_code = GC.generate(right_element)
return expr_wrap(ast.BinOp(left_code, self.OP(), right_code), GC)
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
left_element, right_element = acode[1], acode[2]
with GC.let(domain=ExDom):
left_code = GC.generate(left_element)
right_code = GC.generate(right_element)
return expr_wrap(ast.BinOp(left_code, self.OP(), right_code), GC)
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
if len(acode) is 2 and is_form(acode[1], "for"):
for_form = acode[1].code
# list comprehension
# («[]» (for (in i lst) (f i))) # list compr
in_el = for_form[1]
in_el_code = in_el.code
#with GC.let(domain=ExDom):
assert is_identifier(in_el, "in")
target_element = in_el_code[1]
iter_element = in_el_code[2]
with GC.let(domain=LVDom):
target_code = GC.generate(target_element)
with GC.let(domain=ExDom):
iter_code = GC.generate(iter_element)
generators = [ ast.comprehension(target=target_code,
iter=iter_code,
ifs=[]) ]
to_evaluate_element = for_form[2]
with GC.let(domain=ExDom):
to_evaluate_code = GC.generate(to_evaluate_element)
return ast.ListComp(to_evaluate_code, generators)
else:
els = self.generate_as_expressions(GC, *acode[1:])
if GC.domain == LVDom:
return ast.List(els, ast.Store())
return expr_wrap(ast.List(els, ast.Load()), GC)
def generate(self, element:Element, GC:GenerationContext):
self.precheck(element, GC)
head_name = element.code[0].code.name
if not is_form(element.prev) or not identifier_in(element.prev.code[0], self.expected_names):
raise CodeGenerationError(element.code[0].range, "`%s` form must appear after %s." % (head_name, self.expected_names))
if GC.domain == ExpressionDomain:
return expr_wrap(ast.NameConstant(None), GC)
else:
return []
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
if len(acode) == 2:
arg = acode[1]
with GC.let(domain=ExDom):
arg_code = GC.generate(arg)
return expr_wrap(ast.UnaryOp(op=ast.USub(), operand=arg_code), GC)
else:
assert len(acode) == 3
left_element, right_element = acode[1], acode[2]
with GC.let(domain=ExDom):
left_code = GC.generate(left_element)
right_code = GC.generate(right_element)
return expr_wrap(ast.BinOp(left_code, ast.Sub(), right_code), GC)
def generate(self, element: Element, GC: GenerationContext):
acode = element.code
if len(acode) == 2:
arg = acode[1]
with GC.let(domain=ExDom):
arg_code = GC.generate(arg)
return expr_wrap(ast.UnaryOp(op=ast.USub(), operand=arg_code), GC)
else:
assert len(acode) == 3
left_element, right_element = acode[1], acode[2]
with GC.let(domain=ExDom):
left_code = GC.generate(left_element)
right_code = GC.generate(right_element)
return expr_wrap(ast.BinOp(left_code, ast.Sub(), right_code), GC)
def generate(self, element:Element, GC:GenerationContext):
self.precheck(element, GC)
acode = element.code
if len(acode) == 1:
return ast.Return(None)
else:
assert len(acode) == 2
# TODO: return a, b, c => tuple
with GC.let(domain=ExpressionDomain):
expression_code = GC.generate(acode[1])
return expr_wrap(ast.Yield(expression_code), GC)
def generate(self, element: Element, GC: GenerationContext):
self.precheck(element, GC)
head_name = element.code[0].code.name
if not is_form(element.prev) or not identifier_in(
element.prev.code[0], self.expected_names):
raise CodeGenerationError(
element.code[0].range, "`%s` form must appear after %s." %
(head_name, self.expected_names))
if GC.domain == ExpressionDomain:
return expr_wrap(ast.NameConstant(None), GC)
else:
return []
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
with GC.let(domain=ExDom):
base_object_code = GC.generate(acode[1])
att_name = acode[2].code.full_name
if GC.domain == LValueDomain:
return ast.Attribute(base_object_code, att_name, ast.Store())
elif GC.domain == DeletionDomain:
return ast.Attribute(base_object_code, att_name, ast.Del())
else:
return expr_wrap(ast.Attribute(base_object_code, att_name, ast.Load()), GC)
def generate(self, element: Element, GC: GenerationContext):
acode = element.code
#assert isinstance(acode, Form)
# if acode[0].code.full_name == "and":
# op = ast.And()
# else:
# assert acode[0].code.full_name == "or"
# op = ast.Or()
juncts_code = []
with GC.let(domain=ExDom):
for e in acode[1:]:
juncts_code.append(GC.generate(e))
return expr_wrap(ast.BoolOp(self.OP(), juncts_code), GC)
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
#assert isinstance(acode, Form)
# if acode[0].code.full_name == "and":
# op = ast.And()
# else:
# assert acode[0].code.full_name == "or"
# op = ast.Or()
juncts_code = []
with GC.let(domain=ExDom):
for e in acode[1:]:
juncts_code.append(GC.generate(e))
return expr_wrap(ast.BoolOp(self.OP(), juncts_code), GC)
def generate(self, element: Element, GC: GenerationContext):
acode = element.code
with GC.let(domain=ExDom):
base_object_code = GC.generate(acode[1])
att_name = acode[2].code.full_name
if GC.domain == LValueDomain:
return ast.Attribute(base_object_code, att_name, ast.Store())
elif GC.domain == DeletionDomain:
return ast.Attribute(base_object_code, att_name, ast.Del())
else:
return expr_wrap(
ast.Attribute(base_object_code, att_name, ast.Load()), GC)
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
with GC.let(domain=ExDom):
base_object_code = GC.generate(acode[1])
# (.. )
if is_form(acode[2], ".."):
#slice
raise NotImplementedError()
#if isinstance(acode[2].code, Literal):
else:
with GC.let(domain=ExDom):
index_code = GC.generate(acode[2])
return expr_wrap(ast.Subscript(base_object_code,
ast.Index(index_code),
ast.Store() if GC.domain == LVDom else ast.Load()), GC)
def generate(self, element:Element, GC:GenerationContext):
self.precheck(element, GC)
acode = element.code
operands_seq = acode.last.code
first_operand = operands_seq[0]
with GC.let(domain = ExpressionDomain):
first_operand_gen = GC.generate(first_operand)
ops = [self.OPERAND_DICT[e.code.name]() for e in acode[1:-1]]
comparators = [GC.generate(operand) for operand in operands_seq.iterate_from(1)]
return expr_wrap(
ast.Compare(
left = first_operand_gen,
ops = ops,
comparators = comparators
), GC)
def generate(self, element: Element, GC: GenerationContext):
self.precheck(element, GC)
acode = element.code
operands_seq = acode.last.code
first_operand = operands_seq[0]
with GC.let(domain=ExpressionDomain):
first_operand_gen = GC.generate(first_operand)
ops = [self.OPERAND_DICT[e.code.name]() for e in acode[1:-1]]
comparators = [
GC.generate(operand)
for operand in operands_seq.iterate_from(1)
]
return expr_wrap(
ast.Compare(left=first_operand_gen,
ops=ops,
comparators=comparators), GC)
def generate(self, element, GC: GenerationContext):
from anoky.generation.util import expr_wrap
acode = element.code
if isinstance(acode, Form):
head = acode.first
headcode = head.code
if isinstance(
headcode,
Identifier) and headcode.full_name in GC.special_forms:
head.color = colors.SPECIAL_FORM
hcname = headcode.full_name
special_form = GC.special_forms[hcname]
generated_code = special_form.generate(element, GC)
return generated_code
else:
# function call
# #(func arg1 arg2 arg3 ...)
func_element = head
#func_element_code = headcode
with GC.let(domain=ExDom):
func_code = GC.generate(func_element)
arg_elements = acode[1:]
args = []
keywords = []
for arg_element in arg_elements:
arg_element_code = arg_element.code
if isinstance(arg_element_code, Form):
if is_form(arg_element_code, '='):
# keyword argument
kw_name = arg_element_code[1].code.full_name
with GC.let(domain=ExDom):
value_code = GC.generate(arg_element_code[2])
keywords.append(ast.keyword(kw_name, value_code))
elif is_form(arg_element_code,
'*') and len(arg_element_code) == 2:
# stared argument - expand as list
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element_code[1])
args.append(ast.Starred(arg_code, ast.Load()))
elif is_form(arg_element_code,
'**') and len(arg_element_code) == 2:
# double starred argument - expand as kwlist
assert len(arg_element_code) == 2
# verify no other dblstars already?
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element_code[1])
keywords.append(ast.keyword(None, arg_code))
else:
# positional argument
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element)
args.append(arg_code)
else:
# arg_element_code not a Form
# then generate as expression
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element)
args.append(arg_code)
return expr_wrap(ast.Call(func_code, args, keywords), GC)
if isinstance(acode, Seq):
seq_codes = []
with GC.let(domain=ExDom):
for e in acode:
seq_codes.append(GC.generate(e))
if GC.domain == LVDom:
return ast.Tuple(seq_codes, ast.Store())
elif GC.domain in [ExDom, SDom]:
return expr_wrap(ast.Tuple(seq_codes, ast.Load()), GC)
else:
raise CodeGenerationError(
acode.range,
"Unexpected seq in domain `%s`." % str(GC.domain))
if isinstance(acode, Literal):
element.color = colors.LITERAL
if acode.type is str:
return expr_wrap(ast.Str(acode.value), GC)
elif acode.type in [int, float]:
return expr_wrap(ast.Num(acode.value), GC)
else:
assert False
if isinstance(acode, Identifier):
if acode.full_name == "True":
return expr_wrap(ast.NameConstant(True), GC)
elif acode.full_name == "False":
return expr_wrap(ast.NameConstant(False), GC)
elif acode.full_name == "None":
return expr_wrap(ast.NameConstant(None), GC)
elif acode.full_name in GC.special_forms:
element.color = colors.SPECIAL_FORM
raise CodeGenerationError(
acode.range,
"Refering to special form `%s` by name requires the use of `the`."
% acode.full_name)
# elif acode.full_name in GC.macros:
# raise CodeGenerationError(acode.range,
# "Refering to macro `%s` by name requires the use of `the`." % acode.full_name)
# elif acode.full_name in GC.id_macros:
# raise CodeGenerationError(acode.range,
# "Refering to identifier macro `%s` by name requires the use of `the`." % acode.full_name)
elif GC.domain == LVDom:
return ast.Name(acode.full_name, ast.Store())
elif GC.domain == DelDom:
return ast.Name(acode.full_name, ast.Del())
else:
return expr_wrap(ast.Name(acode.full_name, ast.Load()), GC)
def generate(self, element, GC:GenerationContext):
from anoky.generation.util import expr_wrap
acode = element.code
if isinstance(acode, Form):
head = acode.first
headcode = head.code
if isinstance(headcode, Identifier) and headcode.full_name in GC.special_forms:
head.color = colors.SPECIAL_FORM
hcname = headcode.full_name
special_form = GC.special_forms[hcname]
generated_code = special_form.generate(element, GC)
return generated_code
else:
# function call
# #(func arg1 arg2 arg3 ...)
func_element = head
#func_element_code = headcode
with GC.let(domain=ExDom):
func_code = GC.generate(func_element)
arg_elements = acode[1:]
args = []
keywords = []
for arg_element in arg_elements:
arg_element_code = arg_element.code
if isinstance(arg_element_code, Form):
if is_form(arg_element_code, '='):
# keyword argument
kw_name = arg_element_code[1].code.full_name
with GC.let(domain=ExDom):
value_code = GC.generate(arg_element_code[2])
keywords.append(ast.keyword(kw_name, value_code))
elif is_form(arg_element_code, '*') and len(arg_element_code) == 2:
# stared argument - expand as list
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element_code[1])
args.append(ast.Starred(arg_code, ast.Load()))
elif is_form(arg_element_code, '**') and len(arg_element_code) == 2:
# double starred argument - expand as kwlist
assert len(arg_element_code) == 2
# verify no other dblstars already?
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element_code[1])
keywords.append(ast.keyword(None, arg_code))
else:
# positional argument
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element)
args.append(arg_code)
else:
# arg_element_code not a Form
# then generate as expression
with GC.let(domain=ExDom):
arg_code = GC.generate(arg_element)
args.append(arg_code)
return expr_wrap(ast.Call(func_code, args, keywords), GC)
if isinstance(acode, Seq):
seq_codes = []
with GC.let(domain=ExDom):
for e in acode:
seq_codes.append(GC.generate(e))
if GC.domain == LVDom:
return ast.Tuple(seq_codes, ast.Store())
elif GC.domain in [ExDom, SDom]:
return expr_wrap(ast.Tuple(seq_codes, ast.Load()), GC)
else:
raise CodeGenerationError(acode.range, "Unexpected seq in domain `%s`." % str(GC.domain))
if isinstance(acode, Literal):
element.color = colors.LITERAL
if acode.type is str:
return expr_wrap(ast.Str(acode.value), GC)
elif acode.type in [int, float]:
return expr_wrap(ast.Num(acode.value), GC)
else:
assert False
if isinstance(acode, Identifier):
if acode.full_name == "True":
return expr_wrap(ast.NameConstant(True), GC)
elif acode.full_name == "False":
return expr_wrap(ast.NameConstant(False), GC)
elif acode.full_name == "None":
return expr_wrap(ast.NameConstant(None), GC)
elif acode.full_name in GC.special_forms:
element.color = colors.SPECIAL_FORM
raise CodeGenerationError(acode.range, "Refering to special form `%s` by name requires the use of `the`." % acode.full_name)
# elif acode.full_name in GC.macros:
# raise CodeGenerationError(acode.range,
# "Refering to macro `%s` by name requires the use of `the`." % acode.full_name)
# elif acode.full_name in GC.id_macros:
# raise CodeGenerationError(acode.range,
# "Refering to identifier macro `%s` by name requires the use of `the`." % acode.full_name)
elif GC.domain == LVDom:
return ast.Name(acode.full_name, ast.Store())
elif GC.domain == DelDom:
return ast.Name(acode.full_name, ast.Del())
else:
return expr_wrap(ast.Name(acode.full_name, ast.Load()), GC)
def generate(self, element:Element, GC:GenerationContext):
acode = element.code
head = acode[0].code
assert isinstance(head, Identifier)
headtext = head.full_name
if len(acode) is 2 and is_form(acode[1].code, "for"):
ccode = acode[1].code
assert len(ccode) == 3
target_iter_element = ccode[1]
expr_element = ccode[2]
with GC.let(domain=LVDom):
target_code = GC.generate(target_iter_element.code[1])
with GC.let(domain=ExDom):
iter_code = GC.generate(target_iter_element.code[2])
comp_code = ast.comprehension(target=target_code,
iter=iter_code,
ifs=[])
if is_form(expr_element.code, "="):
# dict comp
key_code = GC.generate(expr_element.code[1])
value_code = GC.generate(expr_element.code[2])
return ast.DictComp(key=key_code, value=value_code,
generators=[comp_code])
else:
# set comp
elt_code = GC.generate(expr_element)
return ast.SetComp(elt=elt_code, generators=[comp_code])
else:
if len(acode) is 1:
return ast.Dict([], [])
if all([is_form(i.code, "=") for i in acode[1:]]):
#dict
keys = []
values = []
with GC.let(domain=ExDom):
for kvpair_el in acode[1:]:
kvpair = kvpair_el.code
key_code = GC.generate(kvpair[1])
value_code = GC.generate(kvpair[2])
keys.append(key_code)
values.append(value_code)
return expr_wrap(ast.Dict(keys, values), GC)
else:
#set
el_codes = self.generate_as_expressions(GC, *acode[1:])
return expr_wrap(ast.Set(el_codes), GC)
