blob: 713cdd3b8b19191678d270808c23692e2b16a6f7 [file] [log] [blame]
eli.benderskyd5ba3452011-02-18 21:32:47 +02001#-----------------------------------------------------------------
2# pycparser: c-to-c.py
3#
eli.benderskyafcfaac2011-02-25 16:46:01 +02004# Example of a C code generator from pycparser AST nodes, serving
5# as a simplistic translator from C to AST and back to C.
eli.benderskyb36f5bb2011-03-06 07:22:33 +02006# Note: at this stage, the example is "alpha release" and considered
7# experimental. Please file any bugs you find in the Issues page on pycparser's
8# website.
eli.benderskyd5ba3452011-02-18 21:32:47 +02009#
10# Copyright (C) 2008-2011, Eli Bendersky
eli.bendersky84a6a632011-04-29 09:00:43 +030011# License: BSD
eli.benderskyd5ba3452011-02-18 21:32:47 +020012#-----------------------------------------------------------------
13from __future__ import print_function
14import sys
15
16# This is not required if you've installed pycparser into
17# your site-packages/ with setup.py
18#
19sys.path.insert(0, '..')
20
21from pycparser import c_parser, c_ast, parse_file
22
23
eli.benderskyafcfaac2011-02-25 16:46:01 +020024class CGenerator(object):
25 """ Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
26 return a value from each visit method, using string accumulation in
27 generic_visit.
28 """
eli.benderskyd5ba3452011-02-18 21:32:47 +020029 def __init__(self):
30 self.output = ''
31
eli.bendersky3ae9f7a2011-02-27 07:19:41 +020032 # Statements start with indentation of self.indent_level spaces, using
33 # the _make_indent method
eli.benderskyafcfaac2011-02-25 16:46:01 +020034 #
35 self.indent_level = 0
36
eli.bendersky3ae9f7a2011-02-27 07:19:41 +020037 def _make_indent(self):
38 return ' ' * self.indent_level
39
eli.benderskyafcfaac2011-02-25 16:46:01 +020040 def visit(self, node):
41 method = 'visit_' + node.__class__.__name__
42 return getattr(self, method, self.generic_visit)(node)
43
44 def generic_visit(self, node):
eli.benderskydcb859c2011-03-05 17:02:43 +020045 #~ print('generic:', type(node))
eli.benderskyafcfaac2011-02-25 16:46:01 +020046 if node is None:
47 return ''
48 else:
49 return ''.join(self.visit(c) for c in node.children())
eli.benderskyd5ba3452011-02-18 21:32:47 +020050
51 def visit_Constant(self, n):
eli.benderskyafcfaac2011-02-25 16:46:01 +020052 return n.value
53
eli.benderskyd5ba3452011-02-18 21:32:47 +020054 def visit_ID(self, n):
eli.benderskyafcfaac2011-02-25 16:46:01 +020055 return n.name
eli.bendersky3ae9f7a2011-02-27 07:19:41 +020056
57 def visit_ArrayRef(self, n):
eli.benderskyb36f5bb2011-03-06 07:22:33 +020058 arrref = self._parenthesize_unless_simple(n.name)
59 return arrref + '[' + self.visit(n.subscript) + ']'
eli.bendersky3ae9f7a2011-02-27 07:19:41 +020060
eli.bendersky724b1cc2011-03-05 10:45:08 +020061 def visit_StructRef(self, n):
eli.benderskyb36f5bb2011-03-06 07:22:33 +020062 sref = self._parenthesize_unless_simple(n.name)
63 return sref + n.type + self.visit(n.field)
eli.bendersky724b1cc2011-03-05 10:45:08 +020064
65 def visit_FuncCall(self, n):
eli.benderskyb36f5bb2011-03-06 07:22:33 +020066 fref = self._parenthesize_unless_simple(n.name)
67 return fref + '(' + self.visit(n.args) + ')'
eli.bendersky724b1cc2011-03-05 10:45:08 +020068
eli.benderskyae36e962011-02-27 08:25:05 +020069 def visit_UnaryOp(self, n):
eli.benderskyb36f5bb2011-03-06 07:22:33 +020070 operand = self._parenthesize_unless_simple(n.expr)
eli.benderskyae36e962011-02-27 08:25:05 +020071 if n.op == 'p++':
eli.benderskyb36f5bb2011-03-06 07:22:33 +020072 return '%s++' % operand
eli.bendersky8348a9d2011-05-26 07:01:43 +030073 elif n.op == 'sizeof':
74 # Always parenthesize the argument of sizeof since it can be
75 # a name.
76 return 'sizeof(%s)' % self.visit(n.expr)
eli.benderskyae36e962011-02-27 08:25:05 +020077 else:
eli.benderskyb36f5bb2011-03-06 07:22:33 +020078 return '%s%s' % (n.op, operand)
eli.benderskyae36e962011-02-27 08:25:05 +020079
eli.bendersky3ae9f7a2011-02-27 07:19:41 +020080 def visit_BinaryOp(self, n):
eli.benderskyb36f5bb2011-03-06 07:22:33 +020081 lval_str = self._parenthesize_if(n.left,
82 lambda d: not self._is_simple_node(d))
83 rval_str = self._parenthesize_if(n.right,
84 lambda d: not self._is_simple_node(d))
eli.bendersky724b1cc2011-03-05 10:45:08 +020085 return '%s %s %s' % (lval_str, n.op, rval_str)
eli.bendersky3ae9f7a2011-02-27 07:19:41 +020086
87 def visit_Assignment(self, n):
eli.bendersky724b1cc2011-03-05 10:45:08 +020088 rval_str = self._parenthesize_if(
89 n.rvalue,
90 lambda n: isinstance(n, c_ast.Assignment))
91 return '%s %s %s' % (self.visit(n.lvalue), n.op, rval_str)
eli.benderskyd5ba3452011-02-18 21:32:47 +020092
93 def visit_IdentifierType(self, n):
eli.bendersky3ae9f7a2011-02-27 07:19:41 +020094 return ' '.join(n.names)
eli.benderskyd5ba3452011-02-18 21:32:47 +020095
eli.benderskyabb96e62011-03-05 16:30:05 +020096 def visit_Decl(self, n, no_type=False):
97 # no_type is used when a Decl is part of a DeclList, where the type is
98 # explicitly only for the first delaration in a list.
99 #
100 s = n.name if no_type else self._generate_decl(n)
eli.benderskyafcfaac2011-02-25 16:46:01 +0200101 if n.bitsize: s += ' : ' + self.visit(n.bitsize)
eli.benderskydcb859c2011-03-05 17:02:43 +0200102 if n.init:
103 if isinstance(n.init, c_ast.ExprList):
104 s += ' = {' + self.visit(n.init) + '}'
105 else:
106 s += ' = ' + self.visit(n.init)
eli.benderskyafcfaac2011-02-25 16:46:01 +0200107 return s
eli.benderskyd5ba3452011-02-18 21:32:47 +0200108
eli.benderskyabb96e62011-03-05 16:30:05 +0200109 def visit_DeclList(self, n):
110 s = self.visit(n.decls[0])
111 if len(n.decls) > 1:
112 s += ', ' + ', '.join(self.visit_Decl(decl, no_type=True)
113 for decl in n.decls[1:])
114 return s
115
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200116 def visit_Typedef(self, n):
117 s = ''
118 if n.storage: s += ' '.join(n.storage) + ' '
119 s += self._generate_type(n.type)
120 return s
121
122 def visit_Cast(self, n):
eli.bendersky6ed80a62011-05-09 18:22:33 +0300123 s = '(' + self._generate_type(n.to_type) + ')'
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200124 return s + ' ' + self.visit(n.expr)
125
eli.bendersky724b1cc2011-03-05 10:45:08 +0200126 def visit_ExprList(self, n):
eli.bendersky8e6c5862011-05-20 12:35:08 +0300127 visited_subexprs = []
128 for expr in n.exprs:
129 if isinstance(expr, c_ast.ExprList):
130 visited_subexprs.append('{' + self.visit(expr) + '}')
131 else:
132 visited_subexprs.append(self.visit(expr))
133 return ', '.join(visited_subexprs)
eli.bendersky724b1cc2011-03-05 10:45:08 +0200134
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200135 def visit_Enum(self, n):
136 s = 'enum'
137 if n.name: s += ' ' + n.name
138 if n.values:
139 s += ' {'
140 for i, enumerator in enumerate(n.values.enumerators):
141 s += enumerator.name
142 if enumerator.value:
143 s += ' = ' + self.visit(enumerator.value)
144 if i != len(n.values.enumerators) - 1:
145 s += ', '
146 s += '}'
147 return s
148
149 def visit_Struct(self, n):
150 s = 'struct'
151 if n.name: s += ' ' + n.name
152 if n.decls:
153 s += ' { \n'
154 for decl in n.decls:
155 s += ' ' + self.visit(decl) + ';\n'
156 s += '}'
157 return s
158
eli.benderskyafcfaac2011-02-25 16:46:01 +0200159 def visit_FuncDef(self, n):
160 decl = self.visit(n.decl)
161 self.indent_level = 0
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200162 # The body is a Compound node
eli.benderskyafcfaac2011-02-25 16:46:01 +0200163 body = self.visit(n.body)
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200164 return decl + '\n' + body + '\n'
165
166 def visit_FileAST(self, n):
167 s = ''
168 for ext in n.ext:
169 if isinstance(ext, c_ast.FuncDef):
170 s += self.visit(ext)
171 else:
172 s += self.visit(ext) + ';\n'
173 return s
174
175 def visit_Compound(self, n):
176 s = self._make_indent() + '{\n'
177 self.indent_level += 2
eli.benderskycad1cfd2011-05-26 06:56:27 +0300178 if n.block_items:
179 s += ''.join(self._generate_stmt(stmt) for stmt in n.block_items)
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200180 self.indent_level -= 2
181 s += self._make_indent() + '}\n'
182 return s
183
184 def visit_ParamList(self, n):
185 return ', '.join(self.visit(param) for param in n.params)
186
187 def visit_Return(self, n):
188 s = 'return'
189 if n.expr: s += ' ' + self.visit(n.expr)
190 return s + ';'
191
eli.benderskyfc96e5e2011-03-04 09:51:23 +0200192 def visit_Break(self, n):
193 return 'break;'
194
195 def visit_Continue(self, n):
196 return 'continue;'
eli.bendersky724b1cc2011-03-05 10:45:08 +0200197
198 def visit_TernaryOp(self, n):
199 s = self.visit(n.cond) + ' ? '
200 s += self.visit(n.iftrue) + ' : '
201 s += self.visit(n.iffalse)
202 return s
203
eli.benderskye6ecb1a2011-03-05 10:58:46 +0200204 def visit_If(self, n):
205 s = 'if ('
206 if n.cond: s += self.visit(n.cond)
207 s += ')\n'
208 s += self._generate_stmt(n.iftrue, add_indent=True)
209 if n.iffalse:
210 s += self._make_indent() + 'else\n'
211 s += self._generate_stmt(n.iffalse, add_indent=True)
212 return s
213
eli.benderskyae36e962011-02-27 08:25:05 +0200214 def visit_For(self, n):
215 s = 'for ('
216 if n.init: s += self.visit(n.init)
217 s += ';'
218 if n.cond: s += ' ' + self.visit(n.cond)
219 s += ';'
220 if n.next: s += ' ' + self.visit(n.next)
221 s += ')\n'
222 s += self._generate_stmt(n.stmt, add_indent=True)
223 return s
224
eli.benderskyfc96e5e2011-03-04 09:51:23 +0200225 def visit_While(self, n):
226 s = 'while ('
227 if n.cond: s += self.visit(n.cond)
228 s += ')\n'
229 s += self._generate_stmt(n.stmt, add_indent=True)
230 return s
231
eli.benderskye6ecb1a2011-03-05 10:58:46 +0200232 def visit_DoWhile(self, n):
233 s = 'do\n'
234 s += self._generate_stmt(n.stmt, add_indent=True)
235 s += self._make_indent() + 'while ('
236 if n.cond: s += self.visit(n.cond)
237 s += ');'
238 return s
239
eli.benderskyabb96e62011-03-05 16:30:05 +0200240 def visit_Switch(self, n):
241 s = 'switch (' + self.visit(n.cond) + ')\n'
242 s += self._generate_stmt(n.stmt, add_indent=True)
243 return s
244
245 def visit_Case(self, n):
246 s = 'case ' + self.visit(n.expr) + ':\n'
247 s += self._generate_stmt(n.stmt, add_indent=True)
248 return s
249
250 def visit_Default(self, n):
251 return 'default:\n' + self._generate_stmt(n.stmt, add_indent=True)
252
253 def visit_Label(self, n):
254 return n.name + ':\n' + self._generate_stmt(n.stmt)
255
256 def visit_Goto(self, n):
257 return 'goto ' + n.name + ';'
258
eli.benderskye6ecb1a2011-03-05 10:58:46 +0200259 def visit_EllipsisParam(self, n):
260 return '...'
261
eli.benderskyabb96e62011-03-05 16:30:05 +0200262 def visit_Struct(self, n):
263 return self._generate_struct_union(n, 'struct')
264
eli.bendersky8e6c5862011-05-20 12:35:08 +0300265 def visit_Typename(self, n):
266 return self._generate_type(n.type)
267
eli.benderskyabb96e62011-03-05 16:30:05 +0200268 def visit_Union(self, n):
269 return self._generate_struct_union(n, 'union')
270
eli.benderskydcb859c2011-03-05 17:02:43 +0200271 def visit_NamedInitializer(self, n):
272 s = ''
273 for name in n.name:
274 if isinstance(name, c_ast.ID):
275 s += '.' + name.name
276 elif isinstance(name, c_ast.Constant):
277 s += '[' + name.value + ']'
278 s += ' = ' + self.visit(n.expr)
279 return s
280
eli.benderskyabb96e62011-03-05 16:30:05 +0200281 def _generate_struct_union(self, n, name):
282 """ Generates code for structs and unions. name should be either
283 'struct' or union.
284 """
eli.benderskydcb859c2011-03-05 17:02:43 +0200285 s = name + ' ' + (n.name or '')
286 if n.decls:
287 s += '\n'
288 s += self._make_indent()
289 self.indent_level += 2
290 s += '{\n'
291 for decl in n.decls:
292 s += self._generate_stmt(decl)
293 self.indent_level -= 2
294 s += self._make_indent() + '}'
eli.benderskyabb96e62011-03-05 16:30:05 +0200295 return s
296
eli.benderskyae36e962011-02-27 08:25:05 +0200297 def _generate_stmt(self, n, add_indent=False):
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200298 """ Generation from a statement node. This method exists as a wrapper
299 for individual visit_* methods to handle different treatment of
300 some statements in this context.
301 """
302 typ = type(n)
eli.benderskyae36e962011-02-27 08:25:05 +0200303 if add_indent: self.indent_level += 2
eli.benderskyfc96e5e2011-03-04 09:51:23 +0200304 indent = self._make_indent()
eli.benderskyae36e962011-02-27 08:25:05 +0200305 if add_indent: self.indent_level -= 2
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200306
eli.bendersky724b1cc2011-03-05 10:45:08 +0200307 if typ in (
308 c_ast.Decl, c_ast.Assignment, c_ast.Cast, c_ast.UnaryOp,
eli.benderskyb36f5bb2011-03-06 07:22:33 +0200309 c_ast.BinaryOp, c_ast.TernaryOp, c_ast.FuncCall, c_ast.ArrayRef,
310 c_ast.StructRef):
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200311 # These can also appear in an expression context so no semicolon
312 # is added to them automatically
313 #
eli.benderskyfc96e5e2011-03-04 09:51:23 +0200314 return indent + self.visit(n) + ';\n'
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200315 elif typ in (c_ast.Compound,):
316 # No extra indentation required before the opening brace of a
317 # compound - because it consists of multiple lines it has to
318 # compute its own indentation.
319 #
eli.benderskyae36e962011-02-27 08:25:05 +0200320 return self.visit(n)
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200321 else:
eli.benderskyfc96e5e2011-03-04 09:51:23 +0200322 return indent + self.visit(n) + '\n'
eli.benderskyafcfaac2011-02-25 16:46:01 +0200323
eli.benderskyd5ba3452011-02-18 21:32:47 +0200324 def _generate_decl(self, n):
325 """ Generation from a Decl node.
326 """
eli.benderskyafcfaac2011-02-25 16:46:01 +0200327 s = ''
328 if n.funcspec: s = ' '.join(n.funcspec) + ' '
329 if n.storage: s += ' '.join(n.storage) + ' '
330 s += self._generate_type(n.type)
331 return s
eli.benderskyd5ba3452011-02-18 21:32:47 +0200332
333 def _generate_type(self, n, modifiers=[]):
334 """ Recursive generation from a type node. n is the type node.
eli.benderskyafcfaac2011-02-25 16:46:01 +0200335 modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
336 encountered on the way down to a TypeDecl, to allow proper
337 generation from it.
eli.benderskyd5ba3452011-02-18 21:32:47 +0200338 """
339 typ = type(n)
340 #~ print(n, modifiers)
341
342 if typ == c_ast.TypeDecl:
eli.benderskyafcfaac2011-02-25 16:46:01 +0200343 s = ''
344 if n.quals: s += ' '.join(n.quals) + ' '
345 s += self.visit(n.type)
eli.benderskyd5ba3452011-02-18 21:32:47 +0200346
347 nstr = n.declname if n.declname else ''
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200348 # Resolve modifiers.
eli.benderskyafcfaac2011-02-25 16:46:01 +0200349 # Wrap in parens to distinguish pointer to array and pointer to
350 # function syntax.
eli.benderskyd5ba3452011-02-18 21:32:47 +0200351 #
352 for i, modifier in enumerate(modifiers):
353 if isinstance(modifier, c_ast.ArrayDecl):
354 if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
355 nstr = '(' + nstr + ')'
eli.benderskyafcfaac2011-02-25 16:46:01 +0200356 nstr += '[' + self.visit(modifier.dim) + ']'
357 elif isinstance(modifier, c_ast.FuncDecl):
358 if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
359 nstr = '(' + nstr + ')'
360 nstr += '(' + self.visit(modifier.args) + ')'
eli.benderskyd5ba3452011-02-18 21:32:47 +0200361 elif isinstance(modifier, c_ast.PtrDecl):
362 nstr = '*' + nstr
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200363 s += ' ' + nstr
eli.benderskyafcfaac2011-02-25 16:46:01 +0200364 return s
eli.bendersky6ed80a62011-05-09 18:22:33 +0300365 elif typ == c_ast.Decl:
eli.benderskyafcfaac2011-02-25 16:46:01 +0200366 return self._generate_decl(n.type)
eli.bendersky6ed80a62011-05-09 18:22:33 +0300367 elif typ == c_ast.Typename:
368 return self._generate_type(n.type)
eli.benderskyd5ba3452011-02-18 21:32:47 +0200369 elif typ == c_ast.IdentifierType:
eli.benderskyafcfaac2011-02-25 16:46:01 +0200370 return ' '.join(n.names) + ' '
371 elif typ in (c_ast.ArrayDecl, c_ast.PtrDecl, c_ast.FuncDecl):
372 return self._generate_type(n.type, modifiers + [n])
eli.benderskyabb96e62011-03-05 16:30:05 +0200373 else:
374 return self.visit(n)
eli.benderskyd5ba3452011-02-18 21:32:47 +0200375
eli.bendersky724b1cc2011-03-05 10:45:08 +0200376 def _parenthesize_if(self, n, condition):
377 """ Visits 'n' and returns its string representation, parenthesized
378 if the condition function applied to the node returns True.
379 """
380 s = self.visit(n)
381 if condition(n):
382 return '(' + s + ')'
383 else:
384 return s
385
eli.benderskyb36f5bb2011-03-06 07:22:33 +0200386 def _parenthesize_unless_simple(self, n):
387 """ Common use case for _parenthesize_if
388 """
389 return self._parenthesize_if(n, lambda d: not self._is_simple_node(d))
390
391 def _is_simple_node(self, n):
392 """ Returns True for nodes that are "simple" - i.e. nodes that always
393 have higher precedence than operators.
394 """
395 return isinstance(n,( c_ast.Constant, c_ast.ID, c_ast.ArrayRef,
396 c_ast.StructRef, c_ast.FuncCall))
397
eli.benderskyd5ba3452011-02-18 21:32:47 +0200398
399def translate_to_c(filename):
400 ast = parse_file(filename, use_cpp=True)
401 generator = CGenerator()
eli.benderskyafcfaac2011-02-25 16:46:01 +0200402 print(generator.visit(ast))
eli.benderskyd5ba3452011-02-18 21:32:47 +0200403
404
eli.benderskyb36f5bb2011-03-06 07:22:33 +0200405def zz_test_translate():
406 # internal use
eli.bendersky8e6c5862011-05-20 12:35:08 +0300407 src = r'''
eli.bendersky8348a9d2011-05-26 07:01:43 +0300408int main(void)
409{
410 unsigned size;
411 size = sizeof(size);
412 return 0;
413}
414'''
eli.bendersky8e6c5862011-05-20 12:35:08 +0300415 parser = c_parser.CParser()
416 ast = parser.parse(src)
417 ast.show()
418 generator = CGenerator()
419
420 print(generator.visit(ast))
421
422 # tracing the generator for debugging
423 #~ import trace
424 #~ tr = trace.Trace(countcallers=1)
425 #~ tr.runfunc(generator.visit, ast)
426 #~ tr.results().write_results()
eli.benderskyb36f5bb2011-03-06 07:22:33 +0200427
428
429#------------------------------------------------------------------------------
430if __name__ == "__main__":
eli.bendersky6ed80a62011-05-09 18:22:33 +0300431 zz_test_translate()
eli.benderskyb36f5bb2011-03-06 07:22:33 +0200432 if len(sys.argv) > 1:
433 translate_to_c(sys.argv[1])
434 else:
eli.benderskyd5ba3452011-02-18 21:32:47 +0200435 print("Please provide a filename as argument")
eli.bendersky3ae9f7a2011-02-27 07:19:41 +0200436