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)