コード例 #1
0
    def generate(self, element: Element, GC: GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        target_iter_element = acode[1]
        target_element = target_iter_element.code[0]
        iter_element = target_iter_element.code[1]

        with GC.let(domain=LValueDomain):
            target_code = GC.generate(target_element)

        with GC.let(domain=ExpressionDomain):
            iter_code = GC.generate(iter_element)

        if is_form(acode.last, "else"):
            raise NotImplementedError()

        body_codes = []
        for e in acode[2:]:
            extend_body(body_codes, GC.generate(e))

        return ast.For(
            target=target_code,
            iter=iter_code,
            body=body_codes,
            orelse=[],
        )
コード例 #2
0
ファイル: for.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        target_iter_element = acode[1]
        target_element = target_iter_element.code[0]
        iter_element = target_iter_element.code[1]

        with GC.let(domain=LValueDomain):
            target_code = GC.generate(target_element)

        with GC.let(domain=ExpressionDomain):
            iter_code = GC.generate(iter_element)

        if is_form(acode.last, "else"):
            raise NotImplementedError()

        body_codes = []
        for e in acode[2:]:
            extend_body(body_codes, GC.generate(e))


        return ast.For(target=target_code,
                      iter=iter_code,
                      body=body_codes,
                      orelse=[],
                      )
コード例 #3
0
ファイル: class.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        acode = element.code


        #name
        spec = acode[1]
        if isinstance(spec.code, Form):
            assert is_identifier(spec.code[0])
            class_name = spec.code[0].code.full_name

            with GC.let(domain=ExDom):
                base_classes_codes = []

                for base_class in spec.code[1:]:
                    extend_body(base_classes_codes, GC.generate(base_class))

        elif isinstance(spec.code, Identifier):
            class_name = spec.code.full_name
            base_classes_codes = []

        #keywords

        # "class keyword(arg, value)
        #  A keyword argument to a function call or class definition.
        #  arg is a raw string of the parameter name, value is a node to pass in."

        #starargs

        #kwargs


        body_elements = acode[3:]

        assert len(body_elements) > 0

        body_codes = []

        with GC.let(domain=StatementDomain):
            for body_statement in body_elements:
                extend_body(body_codes, GC.generate(body_statement))







        return ast.ClassDef(name=class_name,
                            bases=base_classes_codes,
                            keywords=[],
                            #starargs
                            #kwargs
                            body=body_codes,
                            decorator_list=[]
                            )
コード例 #4
0
    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)
コード例 #5
0
ファイル: operators.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #6
0
ファイル: containers.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #7
0
    def generate(self, element: Element, GC: GenerationContext):

        acode = element.code

        #name
        spec = acode[1]
        if isinstance(spec.code, Form):
            assert is_identifier(spec.code[0])
            class_name = spec.code[0].code.full_name

            with GC.let(domain=ExDom):
                base_classes_codes = []

                for base_class in spec.code[1:]:
                    extend_body(base_classes_codes, GC.generate(base_class))

        elif isinstance(spec.code, Identifier):
            class_name = spec.code.full_name
            base_classes_codes = []

        #keywords

        # "class keyword(arg, value)
        #  A keyword argument to a function call or class definition.
        #  arg is a raw string of the parameter name, value is a node to pass in."

        #starargs

        #kwargs

        body_elements = acode[3:]

        assert len(body_elements) > 0

        body_codes = []

        with GC.let(domain=StatementDomain):
            for body_statement in body_elements:
                extend_body(body_codes, GC.generate(body_statement))

        return ast.ClassDef(
            name=class_name,
            bases=base_classes_codes,
            keywords=[],
            #starargs
            #kwargs
            body=body_codes,
            decorator_list=[])
コード例 #8
0
ファイル: lambda.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        assert GC.domain == ExDom

        acode = element.code
        #assert len(acode) == 3

        with GC.let(domain=ExDom):
            expression_code = GC.generate(acode[2])


        # INCOMPLETE:
        # vararg, kwarg, defaults, kw_defaults
        #
        # - This whole arg section might be way off-track
        # - since anything could be an argument, we might need to check
        #   when generating any expression if we actually need to return an ast.arg object
        #   ..or, could we convert everything (e.g. ast.Name, ast.BoolOp, anything)
        #   to an ast.arg after it's been generated

        args_codes = []
        #with GC.let(domain=ArgDom):
            # for a in acode[1]:
            #     # args_code should be a list of ast.arg objects!
            #     args_codes.append(GC.generate(a))




        arguments_code = ast.arguments(args_codes, )


        return ast.Lambda(arguments_code, expression_code)
コード例 #9
0
ファイル: def.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):


        acode = element.code

        func_specs = acode[1].code

        assert isinstance(func_specs[0].code, Identifier)

        function_name = func_specs[0].code.full_name

        arguments = self.generate_arguments(*func_specs[1:], GC=GC)

        body_elements = acode[2:]

        body_code = []
        with GC.let(domain=SDom):
            for body_element in body_elements:
                extend_body(body_code, GC.generate(body_element))

        decorators_code = []

        returns_code = None

        return ast.FunctionDef(function_name, arguments, body_code,
                               decorators_code, returns_code)
コード例 #10
0
ファイル: quote.py プロジェクト: bloff/rmtc-parsing
    def generate_quote_ast(element:Element, GC:GenerationContext):

        # allow passing code instead of element?

        acode = element.code


        if isinstance(acode, Form) and is_identifier(acode[0], "~"):

            assert len(acode) == 2

            with GC.let(domain=ExpressionDomain):
                literal_value = GC.generate(acode[1])

            a = ast.Call(func=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                            attr="force_literal",
                                            ctx=ast.Load()),
                         args=[literal_value],
                         keywords=[])

            return a


        elif isinstance(acode, Form) or isinstance(acode, Seq):

            #return __aky__.Form(*[akycode_to_ast(e) for e in acode])

            children_ast = [Quote.generate_quote_ast(e, GC) for e in acode]

            a = ast.Call(func=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                            attr="Form" if isinstance(acode, Form) else "Seq",
                                            ctx=ast.Load()),
                         args=children_ast,
                         keywords=[])

            return a


        elif isinstance(acode, Identifier):

            return ast.Call(func=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                            attr="Identifier", ctx=ast.Load()),
                            args=[ast.Str(acode.full_name)],
                            keywords=[])

        else:

            assert isinstance(acode, Literal)

            if acode.type is str:
                value_code = ast.Str(acode.value)
            else:
                assert acode.type in [int, float]
                value_code = ast.Num(acode.value)

            return ast.Call(func=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                            attr="Literal", ctx=ast.Load()),
                            args=[value_code,
                                  ast.Name(id=acode.type.__name__, ctx=ast.Load())],
                            keywords=[])
コード例 #11
0
ファイル: assert.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element: Element, GC: GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        test_element = acode[1]

        with GC.let(domain=ExDom):

            test_code = GC.generate(test_element)

            msg_code = None
            if len(acode) > 2:
                msg_element = acode[2]
                msg_code = GC.generate(msg_element)

        return ast.Assert(test=test_code, msg=msg_code)
コード例 #12
0
ファイル: with.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        acode = element.code

        context_element = acode[1]
        context_element_code = context_element.code
        assert len(context_element_code) > 0

        with_items = []

        with GC.let(domain=ExpressionDomain):

            for ctxel in context_element_code:


                if is_form(ctxel.code, "as"):

                    ctxelcode = ctxel.code

                    assert len(ctxel) == 3
                    ctx_expr = GC.generate(ctxelcode[1])

                    opt_var = GC.generate(ctxelcode[2])

                    with_items.append(ast.withitem(context_expr=ctx_expr,
                                                   optional_vars=opt_var))

                else:

                    ctx_expr = GC.generate(ctxel)

                    with_items.append(ast.withitem(context_expr=ctx_expr,
                                                   optional_vars=None))

            body_items = []

            with GC.let(domain=SDom):

                for bodyel in acode[2:]:
                    extend_body(body_items, GC.generate(bodyel))


        return ast.With(items=with_items,
                        body=body_items)
コード例 #13
0
ファイル: operators.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #14
0
    def generate(self, element: Element, GC: GenerationContext):

        acode = element.code

        context_element = acode[1]
        context_element_code = context_element.code
        assert len(context_element_code) > 0

        with_items = []

        with GC.let(domain=ExpressionDomain):

            for ctxel in context_element_code:

                if is_form(ctxel.code, "as"):

                    ctxelcode = ctxel.code

                    assert len(ctxel) == 3
                    ctx_expr = GC.generate(ctxelcode[1])

                    opt_var = GC.generate(ctxelcode[2])

                    with_items.append(
                        ast.withitem(context_expr=ctx_expr,
                                     optional_vars=opt_var))

                else:

                    ctx_expr = GC.generate(ctxel)

                    with_items.append(
                        ast.withitem(context_expr=ctx_expr,
                                     optional_vars=None))

            body_items = []

            with GC.let(domain=SDom):

                for bodyel in acode[2:]:
                    extend_body(body_items, GC.generate(bodyel))

        return ast.With(items=with_items, body=body_items)
コード例 #15
0
ファイル: containers.py プロジェクト: bloff/rmtc-parsing
    def generate_as_expressions(GC:GenerationContext, *args:Element):

        expr_codes = []

        with GC.let(domain=ExDom):

            for arg_element in args:
                expr_codes.append(GC.generate(arg_element))

        return expr_codes
コード例 #16
0
    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)
コード例 #17
0
ファイル: assert.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        test_element = acode[1]

        with GC.let(domain=ExDom):

            test_code = GC.generate(test_element)

            msg_code = None
            if len(acode) > 2:
                msg_element = acode[2]
                msg_code = GC.generate(msg_element)


        return ast.Assert(test=test_code, msg=msg_code)
コード例 #18
0
ファイル: assign.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        acode = element.code

        assert len(acode) == 3
        # target_element = acode[1]
        # augvalue_element = acode[2]

        with GC.let(domain=LVDom):
            # "target can be Name, Subscript or Attribute,
            #  but not a Tuple or List (unlike the targets of Assign)."

            target_code = GC.generate(acode[1])

        with GC.let(domain=ExDom):
            augvalue_code = GC.generate(acode[2])


        return ast.AugAssign(target_code, type(self).OP(), augvalue_code)
コード例 #19
0
ファイル: containers.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #20
0
    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)
コード例 #21
0
ファイル: operators.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #22
0
ファイル: while.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        testexpr_element = acode[1]

        with GC.let(domain=ExpressionDomain):

            testexpr_code = GC.generate(testexpr_element)

        if is_form(element.next, "else"):
            raise NotImplementedError()

        body_codes = []
        for e in acode[2:]:
            extend_body(body_codes, GC.generate(e))

        return ast.While(test=testexpr_code,
                         body=body_codes,
                         orelse=[])
コード例 #23
0
ファイル: comparison.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #24
0
    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)
コード例 #25
0
    def generate(self, element:Element, GC:GenerationContext):

        acode = element.code
        #assert isinstance(acode, Form)

        if len(acode) > 1:
            with GC.let(domain=ExDom):
                exception_obj_code = GC.generate(acode[1])

            return ast.Raise(exception_obj_code, None) # Fix none to allow raise x from y syntax

        else:
            assert len(acode) == 1
            return ast.Raise()
コード例 #26
0
ファイル: assign.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        targets_element = acode[1]
        value_element = acode.last


        # if not isinstance(targets, Seq):
        #     # targets is only one target
        #
        #     with GC.let(domain=LVDom):
        #         target_code = GC.generate(targets)

        with GC.let(domain=LVDom):
            targets_code = GC.generate(targets_element)

        with GC.let(domain=ExDom):
            value_code = GC.generate(value_element)


        return ast.Assign(targets=[targets_code], value=value_code)
コード例 #27
0
ファイル: yield.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #28
0
    def generate(self, element: Element, GC: GenerationContext):

        assert GC.domain == SDom

        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 ast.Return(expression_code)
コード例 #29
0
ファイル: return.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        assert GC.domain == SDom

        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 ast.Return(expression_code)
コード例 #30
0
ファイル: attribute.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #31
0
ファイル: attribute.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #32
0
ファイル: operators.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #33
0
    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)
コード例 #34
0
ファイル: containers.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #35
0
ファイル: def.py プロジェクト: bloff/rmtc-parsing
    def generate_arguments(self, *params, GC:GenerationContext):

        poststar = False

        argslist = []
        kwonlyargslist = []
        vararg = None
        kwarg = None
        defaults = []
        kw_defaults = []

        for param_element in params:

            param_code = param_element.code

            if isinstance(param_code, Identifier) and param_code.full_name == '*':

                poststar = True


            elif isinstance(param_code, Identifier):
                # arg

                arg_object = ast.arg(arg=param_code.full_name, annotation=None)

                #if self.vararg is not None or self.kwarg is not None:
                if poststar:
                    # argument is keyword-only

                    kwonlyargslist.append(arg_object)

                else:

                    assert not poststar

                    argslist.append(arg_object)



            elif isinstance(param_code, Form):

                #assert isinstance(param_code[0].code, Identifier) and
                if param_code[0].code.full_name == '=':
                    # (= arg initializer)

                    assert len(param_code) == 3

                    with GC.let(domain=ExDom):
                        initializer_code = GC.generate(param_code[2])

                    assert isinstance(param_code[1].code, Identifier)
                    arg_object = ast.arg(arg=param_code[1].code.full_name, annotation=None)

                    if poststar:

                        kwonlyargslist.append(arg_object)
                        kw_defaults.append(initializer_code)

                    else:

                        argslist.append(arg_object)
                        defaults.append(initializer_code)


                elif param_code[0].code.full_name == '*':
                    # (* arg)

                    #assert isinstance(param_code[1].code, Identifier)

                    starg = ast.arg(arg=param_code[1].code.full_name, annotation=None)

                    assert vararg is None

                    vararg = starg

                    poststar = True




                else:
                    assert param_code[0].code.full_name == '**'
                    # (** arg)

                    #assert isinstance(param_code[1].code, Identifier)

                    dblstarg = ast.arg(arg=param_code[1].code.full_name, annotation=None)

                    assert kwarg is None

                    kwarg = dblstarg

                    poststar = True





            else:
                # (type, arg)
                # (type, (= arg initializer))
                # (type, (* arg))
                # (type, (** arg))

                #assert isinstance(param_code, Seq)

                annotation_element = param_code[0]

                # if isinstance(annotation_code, Identifier):
                #     annotation = ast.Name(id=annotation_code.full_name, ctx=ast.Load())
                #
                # elif isinstance(annotation_code, Literal):
                #     annotation =

                with GC.let(domain=ExDom):
                    annotation_code = GC.generate(annotation_element)

                # and now the arg itself..

                param_code = param_code[1].code

                if isinstance(param_code, Identifier):

                    #assert param_code.full_name != '*'

                    arg_object = ast.arg(arg=param_code.full_name, annotation=annotation_code)

                    if poststar:

                        kwonlyargslist.append(arg_object)

                    else:

                        argslist.append(arg_object)


                else:

                    assert isinstance(param_code, Form)

                    #assert isinstance(param_code[0].code, Identifier) and
                    if param_code[0].code.full_name == '=':
                        # (= arg initializer)

                        assert len(param_code) == 3

                        with GC.let(domain=ExDom):
                            initializer_code = GC.generate(param_code[2])

                        assert isinstance(param_code[1].code, Identifier)
                        arg_object = ast.arg(arg=param_code[1].full_name, annotation=annotation_code)

                        if poststar:

                            kwonlyargslist.append(arg_object)
                            kw_defaults.append(initializer_code)

                        else:

                            argslist.append(arg_object)
                            defaults.append(initializer_code)





                    elif param_code[0].code.full_name == '*':
                        # (* arg)

                        #assert isinstance(param_code[1].code, Identifier)

                        starg = ast.arg(arg=param_code[1].code.full_name, annotation=annotation_code)

                        assert vararg is None

                        vararg = starg

                        poststar = True




                    else:
                        assert param_code[0].code.full_name == '**'
                        # (** arg)

                        #assert isinstance(param_code[1].code, Identifier)

                        dblstarg = ast.arg(arg=param_code[1].code.full_name, annotation=annotation_code)

                        assert kwarg is None

                        kwarg = dblstarg

                        poststar = True





        return ast.arguments(args=argslist, vararg=vararg, kwonlyargs=kwonlyargslist,
                             kwarg=kwarg, defaults=defaults, kw_defaults=kw_defaults)
コード例 #36
0
ファイル: generator.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #37
0
ファイル: try.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element: Element, GC: GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        # "Check that form is as above"
        #assert

        def gen_except_handler(except_elm):
            my_code = except_elm.code
            exception_elm = my_code[1]
            name = None
            if is_form(exception_elm, 'as'):
                with GC.let(domain=ExpressionDomain):
                    my_exception_type = GC.generate(exception_elm.code[1])
                my_exception_name_id = exception_elm.code[2]
                if not is_identifier(my_exception_name_id):
                    raise CodeGenerationError(
                        my_exception_name_id.range,
                        "Expected an identifier as exception name of `except` clause in `try` special-form."
                    )
                name = my_exception_name_id.code.name
            else:
                with GC.let(domain=ExpressionDomain):
                    my_exception_type = GC.generate(exception_elm)

            body_gens = []
            for my_body_elm in my_code.iterate_from(2):
                extend_body(body_gens, GC.generate(my_body_elm))

            return ast.ExceptHandler(my_exception_type, name, body_gens)

        body_gens, handlers, or_else, finally_body = [], [], None, None
        stage = 0  # 0 = body, 1 = except, 2 = else, 3 = finally
        names = {1: "except", 2: "else", 3: "finally"}
        for body_elm in acode.iterate_from(1):
            if is_form(body_elm, 'except'):
                if stage > 1:
                    raise CodeGenerationError(
                        body_elm.range,
                        "Found `except` clause after first `%s` in `try` special form."
                        % names[stage])
                else:
                    stage = 1
                except_handler = gen_except_handler(body_elm)
                handlers.append(except_handler)
            elif is_form(body_elm, 'else'):
                if stage > 1:
                    raise CodeGenerationError(
                        body_elm.range,
                        "Found `except` clause after first `%s` in `try` special form."
                        % names[stage])
                else:
                    stage = 2
                or_else = [
                    GC.generate(my_body_elm)
                    for my_body_elm in body_elm.code.iterate_from(1)
                ]
            elif is_form(body_elm, 'finally'):
                if stage > 2:
                    raise CodeGenerationError(
                        body_elm.range,
                        "Found `except` clause after first `%s` in `try` special form."
                        % names[stage])
                else:
                    stage = 3
                finally_body = []
                for my_body_elm in body_elm.code.iterate_from(1):
                    extend_body(finally_body, GC.generate(my_body_elm))
            else:
                if stage > 0:
                    raise CodeGenerationError(
                        body_elm.range,
                        "Found body clause after first `%s` in `try` special form."
                        % names[stage])
                body_gen = GC.generate(body_elm)
                extend_body(body_gens, body_gen)

        return ast.Try(body_gens, handlers, or_else, finally_body)
コード例 #38
0
ファイル: if.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        # "Check that form is as above"
        #assert


        if GC.domain == ExDom:
            astIf = ast.IfExp
            if len(acode) > 3 and not (is_form(acode[3], 'elif') or is_form(acode[3], 'else')):
                raise CodeGenerationError(acode.range, "If expression must only have a single sub-expression (for now).")
        else:
            astIf = ast.If



        def gen_elif_elses(elif_else_elm):
            my_code = elif_else_elm.code
            if is_form(elif_else_elm, 'elif'):
                with GC.let(domain=ExDom):
                    my_condition_gen = GC.generate(my_code[1])

                my_body_gens = []
                for body_elm in my_code.iterate_from(2):
                    extend_body(my_body_gens, GC.generate(body_elm))

                if elif_else_elm.next is None:
                    return [astIf(my_condition_gen, my_body_gens, [])]
                else:
                    else_code = gen_elif_elses(elif_else_elm.next)
                    return [astIf(my_condition_gen, my_body_gens, else_code)]
            elif is_form(elif_else_elm, 'else'):
                my_body_gens = []
                for body_elm in my_code.iterate_from(1):
                    extend_body(my_body_gens, GC.generate(body_elm))
                return my_body_gens
            else:
                raise CodeGenerationError(elif_else_elm.range,
                                          "Unexpected element `%s` after first `elif` or `else` form within `if` form." % (
                                          succinct_lisp_printer(elif_else_elm)))

        with GC.let(domain=ExDom):
            condition_gen = GC.generate(acode[1])
        body_gens = []
        else_code = []

        for body_elm in acode.iterate_from(2):
            if is_form(body_elm, 'elif') or is_form(body_elm, 'else'):
                else_code = gen_elif_elses(body_elm)
                break
            else:
                body_gen = GC.generate(body_elm)
                extend_body(body_gens, body_gen)

        if len(body_gens) == 0: body_gens.append(ast.Pass())


        if GC.domain == ExDom:
            return ast.IfExp(condition_gen, body_gens[0], else_code[0] if len(else_code) > 0 else ast.NameConstant(None))
        else:
            return ast.If(condition_gen, body_gens, else_code)
コード例 #39
0
ファイル: generator.py プロジェクト: bloff/rmtc-parsing
    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)
コード例 #40
0
    def generate(self, element: Element, GC: GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        # "Check that form is as above"
        #assert

        if GC.domain == ExDom:
            astIf = ast.IfExp
            if len(acode) > 3 and not (is_form(acode[3], 'elif')
                                       or is_form(acode[3], 'else')):
                raise CodeGenerationError(
                    acode.range,
                    "If expression must only have a single sub-expression (for now)."
                )
        else:
            astIf = ast.If

        def gen_elif_elses(elif_else_elm):
            my_code = elif_else_elm.code
            if is_form(elif_else_elm, 'elif'):
                with GC.let(domain=ExDom):
                    my_condition_gen = GC.generate(my_code[1])

                my_body_gens = []
                for body_elm in my_code.iterate_from(2):
                    extend_body(my_body_gens, GC.generate(body_elm))

                if elif_else_elm.next is None:
                    return [astIf(my_condition_gen, my_body_gens, [])]
                else:
                    else_code = gen_elif_elses(elif_else_elm.next)
                    return [astIf(my_condition_gen, my_body_gens, else_code)]
            elif is_form(elif_else_elm, 'else'):
                my_body_gens = []
                for body_elm in my_code.iterate_from(1):
                    extend_body(my_body_gens, GC.generate(body_elm))
                return my_body_gens
            else:
                raise CodeGenerationError(
                    elif_else_elm.range,
                    "Unexpected element `%s` after first `elif` or `else` form within `if` form."
                    % (succinct_lisp_printer(elif_else_elm)))

        with GC.let(domain=ExDom):
            condition_gen = GC.generate(acode[1])
        body_gens = []
        else_code = []

        for body_elm in acode.iterate_from(2):
            if is_form(body_elm, 'elif') or is_form(body_elm, 'else'):
                else_code = gen_elif_elses(body_elm)
                break
            else:
                body_gen = GC.generate(body_elm)
                extend_body(body_gens, body_gen)

        if len(body_gens) == 0: body_gens.append(ast.Pass())

        if GC.domain == ExDom:
            return ast.IfExp(
                condition_gen, body_gens[0],
                else_code[0] if len(else_code) > 0 else ast.NameConstant(None))
        else:
            return ast.If(condition_gen, body_gens, else_code)
コード例 #41
0
ファイル: try.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        self.precheck(element, GC)

        acode = element.code

        # "Check that form is as above"
        #assert





        def gen_except_handler(except_elm):
            my_code = except_elm.code
            exception_elm = my_code[1]
            name = None
            if is_form(exception_elm, 'as'):
                with GC.let(domain=ExpressionDomain):
                    my_exception_type = GC.generate(exception_elm.code[1])
                my_exception_name_id = exception_elm.code[2]
                if not is_identifier(my_exception_name_id):
                    raise CodeGenerationError(my_exception_name_id.range, "Expected an identifier as exception name of `except` clause in `try` special-form.")
                name = my_exception_name_id.code.name
            else:
                with GC.let(domain=ExpressionDomain):
                    my_exception_type = GC.generate(exception_elm)

            body_gens = []
            for my_body_elm in my_code.iterate_from(2):
                extend_body(body_gens, GC.generate(my_body_elm))

            return ast.ExceptHandler(my_exception_type, name, body_gens)





        body_gens, handlers, or_else, finally_body = [], [], None, None
        stage = 0 # 0 = body, 1 = except, 2 = else, 3 = finally
        names = {1: "except", 2: "else", 3: "finally"}
        for body_elm in acode.iterate_from(1):
            if is_form(body_elm, 'except'):
                if stage > 1: raise CodeGenerationError(body_elm.range, "Found `except` clause after first `%s` in `try` special form." % names[stage])
                else: stage = 1
                except_handler = gen_except_handler(body_elm)
                handlers.append(except_handler)
            elif is_form(body_elm, 'else'):
                if stage > 1: raise CodeGenerationError(body_elm.range, "Found `except` clause after first `%s` in `try` special form." % names[stage])
                else: stage = 2
                or_else = [GC.generate(my_body_elm) for my_body_elm in body_elm.code.iterate_from(1)]
            elif is_form(body_elm, 'finally'):
                if stage > 2: raise CodeGenerationError(body_elm.range, "Found `except` clause after first `%s` in `try` special form." % names[stage])
                else: stage = 3
                finally_body = []
                for my_body_elm in body_elm.code.iterate_from(1):
                    extend_body(finally_body, GC.generate(my_body_elm))
            else:
                if stage > 0: raise CodeGenerationError(body_elm.range, "Found body clause after first `%s` in `try` special form." % names[stage])
                body_gen = GC.generate(body_elm)
                extend_body(body_gens, body_gen)


        return ast.Try(body_gens, handlers, or_else, finally_body)
コード例 #42
0
ファイル: rawmacro.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        acode = element.code

        rawspecs = acode[1].code

        macro_name_element = rawspecs[0]

        macro_name = rawspecs[0].code.full_name
        macro_name_safe = "__macro_"+macro_name+"__"


        rawspec_element_param = rawspecs[1].code.full_name

        rawspec_context_param = rawspecs[2].code.full_name




        expand_body_elements = acode[2:]

        expand_body_code = []
        for b in expand_body_elements:
            extend_body(expand_body_code, GC.generate(b))
        # The... second-to-last form? of the original element should be
        #  responsible for generating (i.e. should return) code that will
        #  complete the macro expansion;
        #  the final statement executed in an .expand method would actually
        #  be doing the replacing
        #
        final_body_code = expand_body_code[-1]
        # element.replace(final_body_code)
        #ast.Call( ... )


        expand_args_code = ast.arguments(
            args=[ast.arg(arg="self"),
                  ast.arg(arg=rawspec_element_param,
                          annotation=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="Element", ctx=ast.Load())),
                  ast.arg(arg=rawspec_context_param,
                          annotation=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="ExpansionContext", ctx=ast.Load()))],
            kwonlyargs=[], defaults=[], kw_defaults=[]
        )



        expand_method_code = ast.FunctionDef(name="expand",
                                             args=expand_args_code,
                                             body=expand_body_code,
                                             decorator_list=[]
                                             )



        class_body_code = []

        # extend_body(class_body_code, ast.Import([ast.alias(name="anoky.module", asname="__aky__")]))

        extend_body(class_body_code, ast.Assign(targets=[ast.Name(id="HEADTEXT",
                                                            ctx=ast.Store())],
                                          value=ast.Str(macro_name)))

        extend_body(class_body_code, expand_method_code)





        classdef_code = ast.ClassDef(
                name=macro_name_safe,
                bases=[ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="Macro", ctx=ast.Load())],
                keywords=[], decorator_list=[],
                body=class_body_code)


        # __macros_macro_name__()
        instantiate_macro_code = ast.Call(func=ast.Name(id=macro_name_safe, ctx=ast.Load()),
                                          args=[], keywords=[])

        # EC.macro_table[macro_name]
        context_code = ast.Subscript(
                value=ast.Attribute(value=ast.Name(id="EC", ctx=ast.Load()),
                                    attr="macro_table", ctx=ast.Load()),
                slice=ast.Index(ast.Str(macro_name)), ctx=ast.Store())


        # __macros__[macro_name] = EC.macro_table[macro_name] = __macros_macro_name__()
        register_macro_code = ast.Assign(targets=[
            ast.Subscript(value=ast.Name(id="__macros__", ctx=ast.Load()),
                          slice=ast.Index(ast.Str(macro_name)),
                          ctx=ast.Store()),
        #    context_code
        ],
                                         value=instantiate_macro_code)


        generated_code = [classdef_code, register_macro_code]

        return generated_code
コード例 #43
0
ファイル: rawmacro.py プロジェクト: bloff/rmtc-parsing
    def generate(self, element:Element, GC:GenerationContext):

        acode = element.code



        sf_name_element = acode[1]

        sf_name = sf_name_element.code.full_name
        sf_name_safe = "__specialform_"+sf_name+"__"



        rawexpand = acode[2].code

        rawexpand_header = rawexpand[0].code
        assert is_identifier(rawexpand_header[0], "expand")

        assert is_identifier(rawexpand_header[1])
        rawexpand_element_param = rawexpand_header[1].code.full_name

        assert is_identifier(rawexpand_header[2])
        rawexpand_context_param = rawexpand_header[2].code.full_name


        expand_body_elements = rawexpand[1:]
        expand_body_code = []
        for b in expand_body_elements:
            extend_body(expand_body_code, GC.generate(b))
        # The... second-to-last form? of the original element should be
        #  responsible for generating (i.e. should return) code that will
        #  complete the macro expansion;
        #  the final statement executed in an .expand method would actually
        #  be doing the replacing


        expand_args_code = ast.arguments(
            args=[ast.arg(arg="self"),
                  ast.arg(arg=rawexpand_element_param,
                          annotation=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="Element", ctx=ast.Load())),
                  ast.arg(arg=rawexpand_context_param,
                          annotation=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="ExpansionContext", ctx=ast.Load()))],
            kwonlyargs=[], defaults=[], kw_defaults=[]
        )



        expand_method_code = ast.FunctionDef(name="expand",
                                             args=expand_args_code,
                                             body=expand_body_code,
                                             decorator_list=[]
                                             )





        rawgenerate = acode[3].code

        rawgenerate_header = rawgenerate[0].code
        assert is_identifier(rawgenerate_header[0], "generate")

        assert is_identifier(rawgenerate_header[1])
        rawgenerate_element_param = rawgenerate_header[1].code.full_name

        assert is_identifier(rawgenerate_header[2])
        rawgenerate_context_param = rawgenerate_header[2].code.full_name

        generate_body_elements = rawgenerate[1:]

        generate_body_code = []
        for b in generate_body_elements:
            extend_body(generate_body_code, GC.generate(b))


        generate_args_code = ast.arguments(
            args=[ast.arg(arg="self"),
                  ast.arg(arg=rawgenerate_element_param,
                          annotation=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="Element", ctx=ast.Load())),
                  ast.arg(arg=rawgenerate_context_param,
                          annotation=ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="GenerationContext", ctx=ast.Load()))],
            kwonlyargs=[], defaults=[], kw_defaults=[]
        )



        generate_method_code = ast.FunctionDef(name="generate",
                                             args=generate_args_code,
                                             body=generate_body_code,
                                             decorator_list=[]
                                             )


        class_body_code = []

        extend_body(class_body_code,ast.Import([ast.alias(name="anoky.module", asname="__aky__")]))

        extend_body(class_body_code, ast.Assign(targets=[ast.Name(id="HEADTEXT",
                                                            ctx=ast.Store())],
                                          value=ast.Str(sf_name)))

        extend_body(class_body_code, expand_method_code)
        extend_body(class_body_code, generate_method_code)




        classdef_code = ast.ClassDef(
                name=sf_name_safe,
                bases=[ast.Attribute(value=ast.Name(id="__aky__", ctx=ast.Load()),
                                     attr="SpecialForm", ctx=ast.Load())],
                keywords=[], decorator_list=[],
                body=class_body_code)


        # __specialform_sf_name__()
        instantiate_macro_code = ast.Call(func=ast.Name(id=sf_name_safe, ctx=ast.Load()),
                                          args=[], keywords=[])

        # EC.macro_table[sf_name]
        expansion_context_code = ast.Subscript(
                value=ast.Attribute(value=ast.Name(id="EC", ctx=ast.Load()),
                                    attr="macro_table", ctx=ast.Load()),
                slice=ast.Index(ast.Str(sf_name)), ctx=ast.Store())

        # GC.special_forms[sf_name]
        generation_context_code = ast.Subscript(
                value=ast.Attribute(value=ast.Name(id="GC", ctx=ast.Load()),
                                    attr="special_forms", ctx=ast.Load()),
                slice=ast.Index(ast.Str(sf_name)), ctx=ast.Store())


        # __special_forms__[sf_name] = EC.macro_table[sf_name] \
        #   = GC.special_forms[sf_name] = __specialform_sf_name__()
        register_macro_code = ast.Assign(targets=[
            ast.Subscript(value=ast.Name(id="__special_forms__", ctx=ast.Load()),
                          slice=ast.Index(ast.Str(sf_name)),
                          ctx=ast.Store()),
        #    expansion_context_code,
        #    generation_context_code
        ],
                                         value=instantiate_macro_code)


        generated_code = [classdef_code, register_macro_code]

        return generated_code
コード例 #44
0
ファイル: quote.py プロジェクト: bloff/rmtc-parsing
    def generate_quote_ast(element: Element, GC: GenerationContext):

        # allow passing code instead of element?

        acode = element.code

        if isinstance(acode, Form) and is_identifier(acode[0], "~"):

            assert len(acode) == 2

            with GC.let(domain=ExpressionDomain):
                literal_value = GC.generate(acode[1])

            a = ast.Call(func=ast.Attribute(value=ast.Name(id="__aky__",
                                                           ctx=ast.Load()),
                                            attr="force_literal",
                                            ctx=ast.Load()),
                         args=[literal_value],
                         keywords=[])

            return a

        elif isinstance(acode, Form) or isinstance(acode, Seq):

            #return __aky__.Form(*[akycode_to_ast(e) for e in acode])

            children_ast = [Quote.generate_quote_ast(e, GC) for e in acode]

            a = ast.Call(func=ast.Attribute(
                value=ast.Name(id="__aky__", ctx=ast.Load()),
                attr="Form" if isinstance(acode, Form) else "Seq",
                ctx=ast.Load()),
                         args=children_ast,
                         keywords=[])

            return a

        elif isinstance(acode, Identifier):

            return ast.Call(func=ast.Attribute(value=ast.Name(id="__aky__",
                                                              ctx=ast.Load()),
                                               attr="Identifier",
                                               ctx=ast.Load()),
                            args=[ast.Str(acode.full_name)],
                            keywords=[])

        else:

            assert isinstance(acode, Literal)

            if acode.type is str:
                value_code = ast.Str(acode.value)
            else:
                assert acode.type in [int, float]
                value_code = ast.Num(acode.value)

            return ast.Call(func=ast.Attribute(value=ast.Name(id="__aky__",
                                                              ctx=ast.Load()),
                                               attr="Literal",
                                               ctx=ast.Load()),
                            args=[
                                value_code,
                                ast.Name(id=acode.type.__name__,
                                         ctx=ast.Load())
                            ],
                            keywords=[])