python-cc 0.0.2__py3-none-any.whl

pcc/evaluater/c_evaluator.py

@@ -0,0 +1,238 @@
+import llvmlite.ir as ir
+import llvmlite.binding as llvm
+import os
+import subprocess
+import shutil
+import sys
+from ..codegen.c_codegen import LLVMCodeGenerator, postprocess_ir_text
+from ..parse.c_parser import CParser
+from ..preprocessor import preprocess
+
+from ctypes import (
+    CFUNCTYPE,
+    c_double,
+    c_int64,
+    c_int32,
+    c_int16,
+    c_int8,
+    c_char_p,
+    POINTER,
+)
+
+
+def get_c_type_from_ir(ir_type):
+    if isinstance(ir_type, ir.VoidType):
+        return None
+    elif isinstance(ir_type, ir.IntType):
+        if ir_type.width == 8:
+            return c_int8
+        elif ir_type.width == 16:
+            return c_int16
+        elif ir_type.width == 32:
+            return c_int32
+        return c_int64
+    elif isinstance(ir_type, ir.DoubleType):
+        return c_double
+    elif isinstance(ir_type, ir.PointerType):
+        point_type = get_c_type_from_ir(ir_type.pointee)
+        return POINTER(point_type)
+    else:
+        return c_int64
+
+
+class CEvaluator(object):
+
+    def __init__(self):
+
+        llvm.initialize_native_target()
+        llvm.initialize_native_asmprinter()
+
+        self.codegen = LLVMCodeGenerator()
+        self.parser = CParser()
+        self.target = llvm.Target.from_default_triple()
+        self.ee = None
+
+    def evaluate(
+        self,
+        codestr,
+        optimize=True,
+        llvmdump=False,
+        args=None,
+        base_dir=None,
+        use_system_cpp=None,
+        prog_args=None,
+    ):
+        if use_system_cpp is None:
+            use_system_cpp = self._has_system_cpp()
+        if use_system_cpp:
+            codestr = self._system_cpp(codestr, base_dir)
+            import re
+
+            codestr = re.sub(
+                r"typedef\s+(int|char|short|long|double|float|void)\s+\1\s*;",
+                "",
+                codestr,
+            )
+        else:
+            codestr = preprocess(codestr, base_dir=base_dir)
+        ast = self.parser.parse(codestr)
+        self.codegen = LLVMCodeGenerator()
+        self.codegen.generate_code(ast)
+        ir_text = postprocess_ir_text(str(self.codegen.module))
+
+        if llvmdump:
+            with open("temp.ir", "w") as f:
+                f.write(ir_text)
+
+        llvmmod = llvm.parse_assembly(ir_text)
+
+        if optimize:
+            target_machine = self.target.create_target_machine()
+            pto = llvm.create_pipeline_tuning_options(speed_level=2, size_level=0)
+            pb = llvm.create_pass_builder(target_machine, pto)
+            pm = pb.getModulePassManager()
+            pm.run(llvmmod, pb)
+
+            if llvmdump:
+                tempbcode = str(llvmmod)
+                with open("temp.ooptimize.bcode", "w") as f:
+                    f.write(tempbcode)
+
+        target_machine = self.target.create_target_machine()
+
+        self.ee = llvm.create_mcjit_compiler(llvmmod, target_machine)
+        self.ee.finalize_object()
+
+        if llvmdump:
+            tempbcode = target_machine.emit_assembly(llvmmod)
+            with open("temp.bcode", "w") as f:
+                f.write(tempbcode)
+
+        return_type = get_c_type_from_ir(self.codegen.return_type)
+
+        main_addr = self.ee.get_function_address("main")
+
+        if prog_args:
+            # Build argc/argv for main(int argc, char **argv)
+            argv_strings = ["pcc"] + list(prog_args)
+            argc = len(argv_strings)
+            ArgvType = c_char_p * (argc + 1)
+            argv = ArgvType(*[s.encode() for s in argv_strings], None)
+            fptr = CFUNCTYPE(return_type, c_int32, POINTER(c_char_p))(main_addr)
+            result = fptr(argc, argv)
+        else:
+            fptr = CFUNCTYPE(return_type)(main_addr)
+            if args is None:
+                args = []
+            result = fptr(*args)
+
+        return result
+
+    @staticmethod
+    def _has_system_cpp():
+        return shutil.which("cc") is not None or shutil.which("gcc") is not None
+
+    @staticmethod
+    def _system_cpp(source, base_dir=None):
+        """Use system C preprocessor (cc -E) for fast preprocessing.
+
+        Uses -nostdinc + fake libc headers so output is pycparser-compatible.
+        """
+        import tempfile
+
+        cc = shutil.which("cc") or shutil.which("gcc") or shutil.which("clang")
+        if not cc:
+            raise RuntimeError("No system C compiler found for preprocessing")
+
+        # Find fake libc headers (shipped with pcc)
+        # __file__ = pcc/evaluater/c_evaluator.py → project root is 2 levels up
+        pcc_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        fake_libc = os.path.join(pcc_root, "utils", "fake_libc_include")
+        base_dir = os.path.abspath(base_dir) if base_dir else os.getcwd()
+
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".c", dir=base_dir, delete=False
+        ) as f:
+            f.write(source)
+            tmp_path = f.name
+        try:
+            platform_defs = []
+            if sys.platform == "darwin":
+                # fake libc headers do not provide the stdio macro remaps that
+                # macOS uses for FILE* globals.
+                platform_defs.extend(
+                    [
+                        "-Dstdin=__stdinp",
+                        "-Dstdout=__stdoutp",
+                        "-Dstderr=__stderrp",
+                    ]
+                )
+
+            cmd = [
+                cc,
+                "-E",
+                "-P",
+                "-nostdinc",  # skip real system headers
+                "-isystem",
+                fake_libc,  # fake libc as system headers
+                "-I",
+                base_dir or ".",  # project headers
+                # Standard limits (fake headers don't have these)
+                "-DLLONG_MAX=9223372036854775807LL",
+                "-DLLONG_MIN=(-9223372036854775807LL-1)",
+                "-DULLONG_MAX=18446744073709551615ULL",
+                "-DLONG_MAX=9223372036854775807L",
+                "-DINT_MAX=2147483647",
+                "-DINT_MIN=(-2147483647-1)",
+                "-DLONG_MIN=(-9223372036854775807L-1)",
+                "-DUINT_MAX=4294967295U",
+                "-DCHAR_BIT=8",
+                "-DSHRT_MAX=32767",
+                "-DUSHRT_MAX=65535",
+                "-DCHAR_MAX=127",
+                "-DUCHAR_MAX=255",
+                "-DSIG_DFL=0",
+                "-DSIG_IGN=1",
+                "-DSIGINT=2",
+                "-DCLOCKS_PER_SEC=1000000",
+                "-DLC_ALL=0",
+                "-DLC_COLLATE=1",
+                "-DLC_CTYPE=2",
+                "-DLC_MONETARY=3",
+                "-DLC_NUMERIC=4",
+                "-DLC_TIME=5",
+                "-Doffsetof(t,m)=((long)&((t*)0)->m)",
+                "-DDBL_MANT_DIG=53",
+                "-DFLT_MANT_DIG=24",
+                "-DDBL_MAX_EXP=1024",
+                "-DFLT_MAX_EXP=128",
+                "-DDBL_MAX=1.7976931348623158e+308",
+                "-DHUGE_VAL=1e309",
+                "-DHUGE_VALF=1e39f",
+                "-DDBL_MAX_10_EXP=308",
+                "-DFLT_MAX_10_EXP=38",
+                "-DDBL_MIN_EXP=-1021",
+                "-DDBL_EPSILON=2.2204460492503131e-16",
+                "-D_IONBF=2",
+                "-D_IOLBF=1",
+                "-D_IOFBF=0",
+                # GCC/Clang extensions
+                "-D__attribute__(x)=",
+                "-D__extension__=",
+                # Disable Lua's computed goto and builtins
+                "-DLUA_USE_JUMPTABLE=0",
+                "-DLUA_NOBUILTIN",
+                *platform_defs,
+                tmp_path,
+            ]
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            if result.returncode == 0:
+                return result.stdout
+            # Fallback: without -nostdinc
+            cmd = [cc, "-E", "-P", "-I", base_dir or ".", tmp_path]
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            return result.stdout
+        finally:
+            os.unlink(tmp_path)

pcc/generator/c_generator.py

@@ -0,0 +1,399 @@
+#------------------------------------------------------------------------------
+# pycparser: c_generator.py
+#
+# C code generator from pycparser AST nodes.
+#
+# Copyright (C) 2008-2015, Eli Bendersky
+# License: BSD
+#------------------------------------------------------------------------------
+from ..ast import c_ast
+
+
+class CGenerator(object):
+    """ Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
+        return a value from each visit method, using string accumulation in
+        generic_visit.
+    """
+    def __init__(self):
+        # Statements start with indentation of self.indent_level spaces, using
+        # the _make_indent method
+        #
+        self.indent_level = 0
+
+    def _make_indent(self):
+        return ' ' * self.indent_level
+
+    def visit(self, node):
+        method = 'visit_' + node.__class__.__name__
+        return getattr(self, method, self.generic_visit)(node)
+
+    def generic_visit(self, node):
+        #~ print('generic:', type(node))
+        if node is None:
+            return ''
+        else:
+            return ''.join(self.visit(c) for c_name, c in node.children())
+
+    def visit_Constant(self, n):
+        return n.value
+
+    def visit_ID(self, n):
+        return n.name
+
+    def visit_ArrayRef(self, n):
+        arrref = self._parenthesize_unless_simple(n.name)
+        return arrref + '[' + self.visit(n.subscript) + ']'
+
+    def visit_StructRef(self, n):
+        sref = self._parenthesize_unless_simple(n.name)
+        return sref + n.type + self.visit(n.field)
+
+    def visit_FuncCall(self, n):
+        fref = self._parenthesize_unless_simple(n.name)
+        return fref + '(' + self.visit(n.args) + ')'
+
+    def visit_UnaryOp(self, n):
+        operand = self._parenthesize_unless_simple(n.expr)
+        if n.op == 'p++':
+            return '%s++' % operand
+        elif n.op == 'p--':
+            return '%s--' % operand
+        elif n.op == 'sizeof':
+            # Always parenthesize the argument of sizeof since it can be
+            # a name.
+            return 'sizeof(%s)' % self.visit(n.expr)
+        else:
+            return '%s%s' % (n.op, operand)
+
+    def visit_BinaryOp(self, n):
+        lval_str = self._parenthesize_if(n.left,
+                            lambda d: not self._is_simple_node(d))
+        rval_str = self._parenthesize_if(n.right,
+                            lambda d: not self._is_simple_node(d))
+        return '%s %s %s' % (lval_str, n.op, rval_str)
+
+    def visit_Assignment(self, n):
+        rval_str = self._parenthesize_if(
+                            n.rvalue,
+                            lambda n: isinstance(n, c_ast.Assignment))
+        return '%s %s %s' % (self.visit(n.lvalue), n.op, rval_str)
+
+    def visit_IdentifierType(self, n):
+        return ' '.join(n.names)
+
+    def _visit_expr(self, n):
+        if isinstance(n, c_ast.InitList):
+            return '{' + self.visit(n) + '}'
+        elif isinstance(n, c_ast.ExprList):
+            return '(' + self.visit(n) + ')'
+        else:
+            return self.visit(n)
+
+    def visit_Decl(self, n, no_type=False):
+        # no_type is used when a Decl is part of a DeclList, where the type is
+        # explicitly only for the first declaration in a list.
+        #
+        s = n.name if no_type else self._generate_decl(n)
+        if n.bitsize: s += ' : ' + self.visit(n.bitsize)
+        if n.init:
+            s += ' = ' + self._visit_expr(n.init)
+        return s
+
+    def visit_DeclList(self, n):
+        s = self.visit(n.decls[0])
+        if len(n.decls) > 1:
+            s += ', ' + ', '.join(self.visit_Decl(decl, no_type=True)
+                                    for decl in n.decls[1:])
+        return s
+
+    def visit_Typedef(self, n):
+        s = ''
+        if n.storage: s += ' '.join(n.storage) + ' '
+        s += self._generate_type(n.type)
+        return s
+
+    def visit_Cast(self, n):
+        s = '(' + self._generate_type(n.to_type) + ')'
+        return s + ' ' + self._parenthesize_unless_simple(n.expr)
+
+    def visit_ExprList(self, n):
+        visited_subexprs = []
+        for expr in n.exprs:
+            visited_subexprs.append(self._visit_expr(expr))
+        return ', '.join(visited_subexprs)
+
+    def visit_InitList(self, n):
+        visited_subexprs = []
+        for expr in n.exprs:
+            visited_subexprs.append(self._visit_expr(expr))
+        return ', '.join(visited_subexprs)
+
+    def visit_Enum(self, n):
+        s = 'enum'
+        if n.name: s += ' ' + n.name
+        if n.values:
+            s += ' {'
+            for i, enumerator in enumerate(n.values.enumerators):
+                s += enumerator.name
+                if enumerator.value:
+                    s += ' = ' + self.visit(enumerator.value)
+                if i != len(n.values.enumerators) - 1:
+                    s += ', '
+            s += '}'
+        return s
+
+    def visit_FuncDef(self, n):
+        decl = self.visit(n.decl)
+        self.indent_level = 0
+        body = self.visit(n.body)
+        if n.param_decls:
+            knrdecls = ';\n'.join(self.visit(p) for p in n.param_decls)
+            return decl + '\n' + knrdecls + ';\n' + body + '\n'
+        else:
+            return decl + '\n' + body + '\n'
+
+    def visit_FileAST(self, n):
+        s = ''
+        for ext in n.ext:
+            if isinstance(ext, c_ast.FuncDef):
+                s += self.visit(ext)
+            else:
+                s += self.visit(ext) + ';\n'
+        return s
+
+    def visit_Compound(self, n):
+        s = self._make_indent() + '{\n'
+        self.indent_level += 2
+        if n.block_items:
+            s += ''.join(self._generate_stmt(stmt) for stmt in n.block_items)
+        self.indent_level -= 2
+        s += self._make_indent() + '}\n'
+        return s
+
+    def visit_EmptyStatement(self, n):
+        return ';'
+
+    def visit_ParamList(self, n):
+        return ', '.join(self.visit(param) for param in n.params)
+
+    def visit_Return(self, n):
+        s = 'return'
+        if n.expr: s += ' ' + self.visit(n.expr)
+        return s + ';'
+
+    def visit_Break(self, n):
+        return 'break;'
+
+    def visit_Continue(self, n):
+        return 'continue;'
+
+    def visit_TernaryOp(self, n):
+        s = self._visit_expr(n.cond) + ' ? '
+        s += self._visit_expr(n.iftrue) + ' : '
+        s += self._visit_expr(n.iffalse)
+        return s
+
+    def visit_If(self, n):
+        s = 'if ('
+        if n.cond: s += self.visit(n.cond)
+        s += ')\n'
+        s += self._generate_stmt(n.iftrue, add_indent=True)
+        if n.iffalse:
+            s += self._make_indent() + 'else\n'
+            s += self._generate_stmt(n.iffalse, add_indent=True)
+        return s
+
+    def visit_For(self, n):
+        s = 'for ('
+        if n.init: s += self.visit(n.init)
+        s += ';'
+        if n.cond: s += ' ' + self.visit(n.cond)
+        s += ';'
+        if n.next: s += ' ' + self.visit(n.next)
+        s += ')\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        return s
+
+    def visit_While(self, n):
+        s = 'while ('
+        if n.cond: s += self.visit(n.cond)
+        s += ')\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        return s
+
+    def visit_DoWhile(self, n):
+        s = 'do\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        s += self._make_indent() + 'while ('
+        if n.cond: s += self.visit(n.cond)
+        s += ');'
+        return s
+
+    def visit_Switch(self, n):
+        s = 'switch (' + self.visit(n.cond) + ')\n'
+        s += self._generate_stmt(n.stmt, add_indent=True)
+        return s
+
+    def visit_Case(self, n):
+        s = 'case ' + self.visit(n.expr) + ':\n'
+        for stmt in n.stmts:
+            s += self._generate_stmt(stmt, add_indent=True)
+        return s
+
+    def visit_Default(self, n):
+        s = 'default:\n'
+        for stmt in n.stmts:
+            s += self._generate_stmt(stmt, add_indent=True)
+        return s
+
+    def visit_Label(self, n):
+        return n.name + ':\n' + self._generate_stmt(n.stmt)
+
+    def visit_Goto(self, n):
+        return 'goto ' + n.name + ';'
+
+    def visit_EllipsisParam(self, n):
+        return '...'
+
+    def visit_Struct(self, n):
+        return self._generate_struct_union(n, 'struct')
+
+    def visit_Typename(self, n):
+        return self._generate_type(n.type)
+
+    def visit_Union(self, n):
+        return self._generate_struct_union(n, 'union')
+
+    def visit_NamedInitializer(self, n):
+        s = ''
+        for name in n.name:
+            if isinstance(name, c_ast.ID):
+                s += '.' + name.name
+            elif isinstance(name, c_ast.Constant):
+                s += '[' + name.value + ']'
+        s += ' = ' + self.visit(n.expr)
+        return s
+
+    def visit_FuncDecl(self, n):
+        return self._generate_type(n)
+
+    def _generate_struct_union(self, n, name):
+        """ Generates code for structs and unions. name should be either
+            'struct' or union.
+        """
+        s = name + ' ' + (n.name or '')
+        if n.decls:
+            s += '\n'
+            s += self._make_indent()
+            self.indent_level += 2
+            s += '{\n'
+            for decl in n.decls:
+                s += self._generate_stmt(decl)
+            self.indent_level -= 2
+            s += self._make_indent() + '}'
+        return s
+
+    def _generate_stmt(self, n, add_indent=False):
+        """ Generation from a statement node. This method exists as a wrapper
+            for individual visit_* methods to handle different treatment of
+            some statements in this context.
+        """
+        typ = type(n)
+        if add_indent: self.indent_level += 2
+        indent = self._make_indent()
+        if add_indent: self.indent_level -= 2
+
+        if typ in (
+                c_ast.Decl, c_ast.Assignment, c_ast.Cast, c_ast.UnaryOp,
+                c_ast.BinaryOp, c_ast.TernaryOp, c_ast.FuncCall, c_ast.ArrayRef,
+                c_ast.StructRef, c_ast.Constant, c_ast.ID, c_ast.Typedef,
+                c_ast.ExprList):
+            # These can also appear in an expression context so no semicolon
+            # is added to them automatically
+            #
+            return indent + self.visit(n) + ';\n'
+        elif typ in (c_ast.Compound,):
+            # No extra indentation required before the opening brace of a
+            # compound - because it consists of multiple lines it has to
+            # compute its own indentation.
+            #
+            return self.visit(n)
+        else:
+            return indent + self.visit(n) + '\n'
+
+    def _generate_decl(self, n):
+        """ Generation from a Decl node.
+        """
+        s = ''
+        if n.funcspec: s = ' '.join(n.funcspec) + ' '
+        if n.storage: s += ' '.join(n.storage) + ' '
+        s += self._generate_type(n.type)
+        return s
+
+    def _generate_type(self, n, modifiers=[]):
+        """ Recursive generation from a type node. n is the type node.
+            modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
+            encountered on the way down to a TypeDecl, to allow proper
+            generation from it.
+        """
+        typ = type(n)
+        #~ print(n, modifiers)
+
+        if typ == c_ast.TypeDecl:
+            s = ''
+            if n.quals: s += ' '.join(n.quals) + ' '
+            s += self.visit(n.type)
+
+            nstr = n.declname if n.declname else ''
+            # Resolve modifiers.
+            # Wrap in parens to distinguish pointer to array and pointer to
+            # function syntax.
+            #
+            for i, modifier in enumerate(modifiers):
+                if isinstance(modifier, c_ast.ArrayDecl):
+                    if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
+                        nstr = '(' + nstr + ')'
+                    nstr += '[' + self.visit(modifier.dim) + ']'
+                elif isinstance(modifier, c_ast.FuncDecl):
+                    if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
+                        nstr = '(' + nstr + ')'
+                    nstr += '(' + self.visit(modifier.args) + ')'
+                elif isinstance(modifier, c_ast.PtrDecl):
+                    if modifier.quals:
+                        nstr = '* %s %s' % (' '.join(modifier.quals), nstr)
+                    else:
+                        nstr = '*' + nstr
+            if nstr: s += ' ' + nstr
+            return s
+        elif typ == c_ast.Decl:
+            return self._generate_decl(n.type)
+        elif typ == c_ast.Typename:
+            return self._generate_type(n.type)
+        elif typ == c_ast.IdentifierType:
+            return ' '.join(n.names) + ' '
+        elif typ in (c_ast.ArrayDecl, c_ast.PtrDecl, c_ast.FuncDecl):
+            return self._generate_type(n.type, modifiers + [n])
+        else:
+            return self.visit(n)
+
+    def _parenthesize_if(self, n, condition):
+        """ Visits 'n' and returns its string representation, parenthesized
+            if the condition function applied to the node returns True.
+        """
+        s = self._visit_expr(n)
+        if condition(n):
+            return '(' + s + ')'
+        else:
+            return s
+
+    def _parenthesize_unless_simple(self, n):
+        """ Common use case for _parenthesize_if
+        """
+        return self._parenthesize_if(n, lambda d: not self._is_simple_node(d))
+
+    def _is_simple_node(self, n):
+        """ Returns True for nodes that are "simple" - i.e. nodes that always
+            have higher precedence than operators.
+        """
+        return isinstance(n,(   c_ast.Constant, c_ast.ID, c_ast.ArrayRef,
+                                c_ast.StructRef, c_ast.FuncCall))