SHARE
TWEET

c to cython translator - test2

a guest Jan 12th, 2013 120 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #------------------------------------------------------------------------------
  2. # pycparser: cython_generator.py
  3. #
  4. # Cython code generator from pycparser AST nodes.
  5. #
  6. # Copyright (C) 2008-2012, Eli Bendersky and Brett Hartshorn
  7. # License: BSD
  8. #------------------------------------------------------------------------------
  9. from . import c_ast
  10.  
  11.  
  12. class CythonGenerator(object):
  13.     """ Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
  14.        return a value from each visit method, using string accumulation in
  15.        generic_visit.
  16.    """
  17.     def __init__(self):
  18.         self.output = ''
  19.        
  20.         # Statements start with indentation of self.indent_level spaces, using
  21.         # the _make_indent method
  22.         #
  23.         self.indent_level = 0
  24.    
  25.     def _make_indent(self):
  26.         return ' ' * self.indent_level
  27.    
  28.     def visit(self, node, cdef=True):
  29.         method = 'visit_' + node.__class__.__name__
  30.         print(method)
  31.         if method in 'visit_Decl visit_ParamList'.split():
  32.             return getattr(self, method, self.generic_visit)(node, cdef=cdef)
  33.         else:
  34.             return getattr(self, method, self.generic_visit)(node)
  35.    
  36.     def generic_visit(self, node):
  37.         #~ print('generic:', type(node))
  38.         if node is None:
  39.             return ''
  40.         else:
  41.             return ''.join(self.visit(c) for c in node.children())
  42.    
  43.     def visit_Constant(self, n):
  44.         return n.value
  45.        
  46.     def visit_ID(self, n):
  47.         return n.name
  48.  
  49.     def visit_ArrayRef(self, n):
  50.         arrref = self._parenthesize_unless_simple(n.name)
  51.         return arrref + '[' + self.visit(n.subscript) + ']'
  52.  
  53.     def visit_StructRef(self, n):
  54.         sref = self._parenthesize_unless_simple(n.name)
  55.         return sref + n.type + self.visit(n.field)
  56.  
  57.     def visit_FuncCall(self, n):
  58.         fref = self._parenthesize_unless_simple(n.name)
  59.         if fref == 'printf': fref = 'print'
  60.         return fref + '(' + self.visit(n.args) + ')'
  61.  
  62.     def visit_UnaryOp(self, n):
  63.         operand = self._parenthesize_unless_simple(n.expr)
  64.         if n.op == 'p++':
  65.             return '%s += 1' % operand
  66.         elif n.op == 'p--':
  67.             return '%s -= 1' % operand
  68.         elif n.op == 'sizeof':
  69.             # Always parenthesize the argument of sizeof since it can be
  70.             # a name.
  71.             return 'sizeof(%s)' % self.visit(n.expr)
  72.         else:
  73.             return '%s%s' % (n.op, operand)
  74.  
  75.     def visit_BinaryOp(self, n):
  76.         lval_str = self._parenthesize_if(n.left,
  77.                             lambda d: not self._is_simple_node(d))
  78.         rval_str = self._parenthesize_if(n.right,
  79.                             lambda d: not self._is_simple_node(d))
  80.         return '%s %s %s' % (lval_str, n.op, rval_str)
  81.  
  82.     def visit_Assignment(self, n):
  83.         rval_str = self._parenthesize_if(
  84.                             n.rvalue,
  85.                             lambda n: isinstance(n, c_ast.Assignment))
  86.         return '%s %s %s' % (self.visit(n.lvalue), n.op, rval_str)
  87.  
  88.     def visit_IdentifierType(self, n):
  89.         return ' '.join(n.names)
  90.  
  91.     def visit_Decl(self, n, no_type=False, cdef=True):
  92.         # no_type is used when a Decl is part of a DeclList, where the type is
  93.         # explicitly only for the first delaration in a list.
  94.         #
  95.         s = n.name if no_type else self._generate_decl(n)
  96.         print('visit_Decl', s)
  97.         n.show()
  98.         print( n.type, type(n.type) )
  99.  
  100.         if not isinstance(n.type, (c_ast.Enum, c_ast.Struct)):
  101.             s = 'cdef ' + s
  102.  
  103.         if n.bitsize: s += ' : ' + self.visit(n.bitsize)
  104.         if n.init:
  105.             if isinstance(n.init, c_ast.InitList):
  106.                 s += ' = {' + self.visit(n.init) + '}'
  107.             elif isinstance(n.init, c_ast.ExprList):
  108.                 s += ' = (' + self.visit(n.init) + ')'
  109.             else:
  110.                 s += ' = ' + self.visit(n.init)
  111.         return s
  112.  
  113.     def visit_DeclList(self, n):
  114.         s = self.visit(n.decls[0])
  115.         if len(n.decls) > 1:
  116.             s += ', ' + ', '.join(self.visit_Decl(decl, no_type=True)
  117.                                     for decl in n.decls[1:])
  118.         return s
  119.  
  120.     def visit_Typedef(self, n):
  121.         a = self._generate_type(n.type)
  122.         a = '\n'.join( a.splitlines()[:-1] ) # remove name at end.
  123.         a = a.replace(';', '')
  124.  
  125.         if n.storage:
  126.             s = ' '.join(n.storage) + ' '
  127.             s = s.replace('typedef ', 'ctypedef ')
  128.             simple = True
  129.             if isinstance(n.type, c_ast.TypeDecl):
  130.                 if isinstance(n.type.type, c_ast.Struct):
  131.                     if not n.type.type.name:
  132.                         simple = True
  133.                     elif n.type.declname == n.type.type.name:
  134.                         simple = True
  135.                     elif n.type.declname != n.type.type.name:
  136.                         simple = False
  137.  
  138.             if simple:
  139.                 if a.startswith('cdef '):
  140.                     a = a[5:]
  141.                 return s + a
  142.             else:
  143.                 return a + '\nctypedef %s %s\n'%(n.type.type.name, n.type.declname)
  144.         else:
  145.             return a
  146.  
  147.  
  148.     def visit_Cast(self, n):
  149.         s = '(' + self._generate_type(n.to_type) + ')'
  150.         return s + ' ' + self._parenthesize_unless_simple(n.expr)
  151.  
  152.     def visit_ExprList(self, n):
  153.         visited_subexprs = []
  154.         for expr in n.exprs:
  155.             if isinstance(expr, c_ast.ExprList):
  156.                 visited_subexprs.append('{' + self.visit(expr) + '}')
  157.             else:
  158.                 visited_subexprs.append(self.visit(expr))
  159.         return ', '.join(visited_subexprs)
  160.  
  161.     def visit_InitList(self, n):
  162.         visited_subexprs = []
  163.         for expr in n.exprs:
  164.             if isinstance(expr, c_ast.InitList):
  165.                 visited_subexprs.append('(' + self.visit(expr) + ')')
  166.             else:
  167.                 visited_subexprs.append(self.visit(expr))
  168.         return ', '.join(visited_subexprs)
  169.  
  170.  
  171.     def visit_Enum(self, n):
  172.         s = '# enum'
  173.         if n.name: s += ' ' + n.name
  174.         items = []
  175.         if n.values:
  176.             for i, enumerator in enumerate(n.values.enumerators):
  177.                 if enumerator.value:
  178.                     items.append( 'cdef int '+enumerator.name + ' = ' + self.visit(enumerator.value) )
  179.                 else:
  180.                     items.append( 'cdef int '+enumerator.name + ' = %s'%i)
  181.         return s + '\n' + '\n'.join( items )
  182.  
  183.  
  184.     def visit_FuncDef(self, n):
  185.         decl = self.visit(n.decl) + ':'
  186.         decl = 'cpdef ' + decl.replace('cdef ', '')  ## to keep things simple just remove "cdef " from parameters
  187.         self.indent_level = 0
  188.         body = self.visit(n.body)
  189.         if n.param_decls:
  190.             knrdecls = ';\n'.join(self.visit(p) for p in n.param_decls)
  191.             return decl + '\n' + knrdecls + ';\n' + body + '\n'
  192.         else:
  193.             return decl + '\n' + body + '\n'
  194.  
  195.     def visit_FileAST(self, n):
  196.         s = ''
  197.         for ext in n.ext:
  198.             if isinstance(ext, c_ast.FuncDef):
  199.                 s += self.visit(ext)
  200.             else:
  201.                 s += self.visit(ext) + ';\n'
  202.         return s
  203.  
  204.     def visit_Compound(self, n):
  205.         #s = self._make_indent() + '{\n'
  206.         s = self._make_indent() + '\n'
  207.         self.indent_level += 2
  208.         if n.block_items:
  209.             s += ''.join(self._generate_stmt(stmt) for stmt in n.block_items)
  210.         self.indent_level -= 2
  211.         #s += self._make_indent() + '}\n'
  212.         s += self._make_indent() + '\n'
  213.         return s
  214.  
  215.     def visit_EmptyStatement(self, n):
  216.         return ';'
  217.  
  218.     def visit_ParamList(self, n, cdef=False):
  219.         return ', '.join(self.visit(param, cdef=cdef) for param in n.params)
  220.  
  221.     def visit_Return(self, n):
  222.         s = 'return'
  223.         if n.expr: s += ' ' + self.visit(n.expr)
  224.         return s + ';'
  225.  
  226.     def visit_Break(self, n):
  227.         return 'break;'
  228.  
  229.     def visit_Continue(self, n):
  230.         return 'continue;'
  231.  
  232.     def visit_TernaryOp(self, n):
  233.         s = self.visit(n.cond) + ' ? '
  234.         s += self.visit(n.iftrue) + ' : '
  235.         s += self.visit(n.iffalse)
  236.         return s
  237.  
  238.     def visit_If(self, n):
  239.         s = 'if ('
  240.         if n.cond: s += self.visit(n.cond)
  241.         s += '):\n'
  242.         s += self._generate_stmt(n.iftrue, add_indent=True)
  243.         if n.iffalse:
  244.             s += self._make_indent() + 'else:\n'
  245.             s += self._generate_stmt(n.iffalse, add_indent=True)
  246.         return s
  247.  
  248.  
  249.     def is_simple_for_loop(self, n):
  250.         if isinstance(n.init, c_ast.Assignment) and n.init.op=='=' and isinstance(n.init.lvalue, c_ast.ID):
  251.             if isinstance( n.init.rvalue, c_ast.Constant) and isinstance( n.cond, c_ast.BinaryOp):
  252.                 if isinstance( n.next, c_ast.UnaryOp ) and n.next.op == 'p++':
  253.                     return True
  254.         return False
  255.  
  256.     def visit_For(self, n):
  257.         if self.is_simple_for_loop( n ):
  258.             var = n.init.lvalue.name
  259.             start = n.init.rvalue.value
  260.             s = 'for %s from %s <= %s'%(var,start,var)
  261.             s += ' %s %s:\n'%(n.cond.op, n.cond.right.name)
  262.         else:  ## not cython yet TODO
  263.             s = 'for ('
  264.             if n.init: s += self.visit(n.init)
  265.             s += ';'
  266.             if n.cond: s += ' ' + self.visit(n.cond)
  267.             s += ';'
  268.             if n.next: s += ' ' + self.visit(n.next)
  269.             s += '):\n'
  270.         s += self._generate_stmt(n.stmt, add_indent=True)
  271.         return s
  272.  
  273.     def visit_While(self, n):
  274.         s = 'while ('
  275.         if n.cond: s += self.visit(n.cond)
  276.         s += '):\n'
  277.         s += self._generate_stmt(n.stmt, add_indent=True)
  278.         return s
  279.  
  280.     def visit_DoWhile(self, n):
  281.         s = 'do\n'
  282.         s += self._generate_stmt(n.stmt, add_indent=True)
  283.         s += self._make_indent() + 'while ('
  284.         if n.cond: s += self.visit(n.cond)
  285.         s += ');'
  286.         return s
  287.  
  288.     def visit_Switch(self, n):
  289.         s = 'switch (' + self.visit(n.cond) + ')\n'
  290.         s += self._generate_stmt(n.stmt, add_indent=True)
  291.         return s
  292.  
  293.     def visit_Case(self, n):
  294.         s = 'case ' + self.visit(n.expr) + ':\n'
  295.         for stmt in n.stmts:
  296.             s += self._generate_stmt(stmt, add_indent=True)
  297.         return s
  298.  
  299.     def visit_Default(self, n):
  300.         s = 'default:\n'
  301.         for stmt in n.stmts:
  302.             s += self._generate_stmt(stmt, add_indent=True)
  303.         return s
  304.  
  305.     def visit_Label(self, n):
  306.         return n.name + ':\n' + self._generate_stmt(n.stmt)
  307.  
  308.     def visit_Goto(self, n):
  309.         return 'goto ' + n.name + ';'
  310.  
  311.     def visit_EllipsisParam(self, n):
  312.         return '...'
  313.  
  314.     def visit_Struct(self, n):
  315.         return self._generate_struct_union(n, 'struct')
  316.  
  317.     def visit_Typename(self, n):
  318.         return self._generate_type(n.type)
  319.        
  320.     def visit_Union(self, n):
  321.         return self._generate_struct_union(n, 'union')
  322.  
  323.     def visit_NamedInitializer(self, n):
  324.         s = ''
  325.         for name in n.name:
  326.             if isinstance(name, c_ast.ID):
  327.                 s += '.' + name.name
  328.             elif isinstance(name, c_ast.Constant):
  329.                 s += '[' + name.value + ']'
  330.         s += ' = ' + self.visit(n.expr)
  331.         return s
  332.  
  333.     def _generate_struct_union(self, n, name):
  334.         """ Generates code for structs and unions. name should be either
  335.            'struct' or union.
  336.        """
  337.         a = 'cdef ' + name + ' ' + (n.name or '') + ':'
  338.         if n.decls:
  339.             s = '\n'
  340.             s += self._make_indent()
  341.             self.indent_level += 2
  342.             for decl in n.decls:
  343.                 s += self._generate_stmt(decl)
  344.             self.indent_level -= 2
  345.             s += self._make_indent()
  346.         return a + s.replace('cdef ', '')
  347.  
  348.     def _generate_struct_union_as_class(self, n, name):
  349.         """ Generates code for structs and unions. name should be either
  350.            'struct' or union.
  351.        """
  352.         assert n.name ## TODO unnamed structs
  353.         s = 'cdef class %s:'%n.name
  354.         if n.decls:
  355.             s += '\n'
  356.             s += self._make_indent()
  357.             self.indent_level += 2
  358.             for decl in n.decls:
  359.                 s += self._generate_stmt(decl)
  360.             self.indent_level -= 2
  361.             s += self._make_indent()
  362.  
  363.         return s
  364.  
  365.  
  366.     def _generate_stmt(self, n, add_indent=False):
  367.         """ Generation from a statement node. This method exists as a wrapper
  368.            for individual visit_* methods to handle different treatment of
  369.            some statements in this context.
  370.        """
  371.         typ = type(n)
  372.         if add_indent: self.indent_level += 2
  373.         indent = self._make_indent()
  374.         if add_indent: self.indent_level -= 2
  375.        
  376.         if typ in (
  377.                 c_ast.Decl, c_ast.Assignment, c_ast.Cast, c_ast.UnaryOp,
  378.                 c_ast.BinaryOp, c_ast.TernaryOp, c_ast.FuncCall, c_ast.ArrayRef,
  379.                 c_ast.StructRef, c_ast.Constant, c_ast.ID, c_ast.Typedef):
  380.             # These can also appear in an expression context so no semicolon
  381.             # is added to them automatically
  382.             #
  383.             return indent + self.visit(n) + ';\n'
  384.         elif typ in (c_ast.Compound,):
  385.             # No extra indentation required before the opening brace of a
  386.             # compound - because it consists of multiple lines it has to
  387.             # compute its own indentation.
  388.             #
  389.             return self.visit(n)
  390.         else:
  391.             return indent + self.visit(n) + '\n'
  392.  
  393.     def _generate_decl(self, n):
  394.         """ Generation from a Decl node.
  395.        """
  396.         s = ''
  397.         if n.funcspec: s = ' '.join(n.funcspec) + ' '
  398.         if n.storage: s += ' '.join(n.storage) + ' '
  399.         s += self._generate_type(n.type)
  400.         return s
  401.    
  402.     def _generate_type(self, n, modifiers=[]):
  403.         """ Recursive generation from a type node. n is the type node.
  404.            modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
  405.            encountered on the way down to a TypeDecl, to allow proper
  406.            generation from it.
  407.        """
  408.         typ = type(n)
  409.         #~ print(n, modifiers)
  410.        
  411.         if typ == c_ast.TypeDecl:
  412.             s = ''
  413.             if n.quals: s += ' '.join(n.quals) + ' '
  414.             s += self.visit(n.type)
  415.            
  416.             nstr = n.declname if n.declname else ''
  417.             # Resolve modifiers.
  418.             # Wrap in parens to distinguish pointer to array and pointer to
  419.             # function syntax.
  420.             #
  421.             for i, modifier in enumerate(modifiers):
  422.                 if isinstance(modifier, c_ast.ArrayDecl):
  423.                     if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
  424.                         nstr = '(' + nstr + ')'
  425.                     nstr += '[' + self.visit(modifier.dim) + ']'
  426.                 elif isinstance(modifier, c_ast.FuncDecl):
  427.                     if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
  428.                         nstr = '(' + nstr + ')'
  429.                     nstr += '(' + self.visit(modifier.args) + ')'
  430.                 elif isinstance(modifier, c_ast.PtrDecl):
  431.                     if modifier.quals:
  432.                         nstr = '* %s %s' % (' '.join(modifier.quals), nstr)
  433.                     else:
  434.                         nstr = '*' + nstr
  435.             if nstr: s += ' ' + nstr
  436.             return s
  437.         elif typ == c_ast.Decl:
  438.             return self._generate_decl(n.type)
  439.         elif typ == c_ast.Typename:
  440.             return self._generate_type(n.type)
  441.         elif typ == c_ast.IdentifierType:
  442.             return ' '.join(n.names) + ' '
  443.         elif typ in (c_ast.ArrayDecl, c_ast.PtrDecl, c_ast.FuncDecl):
  444.             return self._generate_type(n.type, modifiers + [n])
  445.         else:
  446.             return self.visit(n)
  447.  
  448.     def _parenthesize_if(self, n, condition):
  449.         """ Visits 'n' and returns its string representation, parenthesized
  450.            if the condition function applied to the node returns True.
  451.        """
  452.         s = self.visit(n)
  453.         if condition(n):
  454.             return '(' + s + ')'
  455.         else:
  456.             return s
  457.  
  458.     def _parenthesize_unless_simple(self, n):
  459.         """ Common use case for _parenthesize_if
  460.        """
  461.         return self._parenthesize_if(n, lambda d: not self._is_simple_node(d))
  462.  
  463.     def _is_simple_node(self, n):
  464.         """ Returns True for nodes that are "simple" - i.e. nodes that always
  465.            have higher precedence than operators.
  466.        """
  467.         return isinstance(n,(   c_ast.Constant, c_ast.ID, c_ast.ArrayRef,
  468.                                 c_ast.StructRef, c_ast.FuncCall))
RAW Paste Data
Want to get better at Python?
Learn to code Python in 2017
Pastebin PRO Summer Special!
Get 40% OFF on Pastebin PRO accounts!
Top