python-cc 0.0.2__py3-none-any.whl

pcc/__main__.py

@@ -0,0 +1,3 @@
+if __name__ == '__main__':
+    from .pcc import main
+    main()

pcc/ast/ast.py

@@ -0,0 +1,179 @@
+
+# AST hierarchy
+class ASTNode(object):
+    def dump(self, indent=0):
+        raise NotImplementedError
+
+
+class ExprAST(ASTNode):
+    pass
+
+
+class NumberExprAST(ExprAST):
+    def __init__(self, val):
+        self.val = val
+
+    def dump(self, indent=0):
+        return '{0}{1}[{2}]'.format(
+            ' ' * indent, self.__class__.__name__, self.val)
+
+
+class VariableExprAST(ExprAST):
+    def __init__(self, name):
+        self.name = name
+
+    def dump(self, indent=0):
+        return '{0}{1}[{2}]'.format(
+            ' ' * indent, self.__class__.__name__, self.name)
+
+
+class VarExprAST(ExprAST):
+    def __init__(self, vars, body):
+        # vars is a sequence of (name, init) pairs
+        self.vars = vars
+        self.body = body
+
+    def dump(self, indent=0):
+        prefix = ' ' * indent
+        s = '{0}{1}\n'.format(prefix, self.__class__.__name__)
+        for name, init in self.vars:
+            s += '{0} {1}'.format(prefix, name)
+            if init is None:
+                s += '\n'
+            else:
+                s += '=\n' + init.dump(indent+2) + '\n'
+        s += '{0} Body:\n'.format(prefix)
+        s += self.body.dump(indent + 2)
+        return s
+
+
+class UnaryExprAST(ExprAST):
+    def __init__(self, op, operand):
+        self.op = op
+        self.operand = operand
+
+    def dump(self, indent=0):
+        s = '{0}{1}[{2}]\n'.format(
+            ' ' * indent, self.__class__.__name__, self.op)
+        s += self.operand.dump(indent + 2)
+        return s
+
+
+class BinaryExprAST(ExprAST):
+    def __init__(self, op, lhs, rhs):
+        self.op = op
+        self.lhs = lhs
+        self.rhs = rhs
+
+    def dump(self, indent=0):
+        s = '{0}{1}[{2}]\n'.format(
+            ' ' * indent, self.__class__.__name__, self.op)
+        s += self.lhs.dump(indent + 2) + '\n'
+        s += self.rhs.dump(indent + 2)
+        return s
+
+
+class IfExprAST(ExprAST):
+    def __init__(self, cond_expr, then_expr, else_expr):
+        self.cond_expr = cond_expr
+        self.then_expr = then_expr
+        self.else_expr = else_expr
+
+    def dump(self, indent=0):
+        prefix = ' ' * indent
+        s = '{0}{1}\n'.format(prefix, self.__class__.__name__)
+        s += '{0} Condition:\n{1}\n'.format(
+            prefix, self.cond_expr.dump(indent + 2))
+        s += '{0} Then:\n{1}\n'.format(
+            prefix, self.then_expr.dump(indent + 2))
+        s += '{0} Else:\n{1}'.format(
+            prefix, self.else_expr.dump(indent + 2))
+        return s
+
+
+class ForExprAST(ExprAST):
+    def __init__(self, id_name, start_expr, end_expr, step_expr, body):
+        self.id_name = id_name
+        self.start_expr = start_expr
+        self.end_expr = end_expr
+        self.step_expr = step_expr
+        self.body = body
+
+    def dump(self, indent=0):
+        prefix = ' ' * indent
+        s = '{0}{1}\n'.format(prefix, self.__class__.__name__)
+        s += '{0} Start [{1}]:\n{2}\n'.format(
+            prefix, self.id_name, self.start_expr.dump(indent + 2))
+        s += '{0} End:\n{1}\n'.format(
+            prefix, self.end_expr.dump(indent + 2))
+        s += '{0} Step:\n{1}\n'.format(
+            prefix, self.step_expr.dump(indent + 2))
+        s += '{0} Body:\n{1}\n'.format(
+            prefix, self.body.dump(indent + 2))
+        return s
+
+
+class CallExprAST(ExprAST):
+    def __init__(self, callee, args):
+        self.callee = callee
+        self.args = args
+
+    def dump(self, indent=0):
+        s = '{0}{1}[{2}]\n'.format(
+            ' ' * indent, self.__class__.__name__, self.callee)
+        for arg in self.args:
+            s += arg.dump(indent + 2) + '\n'
+        return s[:-1]  # snip out trailing '\n'
+
+
+class PrototypeAST(ASTNode):
+    def __init__(self, name, argnames, isoperator=False, prec=0):
+        self.name = name
+        self.argnames = argnames
+        self.isoperator = isoperator
+        self.prec = prec
+
+    def is_unary_op(self):
+        return self.isoperator and len(self.argnames) == 1
+
+    def is_binary_op(self):
+        return self.isoperator and len(self.argnames) == 2
+
+    def get_op_name(self):
+        assert self.isoperator
+        return self.name[-1]
+
+    def dump(self, indent=0):
+        s = '{0}{1} {2}({3})'.format(
+            ' ' * indent, self.__class__.__name__, self.name,
+            ', '.join(self.argnames))
+        if self.isoperator:
+            s += '[operator with prec={0}]'.format(self.prec)
+        return s
+
+
+class FunctionAST(ASTNode):
+    def __init__(self, proto, body):
+        self.proto = proto
+        self.body = body
+
+    _anonymous_function_counter = 0
+
+    @classmethod
+    def create_anonymous(klass, expr):
+        """Create an anonymous function to hold an expression."""
+        klass._anonymous_function_counter += 1
+        return klass(
+            PrototypeAST('_anon{0}'.format(klass._anonymous_function_counter),
+                         []),
+            expr)
+
+    def is_anonymous(self):
+        return self.proto.name.startswith('_anon')
+
+    def dump(self, indent=0):
+        s = '{0}{1}[{2}]\n'.format(
+            ' ' * indent, self.__class__.__name__, self.proto.dump())
+        s += self.body.dump(indent + 2) + '\n'
+        return s
+

pcc/ast/ast_transforms.py

@@ -0,0 +1,106 @@
+#------------------------------------------------------------------------------
+# pycparser: ast_transforms.py
+#
+# Some utilities used by the parser to create a friendlier AST.
+#
+# Copyright (C) 2008-2015, Eli Bendersky
+# License: BSD
+#------------------------------------------------------------------------------
+
+from . import c_ast
+
+
+def fix_switch_cases(switch_node):
+    """ The 'case' statements in a 'switch' come out of parsing with one
+        child node, so subsequent statements are just tucked to the parent
+        Compound. Additionally, consecutive (fall-through) case statements
+        come out messy. This is a peculiarity of the C grammar. The following:
+
+            switch (myvar) {
+                case 10:
+                    k = 10;
+                    p = k + 1;
+                    return 10;
+                case 20:
+                case 30:
+                    return 20;
+                default:
+                    break;
+            }
+
+        Creates this tree (pseudo-dump):
+
+            Switch
+                ID: myvar
+                Compound:
+                    Case 10:
+                        k = 10
+                    p = k + 1
+                    return 10
+                    Case 20:
+                        Case 30:
+                            return 20
+                    Default:
+                        break
+
+        The goal of this transform it to fix this mess, turning it into the
+        following:
+
+            Switch
+                ID: myvar
+                Compound:
+                    Case 10:
+                        k = 10
+                        p = k + 1
+                        return 10
+                    Case 20:
+                    Case 30:
+                        return 20
+                    Default:
+                        break
+
+        A fixed AST node is returned. The argument may be modified.
+    """
+    assert isinstance(switch_node, c_ast.Switch)
+    if not isinstance(switch_node.stmt, c_ast.Compound):
+        return switch_node
+
+    # The new Compound child for the Switch, which will collect children in the
+    # correct order
+    new_compound = c_ast.Compound([], switch_node.stmt.coord)
+
+    # The last Case/Default node
+    last_case = None
+
+    # Goes over the children of the Compound below the Switch, adding them
+    # either directly below new_compound or below the last Case as appropriate
+    for child in switch_node.stmt.block_items:
+        if isinstance(child, (c_ast.Case, c_ast.Default)):
+            # If it's a Case/Default:
+            # 1. Add it to the Compound and mark as "last case"
+            # 2. If its immediate child is also a Case or Default, promote it
+            #    to a sibling.
+            new_compound.block_items.append(child)
+            _extract_nested_case(child, new_compound.block_items)
+            last_case = new_compound.block_items[-1]
+        else:
+            # Other statements are added as children to the last case, if it
+            # exists.
+            if last_case is None:
+                new_compound.block_items.append(child)
+            else:
+                last_case.stmts.append(child)
+
+    switch_node.stmt = new_compound
+    return switch_node
+
+
+def _extract_nested_case(case_node, stmts_list):
+    """ Recursively extract consecutive Case statements that are made nested
+        by the parser and add them to the stmts_list.
+    """
+    if isinstance(case_node.stmts[0], (c_ast.Case, c_ast.Default)):
+        stmts_list.append(case_node.stmts.pop())
+        _extract_nested_case(stmts_list[-1], stmts_list)
+
+