Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / pycparser / 203b967867976e2d385fcb9d5bd25f83e1f53ba2 / . / tests / test_c_parser.py
blob: e7b6c6783c65f01aab94795e204f335934133632 [file] [log] [blame]
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1#!/usr/bin/env python
2
3import pprint
4import re
Eli Benderskyd0973782012-01-19 08:09:33 +0200[diff] [blame]5import os, sys
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]6import unittest
7
8sys.path.insert(0, '..')
9
10from pycparser import c_parser
11from pycparser.c_ast import *
12from pycparser.c_parser import CParser, Coord, ParseError
13
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]14_c_parser = c_parser.CParser(
15 lex_optimize=False,
16 yacc_debug=True,
17 yacc_optimize=False,
18 yacctab='yacctab')
19
20
21def expand_decl(decl):
22 """ Converts the declaration into a nested list.
23 """
24 typ = type(decl)
25
26 if typ == TypeDecl:
27 return ['TypeDecl', expand_decl(decl.type)]
28 elif typ == IdentifierType:
29 return ['IdentifierType', decl.names]
30 elif typ == ID:
31 return ['ID', decl.name]
32 elif typ in [Struct, Union]:
33 decls = [expand_decl(d) for d in decl.decls or []]
34 return [typ.__name__, decl.name, decls]
35 else:
36 nested = expand_decl(decl.type)
37
38 if typ == Decl:
39 if decl.quals:
40 return ['Decl', decl.quals, decl.name, nested]
41 else:
42 return ['Decl', decl.name, nested]
43 elif typ == Typename: # for function parameters
44 if decl.quals:
45 return ['Typename', decl.quals, nested]
46 else:
47 return ['Typename', nested]
48 elif typ == ArrayDecl:
49 dimval = decl.dim.value if decl.dim else ''
50 return ['ArrayDecl', dimval, nested]
51 elif typ == PtrDecl:
52 return ['PtrDecl', nested]
53 elif typ == Typedef:
54 return ['Typedef', decl.name, nested]
55 elif typ == FuncDecl:
56 if decl.args:
57 params = [expand_decl(param) for param in decl.args.params]
58 else:
59 params = []
60 return ['FuncDecl', params, nested]
61
62
63def expand_init(init):
64 """ Converts an initialization into a nested list
65 """
66 typ = type(init)
67
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]68 if typ == NamedInitializer:
69 des = [expand_init(dp) for dp in init.name]
70 return (des, expand_init(init.expr))
71 elif typ == ExprList:
72 return [expand_init(expr) for expr in init.exprs]
73 elif typ == Constant:
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]74 return ['Constant', init.type, init.value]
75 elif typ == ID:
76 return ['ID', init.name]
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]77
78
eli.bendersky85d2e732011-05-20 19:47:26 +0300[diff] [blame]79class TestCParser_base(unittest.TestCase):
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]80 def parse(self, txt, filename=''):
81 return self.cparser.parse(txt, filename)
82
83 def setUp(self):
84 self.cparser = _c_parser
85
eli.bendersky85d2e732011-05-20 19:47:26 +0300[diff] [blame]86
87class TestCParser_fundamentals(TestCParser_base):
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]88 def get_decl(self, txt, index=0):
89 """ Given a source and an index returns the expanded
90 declaration at that index.
91
92 FileAST holds a list of 'external declarations'.
93 index is the offset of the desired declaration in that
94 list.
95 """
96 t = self.parse(txt).ext[index]
97 return expand_decl(t)
98
99 def get_decl_init(self, txt, index=0):
100 """ Returns the expanded initializer of the declaration
101 at index.
102 """
103 t = self.parse(txt).ext[index]
104 return expand_init(t.init)
105
106 def test_FileAST(self):
107 t = self.parse('int a; char c;')
108 self.failUnless(isinstance(t, FileAST))
109 self.assertEqual(len(t.ext), 2)
eli.bendersky43cf0b22011-10-19 05:56:15 +0200[diff] [blame]110
111 # empty file
112 t2 = self.parse('')
113 self.failUnless(isinstance(t2, FileAST))
114 self.assertEqual(len(t2.ext), 0)
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]115
eli.bendersky38165b72011-02-04 08:13:39 +0200[diff] [blame]116 def test_empty_toplevel_decl(self):
117 code = 'int foo;;'
118 t = self.parse(code)
119 self.failUnless(isinstance(t, FileAST))
120 self.assertEqual(len(t.ext), 1)
121 self.assertEqual(self.get_decl(code),
122 ['Decl', 'foo',
123 ['TypeDecl', ['IdentifierType', ['int']]]])
124
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]125 def assert_coord(self, node, line, file=None):
126 self.assertEqual(node.coord.line, line)
127 if file:
128 self.assertEqual(node.coord.file, file)
129
130 def test_coords(self):
eli.bendersky38165b72011-02-04 08:13:39 +0200[diff] [blame]131 """ Tests the "coordinates" of parsed elements - file
132 name and line numbers, with modification insterted by
133 #line directives.
134 """
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]135 self.assert_coord(self.parse('int a;').ext[0], 1)
136
137 t1 = """
138 int a;
139 int b;\n\n
140 int c;
141 """
142 f1 = self.parse(t1, filename='test.c')
143 self.assert_coord(f1.ext[0], 2, 'test.c')
144 self.assert_coord(f1.ext[1], 3, 'test.c')
145 self.assert_coord(f1.ext[2], 6, 'test.c')
146
147 t1_1 = '''
148 int main() {
149 k = p;
150 printf("%d", b);
151 return 0;
152 }'''
153 f1_1 = self.parse(t1_1, filename='test.c')
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]154 self.assert_coord(f1_1.ext[0].body.block_items[0], 3, 'test.c')
155 self.assert_coord(f1_1.ext[0].body.block_items[1], 4, 'test.c')
eli.benderskyfc96e5e2011-03-04 09:51:23 +0200[diff] [blame]156
157 t1_2 = '''
158 int main () {
159 int p = (int) k;
160 }'''
161 f1_2 = self.parse(t1_2, filename='test.c')
162 # make sure that the Cast has a coord (issue 23)
163 self.assert_coord(f1_2.ext[0].body.block_items[0].init, 3, 'test.c')
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]164
165 t2 = """
166 #line 99
167 int c;
168 """
169 self.assert_coord(self.parse(t2).ext[0], 99)
170
171 t3 = """
172 int dsf;
173 char p;
174 #line 3000 "in.h"
175 char d;
176 """
177 f3 = self.parse(t3, filename='test.c')
178 self.assert_coord(f3.ext[0], 2, 'test.c')
179 self.assert_coord(f3.ext[1], 3, 'test.c')
180 self.assert_coord(f3.ext[2], 3000, 'in.h')
181
182 t4 = """
183 #line 20 "restore.h"
184 int maydler(char);
185
186 #line 30 "includes/daween.ph"
187 long j, k;
188
189 #line 50000
190 char* ro;
191 """
192 f4 = self.parse(t4, filename='myb.c')
193 self.assert_coord(f4.ext[0], 20, 'restore.h')
194 self.assert_coord(f4.ext[1], 30, 'includes/daween.ph')
195 self.assert_coord(f4.ext[2], 30, 'includes/daween.ph')
196 self.assert_coord(f4.ext[3], 50000, 'includes/daween.ph')
197
198 t5 = """
199 int
200 #line 99
201 c;
202 """
203 self.assert_coord(self.parse(t5).ext[0], 99)
204
Eli Bendersky203b9672012-06-15 10:11:24 +0300[diff] [blame^]205 # coord for ellipsis
206 t6 = """
207 int foo(int j,
208 ...) {
209 }"""
210 f6 = self.parse(t6, filename='z.c')
211 self.assert_coord(self.parse(t6).ext[0].decl.type.args.params[1], 3)
212
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]213 def test_simple_decls(self):
214 self.assertEqual(self.get_decl('int a;'),
215 ['Decl', 'a', ['TypeDecl', ['IdentifierType', ['int']]]])
216
217 self.assertEqual(self.get_decl('unsigned int a;'),
Eli Bendersky68497c22012-01-19 06:04:58 +0200[diff] [blame]218 ['Decl', 'a', ['TypeDecl', ['IdentifierType', ['unsigned', 'int']]]])
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]219
eli.benderskyaffe0322011-09-24 06:16:55 +0300[diff] [blame]220 self.assertEqual(self.get_decl('_Bool a;'),
221 ['Decl', 'a', ['TypeDecl', ['IdentifierType', ['_Bool']]]])
222
Eli Benderskyf4d73462012-01-19 05:56:27 +0200[diff] [blame]223 self.assertEqual(self.get_decl('float _Complex fcc;'),
Eli Bendersky68497c22012-01-19 06:04:58 +0200[diff] [blame]224 ['Decl', 'fcc', ['TypeDecl', ['IdentifierType', ['float', '_Complex']]]])
Eli Benderskyf4d73462012-01-19 05:56:27 +0200[diff] [blame]225
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]226 self.assertEqual(self.get_decl('char* string;'),
227 ['Decl', 'string',
228 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]])
229
230 self.assertEqual(self.get_decl('long ar[15];'),
231 ['Decl', 'ar',
232 ['ArrayDecl', '15',
233 ['TypeDecl', ['IdentifierType', ['long']]]]])
eli.bendersky98f45372010-10-30 09:46:29 +0200[diff] [blame]234
235 self.assertEqual(self.get_decl('long long ar[15];'),
236 ['Decl', 'ar',
237 ['ArrayDecl', '15',
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]238 ['TypeDecl', ['IdentifierType', ['long', 'long']]]]])
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]239
240 self.assertEqual(self.get_decl('unsigned ar[];'),
241 ['Decl', 'ar',
242 ['ArrayDecl', '',
243 ['TypeDecl', ['IdentifierType', ['unsigned']]]]])
244
245 self.assertEqual(self.get_decl('int strlen(char* s);'),
246 ['Decl', 'strlen',
247 ['FuncDecl',
248 [['Decl', 's',
249 ['PtrDecl',
250 ['TypeDecl', ['IdentifierType', ['char']]]]]],
251 ['TypeDecl', ['IdentifierType', ['int']]]]])
252
253 self.assertEqual(self.get_decl('int strcmp(char* s1, char* s2);'),
254 ['Decl', 'strcmp',
255 ['FuncDecl',
256 [ ['Decl', 's1',
257 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]],
258 ['Decl', 's2',
259 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]]
260 ],
261 ['TypeDecl', ['IdentifierType', ['int']]]]])
262
263 def test_nested_decls(self): # the fun begins
264 self.assertEqual(self.get_decl('char** ar2D;'),
265 ['Decl', 'ar2D',
266 ['PtrDecl', ['PtrDecl',
267 ['TypeDecl', ['IdentifierType', ['char']]]]]])
268
269 self.assertEqual(self.get_decl('int (*a)[1][2];'),
270 ['Decl', 'a',
271 ['PtrDecl',
272 ['ArrayDecl', '1',
273 ['ArrayDecl', '2',
274 ['TypeDecl', ['IdentifierType', ['int']]]]]]])
275
276 self.assertEqual(self.get_decl('int *a[1][2];'),
277 ['Decl', 'a',
278 ['ArrayDecl', '1',
279 ['ArrayDecl', '2',
280 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['int']]]]]]])
281
282 self.assertEqual(self.get_decl('char ***ar3D[40];'),
283 ['Decl', 'ar3D',
284 ['ArrayDecl', '40',
285 ['PtrDecl', ['PtrDecl', ['PtrDecl',
286 ['TypeDecl', ['IdentifierType', ['char']]]]]]]])
287
288 self.assertEqual(self.get_decl('char (***ar3D)[40];'),
289 ['Decl', 'ar3D',
290 ['PtrDecl', ['PtrDecl', ['PtrDecl',
291 ['ArrayDecl', '40', ['TypeDecl', ['IdentifierType', ['char']]]]]]]])
292
293 self.assertEqual(self.get_decl('int (*x[4])(char, int);'),
294 ['Decl', 'x',
295 ['ArrayDecl', '4',
296 ['PtrDecl',
297 ['FuncDecl',
298 [ ['Typename', ['TypeDecl', ['IdentifierType', ['char']]]],
299 ['Typename', ['TypeDecl', ['IdentifierType', ['int']]]]],
300 ['TypeDecl', ['IdentifierType', ['int']]]]]]])
301
302 self.assertEqual(self.get_decl('char *(*(**foo [][8])())[];'),
303 ['Decl', 'foo',
304 ['ArrayDecl', '',
305 ['ArrayDecl', '8',
306 ['PtrDecl', ['PtrDecl',
307 ['FuncDecl',
308 [],
309 ['PtrDecl',
310 ['ArrayDecl', '',
311 ['PtrDecl',
312 ['TypeDecl',
313 ['IdentifierType', ['char']]]]]]]]]]]])
314
315 # explore named and unnamed function pointer parameters,
316 # with and without qualifiers
317 #
318
319 # unnamed w/o quals
320 self.assertEqual(self.get_decl('int (*k)(int);'),
321 ['Decl', 'k',
322 ['PtrDecl',
323 ['FuncDecl',
324 [['Typename', ['TypeDecl', ['IdentifierType', ['int']]]]],
325 ['TypeDecl', ['IdentifierType', ['int']]]]]])
326
327 # unnamed w/ quals
328 self.assertEqual(self.get_decl('int (*k)(const int);'),
329 ['Decl', 'k',
330 ['PtrDecl',
331 ['FuncDecl',
332 [['Typename', ['const'], ['TypeDecl', ['IdentifierType', ['int']]]]],
333 ['TypeDecl', ['IdentifierType', ['int']]]]]])
334
335 # named w/o quals
336 self.assertEqual(self.get_decl('int (*k)(int q);'),
337 ['Decl', 'k',
338 ['PtrDecl',
339 ['FuncDecl',
340 [['Decl', 'q', ['TypeDecl', ['IdentifierType', ['int']]]]],
341 ['TypeDecl', ['IdentifierType', ['int']]]]]])
342
343 # named w/ quals
344 self.assertEqual(self.get_decl('int (*k)(const volatile int q);'),
345 ['Decl', 'k',
346 ['PtrDecl',
347 ['FuncDecl',
Eli Bendersky68497c22012-01-19 06:04:58 +0200[diff] [blame]348 [['Decl', ['const', 'volatile'], 'q',
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]349 ['TypeDecl', ['IdentifierType', ['int']]]]],
350 ['TypeDecl', ['IdentifierType', ['int']]]]]])
351
eli.bendersky79d5cf62010-10-29 13:33:52 +0200[diff] [blame]352 # restrict qualifier
353 self.assertEqual(self.get_decl('int (*k)(restrict int* q);'),
354 ['Decl', 'k',
355 ['PtrDecl',
356 ['FuncDecl',
357 [['Decl', ['restrict'], 'q',
358 ['PtrDecl',
359 ['TypeDecl', ['IdentifierType', ['int']]]]]],
360 ['TypeDecl', ['IdentifierType', ['int']]]]]])
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]361
362 def test_qualifiers_storage_specifiers(self):
363 def assert_qs(txt, index, quals, storage):
364 d = self.parse(txt).ext[index]
365 self.assertEqual(d.quals, quals)
366 self.assertEqual(d.storage, storage)
367
368 assert_qs("extern int p;", 0, [], ['extern'])
369 assert_qs("const long p = 6;", 0, ['const'], [])
370
371 d1 = "static const int p, q, r;"
372 for i in range(3):
373 assert_qs(d1, i, ['const'], ['static'])
374
375 d2 = "static char * const p;"
376 assert_qs(d2, 0, [], ['static'])
377 pdecl = self.parse(d2).ext[0].type
378 self.failUnless(isinstance(pdecl, PtrDecl))
379 self.assertEqual(pdecl.quals, ['const'])
380
381 def test_sizeof(self):
382 e = """
383 void foo()
384 {
385 int a = sizeof k;
386 int b = sizeof(int);
eli.benderskyc51e1d32011-02-04 08:52:33 +0200[diff] [blame]387 int c = sizeof(int**);;
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]388
389 char* p = "just to make sure this parses w/o error...";
390 int d = sizeof(int());
391 }
392 """
393 compound = self.parse(e).ext[0].body
394
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]395 s1 = compound.block_items[0].init
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]396 self.assertTrue(isinstance(s1, UnaryOp))
397 self.assertEqual(s1.op, 'sizeof')
398 self.assertTrue(isinstance(s1.expr, ID))
399 self.assertEqual(s1.expr.name, 'k')
400
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]401 s2 = compound.block_items[1].init
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]402 self.assertEqual(expand_decl(s2.expr),
403 ['Typename', ['TypeDecl', ['IdentifierType', ['int']]]])
404
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]405 s3 = compound.block_items[2].init
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]406 self.assertEqual(expand_decl(s3.expr),
407 ['Typename',
408 ['PtrDecl',
409 ['PtrDecl',
410 ['TypeDecl',
411 ['IdentifierType', ['int']]]]]])
412
eli.bendersky9f481562010-10-30 15:50:47 +0200[diff] [blame]413 # The C99 compound literal feature
414 #
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]415 def test_compound_literals(self):
eli.bendersky9f481562010-10-30 15:50:47 +0200[diff] [blame]416 ps1 = self.parse(r'''
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]417 void foo() {
eli.bendersky9f481562010-10-30 15:50:47 +0200[diff] [blame]418 p = (long long){k};
419 tc = (struct jk){.a = {1, 2}, .b[0] = t};
420 }''')
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]421
eli.bendersky9f481562010-10-30 15:50:47 +0200[diff] [blame]422 compound = ps1.ext[0].body.block_items[0].rvalue
423 self.assertEqual(expand_decl(compound.type),
424 ['Typename', ['TypeDecl', ['IdentifierType', ['long', 'long']]]])
425 self.assertEqual(expand_init(compound.init),
426 [['ID', 'k']])
427
428 compound = ps1.ext[0].body.block_items[1].rvalue
429 self.assertEqual(expand_decl(compound.type),
430 ['Typename', ['TypeDecl', ['Struct', 'jk', []]]])
431 self.assertEqual(expand_init(compound.init),
432 [
433 ([['ID', 'a']], [['Constant', 'int', '1'], ['Constant', 'int', '2']]),
434 ([['ID', 'b'], ['Constant', 'int', '0']], ['ID', 't'])])
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]435
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]436 def test_enums(self):
437 e1 = "enum mycolor op;"
438 e1_type = self.parse(e1).ext[0].type.type
439
440 self.assertTrue(isinstance(e1_type, Enum))
441 self.assertEqual(e1_type.name, 'mycolor')
442 self.assertEqual(e1_type.values, None)
443
444 e2 = "enum mysize {large=20, small, medium} shoes;"
445 e2_type = self.parse(e2).ext[0].type.type
446
447 self.assertTrue(isinstance(e2_type, Enum))
448 self.assertEqual(e2_type.name, 'mysize')
449
450 e2_elist = e2_type.values
451 self.assertTrue(isinstance(e2_elist, EnumeratorList))
452
453 for e2_eval in e2_elist.enumerators:
454 self.assertTrue(isinstance(e2_eval, Enumerator))
455
456 self.assertEqual(e2_elist.enumerators[0].name, 'large')
457 self.assertEqual(e2_elist.enumerators[0].value.value, '20')
458 self.assertEqual(e2_elist.enumerators[2].name, 'medium')
459 self.assertEqual(e2_elist.enumerators[2].value, None)
460
461 # enum with trailing comma (C99 feature)
462 e3 = """
463 enum
464 {
465 red,
466 blue,
467 green,
468 } color;
469 """
470
471 e3_type = self.parse(e3).ext[0].type.type
472 self.assertTrue(isinstance(e3_type, Enum))
473 e3_elist = e3_type.values
474 self.assertTrue(isinstance(e3_elist, EnumeratorList))
475
476 for e3_eval in e3_elist.enumerators:
477 self.assertTrue(isinstance(e3_eval, Enumerator))
478
479 self.assertEqual(e3_elist.enumerators[0].name, 'red')
480 self.assertEqual(e3_elist.enumerators[0].value, None)
481 self.assertEqual(e3_elist.enumerators[1].name, 'blue')
482 self.assertEqual(e3_elist.enumerators[2].name, 'green')
483
484 def test_typedef(self):
485 # without typedef, error
486 s1 = """
487 node k;
488 """
489 self.assertRaises(ParseError, self.parse, s1)
490
491 # now with typedef, works
492 s2 = """
493 typedef void* node;
494 node k;
495 """
496 ps2 = self.parse(s2)
497 self.assertEqual(expand_decl(ps2.ext[0]),
498 ['Typedef', 'node',
499 ['PtrDecl',
500 ['TypeDecl', ['IdentifierType', ['void']]]]])
501
502 self.assertEqual(expand_decl(ps2.ext[1]),
503 ['Decl', 'k',
504 ['TypeDecl', ['IdentifierType', ['node']]]])
505
506 s3 = """
507 typedef int T;
508 typedef T *pT;
509
510 pT aa, bb;
511 """
512 ps3 = self.parse(s3)
513 self.assertEqual(expand_decl(ps3.ext[3]),
514 ['Decl', 'bb',
515 ['TypeDecl', ['IdentifierType', ['pT']]]])
516
517 s4 = '''
518 typedef char* __builtin_va_list;
519 typedef __builtin_va_list __gnuc_va_list;
520 '''
521 ps4 = self.parse(s4)
522 self.assertEqual(expand_decl(ps4.ext[1]),
523 ['Typedef', '__gnuc_va_list',
524 ['TypeDecl',
525 ['IdentifierType', ['__builtin_va_list']]]])
526
527 s5 = '''typedef struct tagHash Hash;'''
528 ps5 = self.parse(s5)
529 self.assertEqual(expand_decl(ps5.ext[0]),
530 ['Typedef', 'Hash', ['TypeDecl', ['Struct', 'tagHash', []]]])
531
532 def test_struct_union(self):
533 s1 = """
534 struct {
535 int id;
536 char* name;
537 } joe;
538 """
539
540 self.assertEqual(expand_decl(self.parse(s1).ext[0]),
541 ['Decl', 'joe',
542 ['TypeDecl', ['Struct', None,
543 [ ['Decl', 'id',
544 ['TypeDecl',
545 ['IdentifierType', ['int']]]],
546 ['Decl', 'name',
547 ['PtrDecl',
548 ['TypeDecl',
549 ['IdentifierType', ['char']]]]]]]]])
550
551 s2 = """
552 struct node p;
553 """
554 self.assertEqual(expand_decl(self.parse(s2).ext[0]),
555 ['Decl', 'p',
556 ['TypeDecl', ['Struct', 'node', []]]])
557
558 s21 = """
559 union pri ra;
560 """
561 self.assertEqual(expand_decl(self.parse(s21).ext[0]),
562 ['Decl', 'ra',
563 ['TypeDecl', ['Union', 'pri', []]]])
564
565 s3 = """
566 struct node* p;
567 """
568 self.assertEqual(expand_decl(self.parse(s3).ext[0]),
569 ['Decl', 'p',
570 ['PtrDecl',
571 ['TypeDecl', ['Struct', 'node', []]]]])
572
573 s4 = """
574 struct node;
575 """
576 self.assertEqual(expand_decl(self.parse(s4).ext[0]),
577 ['Decl', None,
578 ['Struct', 'node', []]])
579
580 s5 = """
581 union
582 {
583 struct
584 {
585 int type;
586 } n;
587
588 struct
589 {
590 int type;
591 int intnode;
592 } ni;
593 } u;
594 """
595 self.assertEqual(expand_decl(self.parse(s5).ext[0]),
596 ['Decl', 'u',
597 ['TypeDecl',
598 ['Union', None,
599 [['Decl', 'n',
600 ['TypeDecl',
601 ['Struct', None,
602 [['Decl', 'type',
603 ['TypeDecl', ['IdentifierType', ['int']]]]]]]],
604 ['Decl', 'ni',
605 ['TypeDecl',
606 ['Struct', None,
607 [['Decl', 'type',
608 ['TypeDecl', ['IdentifierType', ['int']]]],
609 ['Decl', 'intnode',
610 ['TypeDecl', ['IdentifierType', ['int']]]]]]]]]]]])
611
612 s6 = """
613 typedef struct foo_tag
614 {
615 void* data;
616 } foo, *pfoo;
617 """
618 s6_ast = self.parse(s6)
619
620 self.assertEqual(expand_decl(s6_ast.ext[0]),
621 ['Typedef', 'foo',
622 ['TypeDecl',
623 ['Struct', 'foo_tag',
624 [['Decl', 'data',
625 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['void']]]]]]]]])
626
627 self.assertEqual(expand_decl(s6_ast.ext[1]),
628 ['Typedef', 'pfoo',
629 ['PtrDecl',
630 ['TypeDecl',
631 ['Struct', 'foo_tag',
632 [['Decl', 'data',
633 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['void']]]]]]]]]])
634
635 s7 = r"""
636 struct _on_exit_args {
637 void * _fnargs[32];
638 void * _dso_handle[32];
639
640 long _fntypes;
641 #line 77 "D:\eli\cpp_stuff\libc_include/sys/reent.h"
642
643 long _is_cxa;
644 };
645 """
646
647 s7_ast = self.parse(s7, filename='test.c')
648 self.assert_coord(s7_ast.ext[0].type.decls[2], 6, 'test.c')
649 self.assert_coord(s7_ast.ext[0].type.decls[3], 78,
650 r'D:\eli\cpp_stuff\libc_include/sys/reent.h')
651
652 s8 = """
653 typedef enum tagReturnCode {SUCCESS, FAIL} ReturnCode;
654
655 typedef struct tagEntry
656 {
657 char* key;
658 char* value;
659 } Entry;
660
661
662 typedef struct tagNode
663 {
664 Entry* entry;
665
666 struct tagNode* next;
667 } Node;
668
669 typedef struct tagHash
670 {
671 unsigned int table_size;
672
673 Node** heads;
674
675 } Hash;
676 """
677 s8_ast = self.parse(s8)
678 self.assertEqual(expand_decl(s8_ast.ext[3]),
679 ['Typedef', 'Hash',
680 ['TypeDecl', ['Struct', 'tagHash',
681 [['Decl', 'table_size',
Eli Bendersky68497c22012-01-19 06:04:58 +0200[diff] [blame]682 ['TypeDecl', ['IdentifierType', ['unsigned', 'int']]]],
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]683 ['Decl', 'heads',
684 ['PtrDecl', ['PtrDecl', ['TypeDecl', ['IdentifierType', ['Node']]]]]]]]]])
685
eli.bendersky697ecc52011-02-10 07:05:13 +0200[diff] [blame]686 def test_anonymous_struct_union(self):
687 s1 = """
688 union
689 {
690 union
691 {
692 int i;
693 long l;
694 };
695
696 struct
697 {
698 int type;
699 int intnode;
700 };
701 } u;
702 """
703
704 self.assertEqual(expand_decl(self.parse(s1).ext[0]),
705 ['Decl', 'u',
706 ['TypeDecl',
707 ['Union', None,
708 [['Decl', None,
709 ['Union', None,
710 [['Decl', 'i',
711 ['TypeDecl',
712 ['IdentifierType', ['int']]]],
713 ['Decl', 'l',
714 ['TypeDecl',
715 ['IdentifierType', ['long']]]]]]],
716 ['Decl', None,
717 ['Struct', None,
718 [['Decl', 'type',
719 ['TypeDecl',
720 ['IdentifierType', ['int']]]],
721 ['Decl', 'intnode',
722 ['TypeDecl',
723 ['IdentifierType', ['int']]]]]]]]]]])
724
725 s2 = """
726 struct
727 {
728 int i;
729 union
730 {
731 int id;
732 char* name;
733 };
734 float f;
735 } joe;
736 """
737
738 self.assertEqual(expand_decl(self.parse(s2).ext[0]),
739 ['Decl', 'joe',
740 ['TypeDecl',
741 ['Struct', None,
742 [['Decl', 'i',
743 ['TypeDecl',
744 ['IdentifierType', ['int']]]],
745 ['Decl', None,
746 ['Union', None,
747 [['Decl', 'id',
748 ['TypeDecl',
749 ['IdentifierType', ['int']]]],
750 ['Decl', 'name',
751 ['PtrDecl',
752 ['TypeDecl',
753 ['IdentifierType', ['char']]]]]]]],
754 ['Decl', 'f',
755 ['TypeDecl',
756 ['IdentifierType', ['float']]]]]]]])
757
758 # ISO/IEC 9899:201x Commitee Draft 2010-11-16, N1539
759 # section 6.7.2.1, par. 19, example 1
760 s3 = """
761 struct v {
762 union {
763 struct { int i, j; };
764 struct { long k, l; } w;
765 };
766 int m;
767 } v1;
768 """
769
770 self.assertEqual(expand_decl(self.parse(s3).ext[0]),
771 ['Decl', 'v1',
772 ['TypeDecl',
773 ['Struct', 'v',
774 [['Decl', None,
775 ['Union', None,
776 [['Decl', None,
777 ['Struct', None,
778 [['Decl', 'i',
779 ['TypeDecl',
780 ['IdentifierType', ['int']]]],
781 ['Decl', 'j',
782 ['TypeDecl',
783 ['IdentifierType', ['int']]]]]]],
784 ['Decl', 'w',
785 ['TypeDecl',
786 ['Struct', None,
787 [['Decl', 'k',
788 ['TypeDecl',
789 ['IdentifierType', ['long']]]],
790 ['Decl', 'l',
791 ['TypeDecl',
792 ['IdentifierType', ['long']]]]]]]]]]],
793 ['Decl', 'm',
794 ['TypeDecl',
795 ['IdentifierType', ['int']]]]]]]])
796
eli.benderskydce29a02011-02-10 07:55:00 +0200[diff] [blame]797 s4 = """
798 struct v {
799 int i;
800 float;
801 } v2;"""
eli.bendersky6b011792011-06-22 17:50:56 +0300[diff] [blame]802 # just make sure this doesn't raise ParseError
803 self.parse(s4)
eli.benderskydce29a02011-02-10 07:55:00 +0200[diff] [blame]804
eli.bendersky0e0a71f2010-10-09 08:32:00 +0200[diff] [blame]805 def test_struct_bitfields(self):
eli.bendersky38ed9a92010-10-09 09:29:59 +0200[diff] [blame]806 # a struct with two bitfields, one unnamed
eli.bendersky0e0a71f2010-10-09 08:32:00 +0200[diff] [blame]807 s1 = """
808 struct {
809 int k:6;
810 int :2;
811 } joe;
812 """
813
814 parsed_struct = self.parse(s1).ext[0]
815
eli.bendersky38ed9a92010-10-09 09:29:59 +0200[diff] [blame]816 # We can see here the name of the decl for the unnamed bitfield is
eli.bendersky0e0a71f2010-10-09 08:32:00 +0200[diff] [blame]817 # None, but expand_decl doesn't show bitfield widths
818 # ...
819 self.assertEqual(expand_decl(parsed_struct),
820 ['Decl', 'joe',
821 ['TypeDecl', ['Struct', None,
822 [ ['Decl', 'k',
823 ['TypeDecl',
824 ['IdentifierType', ['int']]]],
825 ['Decl', None,
826 ['TypeDecl',
827 ['IdentifierType', ['int']]]]]]]])
828
829 # ...
830 # so we test them manually
831 self.assertEqual(parsed_struct.type.type.decls[0].bitsize.value, '6')
832 self.assertEqual(parsed_struct.type.type.decls[1].bitsize.value, '2')
833
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]834 def test_tags_namespace(self):
835 """ Tests that the tags of structs/unions/enums reside in a separate namespace and
836 can be named after existing types.
837 """
838 s1 = """
839 typedef int tagEntry;
840
841 struct tagEntry
842 {
843 char* key;
844 char* value;
845 } Entry;
846 """
847
848 s1_ast = self.parse(s1)
849 self.assertEqual(expand_decl(s1_ast.ext[1]),
850 ['Decl', 'Entry',
851 ['TypeDecl', ['Struct', 'tagEntry',
852 [['Decl', 'key',
853 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]],
854 ['Decl', 'value',
855 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]]]]]])
856
857 s2 = """
858 struct tagEntry;
859
860 typedef struct tagEntry tagEntry;
861
862 struct tagEntry
863 {
864 char* key;
865 char* value;
866 } Entry;
867 """
868
869 s2_ast = self.parse(s2)
870 self.assertEqual(expand_decl(s2_ast.ext[2]),
871 ['Decl', 'Entry',
872 ['TypeDecl', ['Struct', 'tagEntry',
873 [['Decl', 'key',
874 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]],
875 ['Decl', 'value',
876 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]]]]]])
877
878 s3 = """
879 typedef int mytag;
880
881 enum mytag {ABC, CDE};
882 enum mytag joe;
883 """
884
885 s3_type = self.parse(s3).ext[1].type
886
887 self.assertTrue(isinstance(s3_type, Enum))
888 self.assertEqual(s3_type.name, 'mytag')
889
890 def test_multi_decls(self):
891 d1 = 'int a, b;'
892
893 self.assertEqual(self.get_decl(d1, 0),
894 ['Decl', 'a', ['TypeDecl', ['IdentifierType', ['int']]]])
895 self.assertEqual(self.get_decl(d1, 1),
896 ['Decl', 'b', ['TypeDecl', ['IdentifierType', ['int']]]])
897
898 d2 = 'char* p, notp, ar[4];'
899 self.assertEqual(self.get_decl(d2, 0),
900 ['Decl', 'p',
901 ['PtrDecl',
902 ['TypeDecl', ['IdentifierType', ['char']]]]])
903 self.assertEqual(self.get_decl(d2, 1),
904 ['Decl', 'notp', ['TypeDecl', ['IdentifierType', ['char']]]])
905 self.assertEqual(self.get_decl(d2, 2),
906 ['Decl', 'ar',
907 ['ArrayDecl', '4',
908 ['TypeDecl', ['IdentifierType', ['char']]]]])
909
910 def test_invalid_multiple_types_error(self):
911 bad = [
912 'int enum {ab, cd} fubr;',
913 'enum kid char brbr;']
914
915 for b in bad:
916 self.assertRaises(ParseError, self.parse, b)
917
918 def test_decl_inits(self):
919 d1 = 'int a = 16;'
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]920 #~ self.parse(d1).show()
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]921 self.assertEqual(self.get_decl(d1),
922 ['Decl', 'a', ['TypeDecl', ['IdentifierType', ['int']]]])
923 self.assertEqual(self.get_decl_init(d1),
924 ['Constant', 'int', '16'])
925
926 d2 = 'long ar[] = {7, 8, 9};'
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]927 #~ self.parse(d2).show()
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]928 self.assertEqual(self.get_decl(d2),
929 ['Decl', 'ar',
930 ['ArrayDecl', '',
931 ['TypeDecl', ['IdentifierType', ['long']]]]])
932 self.assertEqual(self.get_decl_init(d2),
933 [ ['Constant', 'int', '7'],
934 ['Constant', 'int', '8'],
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]935 ['Constant', 'int', '9']])
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]936
937 d3 = 'char p = j;'
938 self.assertEqual(self.get_decl(d3),
939 ['Decl', 'p', ['TypeDecl', ['IdentifierType', ['char']]]])
940 self.assertEqual(self.get_decl_init(d3),
941 ['ID', 'j'])
942
943 d4 = "char x = 'c', *p = {0, 1, 2, {4, 5}, 6};"
944 self.assertEqual(self.get_decl(d4, 0),
945 ['Decl', 'x', ['TypeDecl', ['IdentifierType', ['char']]]])
946 self.assertEqual(self.get_decl_init(d4, 0),
947 ['Constant', 'char', "'c'"])
948 self.assertEqual(self.get_decl(d4, 1),
949 ['Decl', 'p',
950 ['PtrDecl',
951 ['TypeDecl', ['IdentifierType', ['char']]]]])
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]952
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]953 self.assertEqual(self.get_decl_init(d4, 1),
954 [ ['Constant', 'int', '0'],
955 ['Constant', 'int', '1'],
956 ['Constant', 'int', '2'],
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]957 [['Constant', 'int', '4'],
958 ['Constant', 'int', '5']],
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]959 ['Constant', 'int', '6']])
eli.benderskyf890a862010-10-30 12:13:23 +0200[diff] [blame]960
961 def test_decl_named_inits(self):
962 d1 = 'int a = {.k = 16};'
963 self.assertEqual(self.get_decl_init(d1),
964 [( [['ID', 'k']],
965 ['Constant', 'int', '16'])])
966
967 d2 = 'int a = { [0].a = {1}, [1].a[0] = 2 };'
968 self.assertEqual(self.get_decl_init(d2),
969 [
970 ([['Constant', 'int', '0'], ['ID', 'a']],
971 [['Constant', 'int', '1']]),
972 ([['Constant', 'int', '1'], ['ID', 'a'], ['Constant', 'int', '0']],
973 ['Constant', 'int', '2'])])
974
975 d3 = 'int a = { .a = 1, .c = 3, 4, .b = 5};'
976 self.assertEqual(self.get_decl_init(d3),
977 [
978 ([['ID', 'a']], ['Constant', 'int', '1']),
979 ([['ID', 'c']], ['Constant', 'int', '3']),
980 ['Constant', 'int', '4'],
981 ([['ID', 'b']], ['Constant', 'int', '5'])])
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]982
983 def test_function_definitions(self):
984 def parse_fdef(str):
985 return self.parse(str).ext[0]
986
987 def fdef_decl(fdef):
988 return expand_decl(fdef.decl)
989
990 f1 = parse_fdef('''
991 int factorial(int p)
992 {
993 return 3;
994 }
995 ''')
996
997 self.assertEqual(fdef_decl(f1),
998 ['Decl', 'factorial',
999 ['FuncDecl',
1000 [['Decl', 'p', ['TypeDecl', ['IdentifierType', ['int']]]]],
1001 ['TypeDecl', ['IdentifierType', ['int']]]]])
1002
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]1003 self.assertEqual(type(f1.body.block_items[0]), Return)
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1004
1005 f2 = parse_fdef('''
1006 char* zzz(int p, char* c)
1007 {
1008 int a;
1009 char b;
1010
1011 a = b + 2;
1012 return 3;
1013 }
1014 ''')
1015
1016 self.assertEqual(fdef_decl(f2),
1017 ['Decl', 'zzz',
1018 ['FuncDecl',
1019 [ ['Decl', 'p', ['TypeDecl', ['IdentifierType', ['int']]]],
1020 ['Decl', 'c', ['PtrDecl',
1021 ['TypeDecl', ['IdentifierType', ['char']]]]]],
1022 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]]])
1023
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]1024 self.assertEqual(list(map(type, f2.body.block_items)),
1025 [Decl, Decl, Assignment, Return])
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1026
1027 f3 = parse_fdef('''
1028 char* zzz(p, c)
1029 long p, *c;
1030 {
1031 int a;
1032 char b;
1033
1034 a = b + 2;
1035 return 3;
1036 }
1037 ''')
1038
1039 self.assertEqual(fdef_decl(f3),
1040 ['Decl', 'zzz',
1041 ['FuncDecl',
1042 [ ['ID', 'p'],
1043 ['ID', 'c']],
1044 ['PtrDecl', ['TypeDecl', ['IdentifierType', ['char']]]]]])
1045
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]1046 self.assertEqual(list(map(type, f3.body.block_items)),
1047 [Decl, Decl, Assignment, Return])
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1048
1049 self.assertEqual(expand_decl(f3.param_decls[0]),
1050 ['Decl', 'p', ['TypeDecl', ['IdentifierType', ['long']]]])
1051 self.assertEqual(expand_decl(f3.param_decls[1]),
1052 ['Decl', 'c', ['PtrDecl', ['TypeDecl', ['IdentifierType', ['long']]]]])
1053
eli.bendersky71540662010-07-03 12:58:52 +0200[diff] [blame]1054 def test_unified_string_literals(self):
1055 # simple string, for reference
1056 d1 = self.get_decl_init('char* s = "hello";')
1057 self.assertEqual(d1, ['Constant', 'string', '"hello"'])
1058
1059 d2 = self.get_decl_init('char* s = "hello" " world";')
1060 self.assertEqual(d2, ['Constant', 'string', '"hello world"'])
1061
1062 # the test case from issue 6
1063 d3 = self.parse(r'''
1064 int main() {
1065 fprintf(stderr,
1066 "Wrong Params?\n"
1067 "Usage:\n"
1068 "%s <binary_file_path>\n",
1069 argv[0]
1070 );
1071 }
1072 ''')
1073
1074 self.assertEqual(
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]1075 d3.ext[0].body.block_items[0].args.exprs[1].value,
eli.bendersky71540662010-07-03 12:58:52 +0200[diff] [blame]1076 r'"Wrong Params?\nUsage:\n%s <binary_file_path>\n"')
eli.bendersky4a89f112010-07-05 06:02:03 +0200[diff] [blame]1077
1078 d4 = self.get_decl_init('char* s = "" "foobar";')
1079 self.assertEqual(d4, ['Constant', 'string', '"foobar"'])
1080
1081 d5 = self.get_decl_init(r'char* s = "foo\"" "bar";')
1082 self.assertEqual(d5, ['Constant', 'string', r'"foo\"bar"'])
eli.bendersky71540662010-07-03 12:58:52 +0200[diff] [blame]1083
eli.bendersky79d5cf62010-10-29 13:33:52 +0200[diff] [blame]1084 def test_inline_specifier(self):
1085 ps2 = self.parse('static inline void inlinefoo(void);')
1086 self.assertEqual(ps2.ext[0].funcspec, ['inline'])
eli.bendersky2e907fa2010-10-29 15:51:07 +0200[diff] [blame]1087
1088 # variable length array
1089 def test_vla(self):
1090 ps2 = self.parse(r'''
1091 int main() {
1092 int size;
1093 int var[size = 5];
1094
1095 int var2[*];
1096 }
1097 ''')
eli.benderskyef29ff92010-10-29 16:25:43 +0200[diff] [blame]1098 self.failUnless(isinstance(ps2.ext[0].body.block_items[1].type.dim, Assignment))
1099 self.failUnless(isinstance(ps2.ext[0].body.block_items[2].type.dim, ID))
eli.bendersky79d5cf62010-10-29 13:33:52 +0200[diff] [blame]1100
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1101
eli.bendersky85d2e732011-05-20 19:47:26 +0300[diff] [blame]1102class TestCParser_whole_code(TestCParser_base):
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1103 """ Testing of parsing whole chunks of code.
1104
1105 Since I don't want to rely on the structure of ASTs too
1106 much, most of these tests are implemented with visitors.
1107 """
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1108 # A simple helper visitor that lists the values of all the
1109 # Constant nodes it sees.
1110 #
1111 class ConstantVisitor(NodeVisitor):
1112 def __init__(self):
1113 self.values = []
1114
1115 def visit_Constant(self, node):
1116 self.values.append(node.value)
1117
1118 # This visitor counts the amount of references to the ID
1119 # with the name provided to it in the constructor.
1120 #
1121 class IDNameCounter(NodeVisitor):
1122 def __init__(self, name):
1123 self.name = name
1124 self.nrefs = 0
1125
1126 def visit_ID(self, node):
1127 if node.name == self.name:
1128 self.nrefs += 1
1129
1130 # Counts the amount of nodes of a given class
1131 #
1132 class NodeKlassCounter(NodeVisitor):
1133 def __init__(self, node_klass):
1134 self.klass = node_klass
1135 self.n = 0
1136
1137 def generic_visit(self, node):
1138 if node.__class__ == self.klass:
1139 self.n += 1
1140
1141 NodeVisitor.generic_visit(self, node)
1142
1143 def assert_all_Constants(self, code, constants):
1144 """ Asserts that the list of all Constant values (by
1145 'preorder' appearance) in the chunk of code is as
1146 given.
1147 """
eli.benderskyed890492010-06-25 08:25:55 +0300[diff] [blame]1148 if isinstance(code, str):
1149 parsed = self.parse(code)
1150 else:
1151 parsed = code
1152
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1153 cv = self.ConstantVisitor()
1154 cv.visit(parsed)
1155 self.assertEqual(cv.values, constants)
1156
1157 def assert_num_ID_refs(self, code, name, num):
1158 """ Asserts the number of references to the ID with
1159 the given name.
1160 """
1161 if isinstance(code, str):
1162 parsed = self.parse(code)
1163 else:
1164 parsed = code
1165
1166 iv = self.IDNameCounter(name)
1167 iv.visit(parsed)
1168 self.assertEqual(iv.nrefs, num)
1169
1170 def assert_num_klass_nodes(self, code, klass, num):
1171 """ Asserts the amount of klass nodes in the code.
1172 """
1173 if isinstance(code, str):
1174 parsed = self.parse(code)
1175 else:
1176 parsed = code
1177
1178 cv = self.NodeKlassCounter(klass)
1179 cv.visit(parsed)
1180 self.assertEqual(cv.n, num)
1181
1182 def test_expressions(self):
1183 e1 = '''int k = (r + 10.0) >> 6 + 8 << (3 & 0x14);'''
1184 self.assert_all_Constants(e1, ['10.0', '6', '8', '3', '0x14'])
1185
1186 e2 = r'''char n = '\n', *prefix = "st_";'''
1187 self.assert_all_Constants(e2, [r"'\n'", '"st_"'])
1188
1189 def test_statements(self):
1190 s1 = r'''
1191 void foo(){
1192 if (sp == 1)
1193 if (optind >= argc ||
1194 argv[optind][0] != '-' || argv[optind][1] == '\0')
1195 return -1;
1196 else if (strcmp(argv[optind], "--") == 0) {
1197 optind++;
1198 return -1;
1199 }
1200 }
1201 '''
1202
1203 self.assert_all_Constants(s1,
1204 ['1', '0', r"'-'", '1', r"'\0'", '1', r'"--"', '0', '1'])
1205
1206 ps1 = self.parse(s1)
1207 self.assert_num_ID_refs(ps1, 'argv', 3)
1208 self.assert_num_ID_refs(ps1, 'optind', 5)
1209
1210 self.assert_num_klass_nodes(ps1, If, 3)
1211 self.assert_num_klass_nodes(ps1, Return, 2)
1212 self.assert_num_klass_nodes(ps1, FuncCall, 1) # strcmp
1213 self.assert_num_klass_nodes(ps1, BinaryOp, 7)
1214
1215 # In the following code, Hash and Node were defined as
1216 # int to pacify the parser that sees they're used as
1217 # types
1218 #
1219 s2 = r'''
1220 typedef int Hash, Node;
1221
1222 void HashDestroy(Hash* hash)
1223 {
1224 unsigned int i;
1225
1226 if (hash == NULL)
1227 return;
1228
1229 for (i = 0; i < hash->table_size; ++i)
1230 {
1231 Node* temp = hash->heads[i];
1232
1233 while (temp != NULL)
1234 {
1235 Node* temp2 = temp;
1236
1237 free(temp->entry->key);
1238 free(temp->entry->value);
1239 free(temp->entry);
1240
1241 temp = temp->next;
1242
1243 free(temp2);
1244 }
1245 }
1246
1247 free(hash->heads);
1248 hash->heads = NULL;
1249
1250 free(hash);
1251 }
1252 '''
1253
1254 ps2 = self.parse(s2)
1255 self.assert_num_klass_nodes(ps2, FuncCall, 6)
1256 self.assert_num_klass_nodes(ps2, FuncDef, 1)
1257 self.assert_num_klass_nodes(ps2, For, 1)
1258 self.assert_num_klass_nodes(ps2, While, 1)
1259 self.assert_num_klass_nodes(ps2, StructRef, 10)
1260
1261 # declarations don't count
1262 self.assert_num_ID_refs(ps2, 'hash', 6)
1263 self.assert_num_ID_refs(ps2, 'i', 4)
eli.benderskyed890492010-06-25 08:25:55 +0300[diff] [blame]1264
1265 s3 = r'''
1266 void x(void) {
1267 int a, b;
1268 if (a < b)
1269 do {
1270 a = 0;
1271 } while (0);
1272 else if (a == b) {
1273 a = 1;
1274 }
1275 }
1276 '''
1277
1278 ps3 = self.parse(s3)
1279 self.assert_num_klass_nodes(ps3, DoWhile, 1)
1280 self.assert_num_ID_refs(ps3, 'a', 4)
1281 self.assert_all_Constants(ps3, ['0', '0', '1'])
eli.bendersky91c0aa32011-10-16 05:50:43 +0200[diff] [blame]1282
1283 def test_empty_statement(self):
1284 s1 = r'''
1285 void foo(void){
1286 ;
1287 return;
1288 }
1289 '''
1290 ps1 = self.parse(s1)
1291 self.assert_num_klass_nodes(ps1, EmptyStatement, 1)
1292 self.assert_num_klass_nodes(ps1, Return, 1)
eli.bendersky145890d2010-10-29 12:02:32 +0200[diff] [blame]1293
Ben5cd3fd62012-02-03 06:02:40 +0200[diff] [blame]1294 def test_switch_statement(self):
Eli Bendersky12f0c9d2012-02-03 11:22:25 +0200[diff] [blame]1295 def assert_case_node(node, const_value):
1296 self.failUnless(isinstance(node, Case))
1297 self.failUnless(isinstance(node.expr, Constant))
1298 self.assertEqual(node.expr.value, const_value)
1299
1300 def assert_default_node(node):
1301 self.failUnless(isinstance(node, Default))
1302
Ben5cd3fd62012-02-03 06:02:40 +0200[diff] [blame]1303 s1 = r'''
1304 int foo(void) {
1305 switch (myvar) {
1306 case 10:
1307 k = 10;
1308 p = k + 1;
1309 return 10;
1310 case 20:
1311 case 30:
1312 return 20;
1313 default:
1314 break;
1315 }
1316 return 0;
1317 }
1318 '''
1319 ps1 = self.parse(s1)
Eli Bendersky12f0c9d2012-02-03 11:22:25 +0200[diff] [blame]1320 switch = ps1.ext[0].body.block_items[0]
1321
1322 block = switch.stmt.block_items
1323 assert_case_node(block[0], '10')
1324 self.assertEqual(len(block[0].stmts), 3)
1325 assert_case_node(block[1], '20')
1326 self.assertEqual(len(block[1].stmts), 0)
1327 assert_case_node(block[2], '30')
1328 self.assertEqual(len(block[2].stmts), 1)
1329 assert_default_node(block[3])
1330
1331 s2 = r'''
1332 int foo(void) {
1333 switch (myvar) {
1334 default:
1335 joe = moe;
1336 return 10;
1337 case 10:
1338 case 20:
1339 case 30:
1340 case 40:
1341 break;
1342 }
1343 return 0;
1344 }
1345 '''
1346 ps2 = self.parse(s2)
1347 switch = ps2.ext[0].body.block_items[0]
1348
1349 block = switch.stmt.block_items
1350 assert_default_node(block[0])
1351 self.assertEqual(len(block[0].stmts), 2)
1352 assert_case_node(block[1], '10')
1353 self.assertEqual(len(block[1].stmts), 0)
1354 assert_case_node(block[2], '20')
1355 self.assertEqual(len(block[1].stmts), 0)
1356 assert_case_node(block[3], '30')
1357 self.assertEqual(len(block[1].stmts), 0)
1358 assert_case_node(block[4], '40')
1359 self.assertEqual(len(block[4].stmts), 1)
Ben5cd3fd62012-02-03 06:02:40 +0200[diff] [blame]1360
eli.bendersky145890d2010-10-29 12:02:32 +0200[diff] [blame]1361 def test_for_statement(self):
1362 s2 = r'''
1363 void x(void)
1364 {
1365 int i;
1366 for (i = 0; i < 5; ++i) {
1367 x = 50;
1368 }
1369 }
1370 '''
1371 ps2 = self.parse(s2)
1372 self.assert_num_klass_nodes(ps2, For, 1)
1373 # here there are 3 refs to 'i' since the declaration doesn't count as
1374 # a ref in the visitor
1375 #
1376 self.assert_num_ID_refs(ps2, 'i', 3)
eli.benderskyed890492010-06-25 08:25:55 +0300[diff] [blame]1377
eli.bendersky145890d2010-10-29 12:02:32 +0200[diff] [blame]1378 s3 = r'''
1379 void x(void)
1380 {
1381 for (int i = 0; i < 5; ++i) {
1382 x = 50;
1383 }
1384 }
1385 '''
1386 ps3 = self.parse(s3)
eli.bendersky145890d2010-10-29 12:02:32 +0200[diff] [blame]1387 self.assert_num_klass_nodes(ps3, For, 1)
1388 # here there are 2 refs to 'i' since the declaration doesn't count as
1389 # a ref in the visitor
1390 #
1391 self.assert_num_ID_refs(ps3, 'i', 2)
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1392
Eli Benderskyd0973782012-01-19 08:09:33 +0200[diff] [blame]1393 def _open_c_file(self, name):
1394 """ Find a c file by name, taking into account the current dir can be
1395 in a couple of typical places
1396 """
1397 fullnames = [
1398 os.path.join('c_files', name),
1399 os.path.join('tests', 'c_files', name)]
1400 for fullname in fullnames:
1401 if os.path.exists(fullname):
1402 return open(fullname, 'rU')
1403 assert False, "Unreachable"
1404
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1405 def test_whole_file(self):
1406 # See how pycparser handles a whole, real C file.
1407 #
Eli Benderskyd0973782012-01-19 08:09:33 +0200[diff] [blame]1408 code = self._open_c_file('memmgr_with_h.c').read()
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1409 p = self.parse(code)
1410
1411 self.assert_num_klass_nodes(p, FuncDef, 5)
1412
1413 # each FuncDef also has a FuncDecl. 4 declarations
1414 # + 5 definitions, overall 9
1415 self.assert_num_klass_nodes(p, FuncDecl, 9)
1416
1417 self.assert_num_klass_nodes(p, Typedef, 4)
1418
1419 self.assertEqual(p.ext[4].coord.line, 88)
1420 self.assertEqual(p.ext[4].coord.file, "./memmgr.h")
1421
1422 self.assertEqual(p.ext[6].coord.line, 10)
1423 self.assertEqual(p.ext[6].coord.file, "memmgr.c")
1424
1425 def test_whole_file_with_stdio(self):
1426 # Parse a whole file with stdio.h included by cpp
1427 #
Eli Benderskyd0973782012-01-19 08:09:33 +0200[diff] [blame]1428 code = self._open_c_file('cppd_with_stdio_h.c').read()
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1429 p = self.parse(code)
1430
1431 self.failUnless(isinstance(p.ext[0], Typedef))
1432 self.assertEqual(p.ext[0].coord.line, 213)
1433 self.assertEqual(p.ext[0].coord.file, "D:\eli\cpp_stuff\libc_include/stddef.h")
1434
1435 self.failUnless(isinstance(p.ext[-1], FuncDef))
1436 self.assertEqual(p.ext[-1].coord.line, 15)
1437 self.assertEqual(p.ext[-1].coord.file, "example_c_file.c")
1438
1439 self.failUnless(isinstance(p.ext[-8], Typedef))
1440 self.failUnless(isinstance(p.ext[-8].type, TypeDecl))
1441 self.assertEqual(p.ext[-8].name, 'cookie_io_functions_t')
eli.bendersky85d2e732011-05-20 19:47:26 +0300[diff] [blame]1442
1443
1444class TestCParser_typenames(TestCParser_base):
1445 """ Test issues related to the typedef-name problem.
1446 """
1447 def test_innerscope_typedef(self):
1448 # should fail since TT is not a type in bar
1449 s1 = r'''
1450 void foo() {
1451 typedef char TT;
1452 TT x;
1453 }
1454 void bar() {
1455 TT y;
1456 }
1457 '''
1458 self.assertRaises(ParseError, self.parse, s1)
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1459
eli.bendersky85d2e732011-05-20 19:47:26 +0300[diff] [blame]1460 # should succeed since TT is not a type in bar
1461 s2 = r'''
1462 void foo() {
1463 typedef char TT;
1464 TT x;
1465 }
1466 void bar() {
1467 unsigned TT;
1468 }
1469 '''
1470 self.failUnless(isinstance(self.parse(s2), FileAST))
1471
1472
Eli Bendersky3921e8e2010-05-21 09:05:39 +0300[diff] [blame]1473
1474if __name__ == '__main__':
1475 #~ suite = unittest.TestLoader().loadTestsFromNames(
1476 #~ ['test_c_parser.TestCParser_fundamentals.test_typedef'])
1477
1478 #~ suite = unittest.TestLoader().loadTestsFromNames(
1479 #~ ['test_c_parser.TestCParser_whole_code.test_whole_file_with_stdio'])
1480
1481 #~ suite = unittest.TestLoader().loadTestsFromTestCase(
1482 #~ TestCParser_whole_code)
1483
1484 #~ unittest.TextTestRunner(verbosity=2).run(suite)
1485 unittest.main()