releasing version 2.01 - removed yaml dependency, fix installation problems

1 files changed, 1340 insertions, 1341 deletions

diff --git a/pycparser/c_parser.py b/pycparser/c_parser.py
index e9d0403..38c80b3 100644
--- a/pycparser/c_parser.py
+++ b/pycparser/c_parser.py
@@ -1,1354 +1,1353 @@
-#-----------------------------------------------------------------

-# pycparser: c_parser.py

-#

-# CParser class: Parser and AST builder for the C language

-#

-# Copyright (C) 2008-2010, Eli Bendersky

-# License: LGPL

-#-----------------------------------------------------------------

-

-import re

-

-import ply.yacc

-

-from . import c_ast

-from .c_lexer import CLexer

-from .plyparser import PLYParser, Coord, ParseError

-

-

-class CParser(PLYParser):    

-    def __init__(

-            self, 

-            lex_optimize=True,

-            lextab='pycparser.lextab',

-            yacc_optimize=True,

-            yacctab='pycparser.yacctab',

-            yacc_debug=False):

-        """ Create a new CParser.

-        

-            Some arguments for controlling the debug/optimization

-            level of the parser are provided. The defaults are 

-            tuned for release/performance mode. 

-            The simple rules for using them are:

-            *) When tweaking CParser/CLexer, set these to False

-            *) When releasing a stable parser, set to True

-            

-            lex_optimize:

-                Set to False when you're modifying the lexer.

-                Otherwise, changes in the lexer won't be used, if

-                some lextab.py file exists.

-                When releasing with a stable lexer, set to True

-                to save the re-generation of the lexer table on 

-                each run.

-            

-            lextab:

-                Points to the lex table that's used for optimized

-                mode. Only if you're modifying the lexer and want

-                some tests to avoid re-generating the table, make 

-                this point to a local lex table file (that's been

-                earlier generated with lex_optimize=True)

-            

-            yacc_optimize:

-                Set to False when you're modifying the parser.

-                Otherwise, changes in the parser won't be used, if

-                some parsetab.py file exists.

-                When releasing with a stable parser, set to True

-                to save the re-generation of the parser table on 

-                each run.

-            

-            yacctab:

-                Points to the yacc table that's used for optimized

-                mode. Only if you're modifying the parser, make 

-                this point to a local yacc table file

-                        

-            yacc_debug:

-                Generate a parser.out file that explains how yacc

-                built the parsing table from the grammar.

-        """

-        self.clex = CLexer(

-            error_func=self._lex_error_func,

-            type_lookup_func=self._lex_type_lookup_func)

-            

-        self.clex.build(

-            optimize=lex_optimize,

-            lextab=lextab)

-        self.tokens = self.clex.tokens

-        

-        rules_with_opt = [

-            'abstract_declarator',

-            'assignment_expression',

-            'declaration_list',

-            'declaration_specifiers',

-            'designation',

-            'expression',

-            'identifier_list',

-            'init_declarator_list',

-            'parameter_type_list',

-            'specifier_qualifier_list',

-            'block_item_list',

-            'type_qualifier_list',

-        ]

-        

-        for rule in rules_with_opt:

-            self._create_opt_rule(rule)

-        

-        self.cparser = ply.yacc.yacc(

-            module=self, 

-            start='translation_unit',

-            debug=yacc_debug,

-            optimize=yacc_optimize,

-            tabmodule=yacctab)

-        

-        # A table of identifiers defined as typedef types during

-        # parsing.

-        #

-        self.typedef_table = set([])

-    

-    def parse(self, text, filename='', debuglevel=0):

-        """ Parses C code and returns an AST.

-        

-            text:

-                A string containing the C source code

-            

-            filename:

-                Name of the file being parsed (for meaningful

-                error messages)

-            

-            debuglevel:

-                Debug level to yacc

-        """

-        self.clex.filename = filename

-        self.clex.reset_lineno()

-        self.typedef_table = set([])

-        return self.cparser.parse(text, lexer=self.clex, debug=debuglevel)

-    

-    ######################--   PRIVATE   --######################

-    

-    def _lex_error_func(self, msg, line, column):

-        self._parse_error(msg, self._coord(line, column))

-    

-    def _lex_type_lookup_func(self, name):

-        """ Looks up types that were previously defined with

-            typedef. 

-            Passed to the lexer for recognizing identifiers that

-            are types.

-        """

-        return name in self.typedef_table

-    

-    def _add_typedef_type(self, name):

-        """ Adds names that were defined as new types with 

-            typedef.

-        """

-        self.typedef_table.add(name)

-    

-    # To understand what's going on here, read sections A.8.5 and 

-    # A.8.6 of K&R2 very carefully.

-    # 

-    # A C type consists of a basic type declaration, with a list

-    # of modifiers. For example:

-    #

-    # int *c[5];

-    #

-    # The basic declaration here is 'int x', and the pointer and

-    # the array are the modifiers.

-    #

-    # Basic declarations are represented by TypeDecl (from module

-    # c_ast) and the modifiers are FuncDecl, PtrDecl and 

-    # ArrayDecl.

-    #

-    # The standard states that whenever a new modifier is parsed,

-    # it should be added to the end of the list of modifiers. For

-    # example:

-    #

-    # K&R2 A.8.6.2: Array Declarators

-    #

-    # In a declaration T D where D has the form  

-    #   D1 [constant-expression-opt]  

-    # and the type of the identifier in the declaration T D1 is 

-    # "type-modifier T", the type of the 

-    # identifier of D is "type-modifier array of T"

-    #

-    # This is what this method does. The declarator it receives

-    # can be a list of declarators ending with TypeDecl. It 

-    # tacks the modifier to the end of this list, just before 

-    # the TypeDecl.

-    #

-    # Additionally, the modifier may be a list itself. This is 

-    # useful for pointers, that can come as a chain from the rule

-    # p_pointer. In this case, the whole modifier list is spliced 

-    # into the new location.

-    #

-    def _type_modify_decl(self, decl, modifier):

-        """ Tacks a type modifier on a declarator, and returns

-            the modified declarator.

-            

-            Note: the declarator and modifier may be modified

-        """

-        #~ print '****'

-        #~ decl.show(offset=3)

-        #~ modifier.show(offset=3)

-        #~ print '****'

-        

-        modifier_head = modifier

-        modifier_tail = modifier

-        

-        # The modifier may be a nested list. Reach its tail.

-        #

-        while modifier_tail.type: 

-            modifier_tail = modifier_tail.type

-        

-        # If the decl is a basic type, just tack the modifier onto

-        # it

-        #

-        if isinstance(decl, c_ast.TypeDecl):

-            modifier_tail.type = decl

-            return modifier

-        else:

-            # Otherwise, the decl is a list of modifiers. Reach

-            # its tail and splice the modifier onto the tail,

-            # pointing to the underlying basic type.

-            #

-            decl_tail = decl

-            

-            while not isinstance(decl_tail.type, c_ast.TypeDecl):

-                decl_tail = decl_tail.type

-            

-            modifier_tail.type = decl_tail.type

-            decl_tail.type = modifier_head

-            return decl

-

-    # Due to the order in which declarators are constructed,

-    # they have to be fixed in order to look like a normal AST.

-    # 

-    # When a declaration arrives from syntax construction, it has

-    # these problems:

-    # * The innermost TypeDecl has no type (because the basic

-    #   type is only known at the uppermost declaration level)

-    # * The declaration has no variable name, since that is saved

-    #   in the innermost TypeDecl

-    # * The typename of the declaration is a list of type 

-    #   specifiers, and not a node. Here, basic identifier types

-    #   should be separated from more complex types like enums

-    #   and structs.

-    #

-    # This method fixes these problem.

-    #

-    def _fix_decl_name_type(self, decl, typename):

-        """ Fixes a declaration. Modifies decl.

-        """

-        # Reach the underlying basic type

-        #

-        type = decl

-        while not isinstance(type, c_ast.TypeDecl):

-            type = type.type

-        

-        decl.name = type.declname

-        type.quals = decl.quals

-        

-        # The typename is a list of types. If any type in this 

-        # list isn't a simple string type, it must be the only

-        # type in the list (it's illegal to declare "int enum .."

-        # If all the types are basic, they're collected in the

-        # IdentifierType holder.

-        #

-        for tn in typename:

-            if not isinstance(tn, str):

-                if len(typename) > 1:

-                    self._parse_error(

-                        "Invalid multiple types specified", tn.coord)

-                else:

-                    type.type = tn

-                    return decl

-        

-        type.type = c_ast.IdentifierType(typename)

-        return decl

-    

-    def _add_declaration_specifier(self, declspec, newspec, kind):

-        """ Declaration specifiers are represented by a dictionary

-            with the entries:

-            * qual: a list of type qualifiers

-            * storage: a list of storage type qualifiers

-            * type: a list of type specifiers

-            * function: a list of function specifiers

-            

-            This method is given a declaration specifier, and a 

-            new specifier of a given kind.

-            Returns the declaration specifier, with the new 

-            specifier incorporated.

-        """

-        spec = declspec or dict(qual=[], storage=[], type=[], function=[])

-        spec[kind].append(newspec)

-        return spec

-    

-    def _build_function_definition(self, decl, spec, param_decls, body):

-        """ Builds a function definition.

-        """

-        declaration = c_ast.Decl(

-            name=None,

-            quals=spec['qual'],

-            storage=spec['storage'],

-            funcspec=spec['function'],

-            type=decl, 

-            init=None, 

-            bitsize=None, 

-            coord=decl.coord)

-        

-        typename = spec['type']

-        declaration = self._fix_decl_name_type(declaration, typename)

-        return c_ast.FuncDef(

-            decl=declaration,

-            param_decls=param_decls,

-            body=body,

-            coord=decl.coord)

-

-    def _select_struct_union_class(self, token):

-        """ Given a token (either STRUCT or UNION), selects the

-            appropriate AST class.

-        """

-        if token == 'struct':

-            return c_ast.Struct

-        else:

-            return c_ast.Union

-

-    ##

-    ## Precedence and associativity of operators

-    ##

-    precedence = (

-        ('left', 'LOR'),

-        ('left', 'LAND'),

-        ('left', 'OR'),

-        ('left', 'XOR'),

-        ('left', 'AND'),

-        ('left', 'EQ', 'NE'),

-        ('left', 'GT', 'GE', 'LT', 'LE'),

-        ('left', 'RSHIFT', 'LSHIFT'),

-        ('left', 'PLUS', 'MINUS'),

-        ('left', 'TIMES', 'DIVIDE', 'MOD')

-    )

-    

-    ##

-    ## Grammar productions

-    ## Implementation of the BNF defined in K&R2 A.13

-    ##

-    def p_translation_unit_1(self, p):

-        """ translation_unit    : external_declaration 

-        """

-        # Note: external_declaration is already a list

-        #

-        p[0] = c_ast.FileAST(p[1])

-    

-    def p_translation_unit_2(self, p):

-        """ translation_unit    : translation_unit external_declaration

-        """

-        p[1].ext.extend(p[2])

-        p[0] = p[1]

-    

-    # Declarations always come as lists (because they can be

-    # several in one line), so we wrap the function definition 

-    # into a list as well, to make the return value of 

-    # external_declaration homogenous.

-    #

-    def p_external_declaration_1(self, p):

-        """ external_declaration    : function_definition

-        """

-        p[0] = [p[1]]

-    

-    def p_external_declaration_2(self, p):

-        """ external_declaration    : declaration

-        """

-        p[0] = p[1]

-

-    def p_external_declaration_3(self, p):

-        """ external_declaration    : pp_directive

-        """

-        p[0] = p[1]

-

-    def p_pp_directive(self, p):

-        """ pp_directive  : PPHASH 

-        """

-        self._parse_error('Directives not supported yet', 

-            self._coord(p.lineno(1)))

-

-    # In function definitions, the declarator can be followed by

-    # a declaration list, for old "K&R style" function definitios.

-    #

-    def p_function_definition_1(self, p):

-        """ function_definition : declarator declaration_list_opt compound_statement

-        """

-        # no declaration specifiers

-        spec = dict(qual=[], storage=[], type=[])

-

-        p[0] = self._build_function_definition(

-            decl=p[1],

-            spec=spec, 

-            param_decls=p[2],

-            body=p[3])

-                    

-    def p_function_definition_2(self, p):

-        """ function_definition : declaration_specifiers declarator declaration_list_opt compound_statement

-        """

-        spec = p[1]

-

-        p[0] = self._build_function_definition(

-            decl=p[2],

-            spec=spec, 

-            param_decls=p[3],

-            body=p[4])

-        

-    def p_statement(self, p):

-        """ statement   : labeled_statement

-                        | expression_statement

-                        | compound_statement

-                        | selection_statement

-                        | iteration_statement    

-                        | jump_statement

-        """

-        p[0] = p[1]

-

-    # In C, declarations can come several in a line:

-    #   int x, *px, romulo = 5;

-    #

-    # However, for the AST, we will split them to separate Decl

-    # nodes.

-    #

-    # This rule splits its declarations and always returns a list

-    # of Decl nodes, even if it's one element long.

-    #

-    def p_decl_body(self, p):

-        """ decl_body : declaration_specifiers init_declarator_list_opt

-        """

-        spec = p[1]

-        is_typedef = 'typedef' in spec['storage']

-        decls = []

-

-        # p[2] (init_declarator_list_opt) is either a list or None

-        #

-        if p[2] is None:

-            # Then it's a declaration of a struct / enum tag,

-            # without an actual declarator.

-            #

-            type = spec['type']

-            if len(type) > 1:

-                coord = '?'

-                for t in type:

-                    if hasattr(t, 'coord'):

-                        coord = t.coord

-                        break

-                        

-                self._parse_error('Multiple type specifiers with a type tag', coord)

-            

-            decl = c_ast.Decl(

-                name=None,

-                quals=spec['qual'],

-                storage=spec['storage'],

-                funcspec=spec['function'],

-                type=type[0],

-                init=None,

-                bitsize=None,

-                coord=type[0].coord)

-            decls = [decl]

-        else:

-            for decl, init in p[2] or []:

-                if is_typedef:

-                    decl = c_ast.Typedef(

-                        name=None,

-                        quals=spec['qual'],

-                        storage=spec['storage'],

-                        type=decl,

-                        coord=decl.coord)

-                else:

-                    decl = c_ast.Decl(

-                        name=None,

-                        quals=spec['qual'],

-                        storage=spec['storage'],

-                        funcspec=spec['function'],

-                        type=decl, 

-                        init=init, 

-                        bitsize=None, 

-                        coord=decl.coord)

-                

-                typename = spec['type']

-                fixed_decl = self._fix_decl_name_type(decl, typename)

-

-                # Add the type name defined by typedef to a

-                # symbol table (for usage in the lexer)

-                # 

-                if is_typedef:

-                    self._add_typedef_type(fixed_decl.name)

-

-                decls.append(fixed_decl)

-

-        p[0] = decls

-

-    # The declaration has been split to a decl_body sub-rule and

-    # SEMI, because having them in a single rule created a problem

-    # for defining typedefs.

-    #

-    # If a typedef line was directly followed by a line using the

-    # type defined with the typedef, the type would not be 

-    # recognized. This is because to reduce the declaration rule,

-    # the parser's lookahead asked for the token after SEMI, which

-    # was the type from the next line, and the lexer had no chance

-    # to see the updated type symbol table.

-    #

-    # Splitting solves this problem, because after seeing SEMI,

-    # the parser reduces decl_body, which actually adds the new

-    # type into the table to be seen by the lexer before the next

-    # line is reached.

-    #

-    def p_declaration(self, p):

-        """ declaration : decl_body SEMI 

-        """

-        p[0] = p[1]

-

-    # Since each declaration is a list of declarations, this

-    # rule will combine all the declarations and return a single

-    # list

-    # 

-    def p_declaration_list(self, p):

-        """ declaration_list    : declaration

-                                | declaration_list declaration

-        """

-        p[0] = p[1] if len(p) == 2 else p[1] + p[2]

-    

-    def p_declaration_specifiers_1(self, p):

-        """ declaration_specifiers  : type_qualifier declaration_specifiers_opt 

-        """

-        p[0] = self._add_declaration_specifier(p[2], p[1], 'qual')

-        

-    def p_declaration_specifiers_2(self, p):

-        """ declaration_specifiers  : type_specifier declaration_specifiers_opt

-        """

-        p[0] = self._add_declaration_specifier(p[2], p[1], 'type')

-        

-    def p_declaration_specifiers_3(self, p):

-        """ declaration_specifiers  : storage_class_specifier declaration_specifiers_opt

-        """

-        p[0] = self._add_declaration_specifier(p[2], p[1], 'storage')

-        

-    def p_declaration_specifiers_4(self, p):

-        """ declaration_specifiers  : function_specifier declaration_specifiers_opt

-        """

-        p[0] = self._add_declaration_specifier(p[2], p[1], 'function')

-    

-    def p_storage_class_specifier(self, p):

-        """ storage_class_specifier : AUTO

-                                    | REGISTER

-                                    | STATIC

-                                    | EXTERN

-                                    | TYPEDEF

-        """

-        p[0] = p[1]

-    

+#-----------------------------------------------------------------
+# pycparser: c_parser.py
+#
+# CParser class: Parser and AST builder for the C language
+#
+# Copyright (C) 2008-2010, Eli Bendersky
+# License: LGPL
+#-----------------------------------------------------------------
+import re
+
+import ply.yacc
+
+from . import c_ast
+from .c_lexer import CLexer
+from .plyparser import PLYParser, Coord, ParseError
+
+
+class CParser(PLYParser):    
+    def __init__(
+            self, 
+            lex_optimize=True,
+            lextab='pycparser.lextab',
+            yacc_optimize=True,
+            yacctab='pycparser.yacctab',
+            yacc_debug=False):
+        """ Create a new CParser.
+        
+            Some arguments for controlling the debug/optimization
+            level of the parser are provided. The defaults are 
+            tuned for release/performance mode. 
+            The simple rules for using them are:
+            *) When tweaking CParser/CLexer, set these to False
+            *) When releasing a stable parser, set to True
+            
+            lex_optimize:
+                Set to False when you're modifying the lexer.
+                Otherwise, changes in the lexer won't be used, if
+                some lextab.py file exists.
+                When releasing with a stable lexer, set to True
+                to save the re-generation of the lexer table on 
+                each run.
+            
+            lextab:
+                Points to the lex table that's used for optimized
+                mode. Only if you're modifying the lexer and want
+                some tests to avoid re-generating the table, make 
+                this point to a local lex table file (that's been
+                earlier generated with lex_optimize=True)
+            
+            yacc_optimize:
+                Set to False when you're modifying the parser.
+                Otherwise, changes in the parser won't be used, if
+                some parsetab.py file exists.
+                When releasing with a stable parser, set to True
+                to save the re-generation of the parser table on 
+                each run.
+            
+            yacctab:
+                Points to the yacc table that's used for optimized
+                mode. Only if you're modifying the parser, make 
+                this point to a local yacc table file
+                        
+            yacc_debug:
+                Generate a parser.out file that explains how yacc
+                built the parsing table from the grammar.
+        """
+        self.clex = CLexer(
+            error_func=self._lex_error_func,
+            type_lookup_func=self._lex_type_lookup_func)
+            
+        self.clex.build(
+            optimize=lex_optimize,
+            lextab=lextab)
+        self.tokens = self.clex.tokens
+        
+        rules_with_opt = [
+            'abstract_declarator',
+            'assignment_expression',
+            'declaration_list',
+            'declaration_specifiers',
+            'designation',
+            'expression',
+            'identifier_list',
+            'init_declarator_list',
+            'parameter_type_list',
+            'specifier_qualifier_list',
+            'block_item_list',
+            'type_qualifier_list',
+        ]
+        
+        for rule in rules_with_opt:
+            self._create_opt_rule(rule)
+        
+        self.cparser = ply.yacc.yacc(
+            module=self, 
+            start='translation_unit',
+            debug=yacc_debug,
+            optimize=yacc_optimize,
+            tabmodule=yacctab)
+        
+        # A table of identifiers defined as typedef types during
+        # parsing.
+        #
+        self.typedef_table = set([])
+    
+    def parse(self, text, filename='', debuglevel=0):
+        """ Parses C code and returns an AST.
+        
+            text:
+                A string containing the C source code
+            
+            filename:
+                Name of the file being parsed (for meaningful
+                error messages)
+            
+            debuglevel:
+                Debug level to yacc
+        """
+        self.clex.filename = filename
+        self.clex.reset_lineno()
+        self.typedef_table = set([])
+        return self.cparser.parse(text, lexer=self.clex, debug=debuglevel)
+    
+    ######################--   PRIVATE   --######################
+    
+    def _lex_error_func(self, msg, line, column):
+        self._parse_error(msg, self._coord(line, column))
+    
+    def _lex_type_lookup_func(self, name):
+        """ Looks up types that were previously defined with
+            typedef. 
+            Passed to the lexer for recognizing identifiers that
+            are types.
+        """
+        return name in self.typedef_table
+    
+    def _add_typedef_type(self, name):
+        """ Adds names that were defined as new types with 
+            typedef.
+        """
+        self.typedef_table.add(name)
+    
+    # To understand what's going on here, read sections A.8.5 and 
+    # A.8.6 of K&R2 very carefully.
+    # 
+    # A C type consists of a basic type declaration, with a list
+    # of modifiers. For example:
+    #
+    # int *c[5];
+    #
+    # The basic declaration here is 'int x', and the pointer and
+    # the array are the modifiers.
+    #
+    # Basic declarations are represented by TypeDecl (from module
+    # c_ast) and the modifiers are FuncDecl, PtrDecl and 
+    # ArrayDecl.
+    #
+    # The standard states that whenever a new modifier is parsed,
+    # it should be added to the end of the list of modifiers. For
+    # example:
+    #
+    # K&R2 A.8.6.2: Array Declarators
+    #
+    # In a declaration T D where D has the form  
+    #   D1 [constant-expression-opt]  
+    # and the type of the identifier in the declaration T D1 is 
+    # "type-modifier T", the type of the 
+    # identifier of D is "type-modifier array of T"
+    #
+    # This is what this method does. The declarator it receives
+    # can be a list of declarators ending with TypeDecl. It 
+    # tacks the modifier to the end of this list, just before 
+    # the TypeDecl.
+    #
+    # Additionally, the modifier may be a list itself. This is 
+    # useful for pointers, that can come as a chain from the rule
+    # p_pointer. In this case, the whole modifier list is spliced 
+    # into the new location.
+    #
+    def _type_modify_decl(self, decl, modifier):
+        """ Tacks a type modifier on a declarator, and returns
+            the modified declarator.
+            
+            Note: the declarator and modifier may be modified
+        """
+        #~ print '****'
+        #~ decl.show(offset=3)
+        #~ modifier.show(offset=3)
+        #~ print '****'
+        
+        modifier_head = modifier
+        modifier_tail = modifier
+        
+        # The modifier may be a nested list. Reach its tail.
+        #
+        while modifier_tail.type: 
+            modifier_tail = modifier_tail.type
+        
+        # If the decl is a basic type, just tack the modifier onto
+        # it
+        #
+        if isinstance(decl, c_ast.TypeDecl):
+            modifier_tail.type = decl
+            return modifier
+        else:
+            # Otherwise, the decl is a list of modifiers. Reach
+            # its tail and splice the modifier onto the tail,
+            # pointing to the underlying basic type.
+            #
+            decl_tail = decl
+            
+            while not isinstance(decl_tail.type, c_ast.TypeDecl):
+                decl_tail = decl_tail.type
+            
+            modifier_tail.type = decl_tail.type
+            decl_tail.type = modifier_head
+            return decl
+
+    # Due to the order in which declarators are constructed,
+    # they have to be fixed in order to look like a normal AST.
+    # 
+    # When a declaration arrives from syntax construction, it has
+    # these problems:
+    # * The innermost TypeDecl has no type (because the basic
+    #   type is only known at the uppermost declaration level)
+    # * The declaration has no variable name, since that is saved
+    #   in the innermost TypeDecl
+    # * The typename of the declaration is a list of type 
+    #   specifiers, and not a node. Here, basic identifier types
+    #   should be separated from more complex types like enums
+    #   and structs.
+    #
+    # This method fixes these problem.
+    #
+    def _fix_decl_name_type(self, decl, typename):
+        """ Fixes a declaration. Modifies decl.
+        """
+        # Reach the underlying basic type
+        #
+        type = decl
+        while not isinstance(type, c_ast.TypeDecl):
+            type = type.type
+        
+        decl.name = type.declname
+        type.quals = decl.quals
+        
+        # The typename is a list of types. If any type in this 
+        # list isn't a simple string type, it must be the only
+        # type in the list (it's illegal to declare "int enum .."
+        # If all the types are basic, they're collected in the
+        # IdentifierType holder.
+        #
+        for tn in typename:
+            if not isinstance(tn, str):
+                if len(typename) > 1:
+                    self._parse_error(
+                        "Invalid multiple types specified", tn.coord)
+                else:
+                    type.type = tn
+                    return decl
+        
+        type.type = c_ast.IdentifierType(typename)
+        return decl
+    
+    def _add_declaration_specifier(self, declspec, newspec, kind):
+        """ Declaration specifiers are represented by a dictionary
+            with the entries:
+            * qual: a list of type qualifiers
+            * storage: a list of storage type qualifiers
+            * type: a list of type specifiers
+            * function: a list of function specifiers
+            
+            This method is given a declaration specifier, and a 
+            new specifier of a given kind.
+            Returns the declaration specifier, with the new 
+            specifier incorporated.
+        """
+        spec = declspec or dict(qual=[], storage=[], type=[], function=[])
+        spec[kind].append(newspec)
+        return spec
+    
+    def _build_function_definition(self, decl, spec, param_decls, body):
+        """ Builds a function definition.
+        """
+        declaration = c_ast.Decl(
+            name=None,
+            quals=spec['qual'],
+            storage=spec['storage'],
+            funcspec=spec['function'],
+            type=decl, 
+            init=None, 
+            bitsize=None, 
+            coord=decl.coord)
+        
+        typename = spec['type']
+        declaration = self._fix_decl_name_type(declaration, typename)
+        return c_ast.FuncDef(
+            decl=declaration,
+            param_decls=param_decls,
+            body=body,
+            coord=decl.coord)
+
+    def _select_struct_union_class(self, token):
+        """ Given a token (either STRUCT or UNION), selects the
+            appropriate AST class.
+        """
+        if token == 'struct':
+            return c_ast.Struct
+        else:
+            return c_ast.Union
+
+    ##
+    ## Precedence and associativity of operators
+    ##
+    precedence = (
+        ('left', 'LOR'),
+        ('left', 'LAND'),
+        ('left', 'OR'),
+        ('left', 'XOR'),
+        ('left', 'AND'),
+        ('left', 'EQ', 'NE'),
+        ('left', 'GT', 'GE', 'LT', 'LE'),
+        ('left', 'RSHIFT', 'LSHIFT'),
+        ('left', 'PLUS', 'MINUS'),
+        ('left', 'TIMES', 'DIVIDE', 'MOD')
+    )
+    
+    ##
+    ## Grammar productions
+    ## Implementation of the BNF defined in K&R2 A.13
+    ##
+    def p_translation_unit_1(self, p):
+        """ translation_unit    : external_declaration 
+        """
+        # Note: external_declaration is already a list
+        #
+        p[0] = c_ast.FileAST(p[1])
+    
+    def p_translation_unit_2(self, p):
+        """ translation_unit    : translation_unit external_declaration
+        """
+        p[1].ext.extend(p[2])
+        p[0] = p[1]
+    
+    # Declarations always come as lists (because they can be
+    # several in one line), so we wrap the function definition 
+    # into a list as well, to make the return value of 
+    # external_declaration homogenous.
+    #
+    def p_external_declaration_1(self, p):
+        """ external_declaration    : function_definition
+        """
+        p[0] = [p[1]]
+    
+    def p_external_declaration_2(self, p):
+        """ external_declaration    : declaration
+        """
+        p[0] = p[1]
+
+    def p_external_declaration_3(self, p):
+        """ external_declaration    : pp_directive
+        """
+        p[0] = p[1]
+
+    def p_pp_directive(self, p):
+        """ pp_directive  : PPHASH 
+        """
+        self._parse_error('Directives not supported yet', 
+            self._coord(p.lineno(1)))
+
+    # In function definitions, the declarator can be followed by
+    # a declaration list, for old "K&R style" function definitios.
+    #
+    def p_function_definition_1(self, p):
+        """ function_definition : declarator declaration_list_opt compound_statement
+        """
+        # no declaration specifiers
+        spec = dict(qual=[], storage=[], type=[])
+
+        p[0] = self._build_function_definition(
+            decl=p[1],
+            spec=spec, 
+            param_decls=p[2],
+            body=p[3])
+                    
+    def p_function_definition_2(self, p):
+        """ function_definition : declaration_specifiers declarator declaration_list_opt compound_statement
+        """
+        spec = p[1]
+
+        p[0] = self._build_function_definition(
+            decl=p[2],
+            spec=spec, 
+            param_decls=p[3],
+            body=p[4])
+        
+    def p_statement(self, p):
+        """ statement   : labeled_statement
+                        | expression_statement
+                        | compound_statement
+                        | selection_statement
+                        | iteration_statement    
+                        | jump_statement
+        """
+        p[0] = p[1]
+
+    # In C, declarations can come several in a line:
+    #   int x, *px, romulo = 5;
+    #
+    # However, for the AST, we will split them to separate Decl
+    # nodes.
+    #
+    # This rule splits its declarations and always returns a list
+    # of Decl nodes, even if it's one element long.
+    #
+    def p_decl_body(self, p):
+        """ decl_body : declaration_specifiers init_declarator_list_opt
+        """
+        spec = p[1]
+        is_typedef = 'typedef' in spec['storage']
+        decls = []
+
+        # p[2] (init_declarator_list_opt) is either a list or None
+        #
+        if p[2] is None:
+            # Then it's a declaration of a struct / enum tag,
+            # without an actual declarator.
+            #
+            type = spec['type']
+            if len(type) > 1:
+                coord = '?'
+                for t in type:
+                    if hasattr(t, 'coord'):
+                        coord = t.coord
+                        break
+                        
+                self._parse_error('Multiple type specifiers with a type tag', coord)
+            
+            decl = c_ast.Decl(
+                name=None,
+                quals=spec['qual'],
+                storage=spec['storage'],
+                funcspec=spec['function'],
+                type=type[0],
+                init=None,
+                bitsize=None,
+                coord=type[0].coord)
+            decls = [decl]
+        else:
+            for decl, init in p[2] or []:
+                if is_typedef:
+                    decl = c_ast.Typedef(
+                        name=None,
+                        quals=spec['qual'],
+                        storage=spec['storage'],
+                        type=decl,
+                        coord=decl.coord)
+                else:
+                    decl = c_ast.Decl(
+                        name=None,
+                        quals=spec['qual'],
+                        storage=spec['storage'],
+                        funcspec=spec['function'],
+                        type=decl, 
+                        init=init, 
+                        bitsize=None, 
+                        coord=decl.coord)
+                
+                typename = spec['type']
+                fixed_decl = self._fix_decl_name_type(decl, typename)
+
+                # Add the type name defined by typedef to a
+                # symbol table (for usage in the lexer)
+                # 
+                if is_typedef:
+                    self._add_typedef_type(fixed_decl.name)
+
+                decls.append(fixed_decl)
+
+        p[0] = decls
+
+    # The declaration has been split to a decl_body sub-rule and
+    # SEMI, because having them in a single rule created a problem
+    # for defining typedefs.
+    #
+    # If a typedef line was directly followed by a line using the
+    # type defined with the typedef, the type would not be 
+    # recognized. This is because to reduce the declaration rule,
+    # the parser's lookahead asked for the token after SEMI, which
+    # was the type from the next line, and the lexer had no chance
+    # to see the updated type symbol table.
+    #
+    # Splitting solves this problem, because after seeing SEMI,
+    # the parser reduces decl_body, which actually adds the new
+    # type into the table to be seen by the lexer before the next
+    # line is reached.
+    #
+    def p_declaration(self, p):
+        """ declaration : decl_body SEMI 
+        """
+        p[0] = p[1]
+
+    # Since each declaration is a list of declarations, this
+    # rule will combine all the declarations and return a single
+    # list
+    # 
+    def p_declaration_list(self, p):
+        """ declaration_list    : declaration
+                                | declaration_list declaration
+        """
+        p[0] = p[1] if len(p) == 2 else p[1] + p[2]
+    
+    def p_declaration_specifiers_1(self, p):
+        """ declaration_specifiers  : type_qualifier declaration_specifiers_opt 
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'qual')
+        
+    def p_declaration_specifiers_2(self, p):
+        """ declaration_specifiers  : type_specifier declaration_specifiers_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'type')
+        
+    def p_declaration_specifiers_3(self, p):
+        """ declaration_specifiers  : storage_class_specifier declaration_specifiers_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'storage')
+        
+    def p_declaration_specifiers_4(self, p):
+        """ declaration_specifiers  : function_specifier declaration_specifiers_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'function')
+    
+    def p_storage_class_specifier(self, p):
+        """ storage_class_specifier : AUTO
+                                    | REGISTER
+                                    | STATIC
+                                    | EXTERN
+                                    | TYPEDEF
+        """
+        p[0] = p[1]
+    
     def p_function_specifier(self, p):
         """ function_specifier  : INLINE
-        """

-        p[0] = p[1]

-    

-    def p_type_specifier_1(self, p):

-        """ type_specifier  : VOID

-                            | CHAR

-                            | SHORT

-                            | INT

-                            | LONG

-                            | FLOAT

-                            | DOUBLE

-                            | SIGNED

-                            | UNSIGNED

-                            | typedef_name

-                            | enum_specifier

-                            | struct_or_union_specifier

-        """

-        p[0] = p[1]

-    

-    def p_type_qualifier(self, p):

-        """ type_qualifier  : CONST

-                            | RESTRICT

-                            | VOLATILE

-        """

-        p[0] = p[1]

-    

-    def p_init_declarator_list(self, p):

-        """ init_declarator_list    : init_declarator

-                                    | init_declarator_list COMMA init_declarator

-        """

-        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]

-

-    # Returns a (declarator, initializer) pair

-    # If there's no initializer, returns (declarator, None)

-    #

-    def p_init_declarator(self, p):

-        """ init_declarator : declarator

-                            | declarator EQUALS initializer

-        """

-        p[0] = (p[1], p[3] if len(p) > 2 else None)        

-    

-    def p_specifier_qualifier_list_1(self, p):

-        """ specifier_qualifier_list    : type_qualifier specifier_qualifier_list_opt

-        """

-        p[0] = self._add_declaration_specifier(p[2], p[1], 'qual')

-        

-    def p_specifier_qualifier_list_2(self, p):

-        """ specifier_qualifier_list    : type_specifier specifier_qualifier_list_opt

-        """

-        p[0] = self._add_declaration_specifier(p[2], p[1], 'type')

-

-    # TYPEID is allowed here (and in other struct/enum related tag names), because

-    # struct/enum tags reside in their own namespace and can be named the same as types

-    #

-    def p_struct_or_union_specifier_1(self, p):

-        """ struct_or_union_specifier   : struct_or_union ID

-                                        | struct_or_union TYPEID

-        """

-        klass = self._select_struct_union_class(p[1])

-        p[0] = klass(

-            name=p[2], 

-            decls=None, 

-            coord=self._coord(p.lineno(2)))

-

-    def p_struct_or_union_specifier_2(self, p):

-        """ struct_or_union_specifier : struct_or_union LBRACE struct_declaration_list RBRACE

-        """

-        klass = self._select_struct_union_class(p[1])

-        p[0] = klass(

-            name=None,

-            decls=p[3],

-            coord=self._coord(p.lineno(2)))

-

-    def p_struct_or_union_specifier_3(self, p):

-        """ struct_or_union_specifier   : struct_or_union ID LBRACE struct_declaration_list RBRACE

-                                        | struct_or_union TYPEID LBRACE struct_declaration_list RBRACE

-        """

-        klass = self._select_struct_union_class(p[1])

-        p[0] = klass(

-            name=p[2],

-            decls=p[4],

-            coord=self._coord(p.lineno(2)))

-

-    def p_struct_or_union(self, p):

-        """ struct_or_union : STRUCT 

-                            | UNION

-        """

-        p[0] = p[1]

-

-    # Combine all declarations into a single list

-    #

-    def p_struct_declaration_list(self, p):

-        """ struct_declaration_list     : struct_declaration

-                                        | struct_declaration_list struct_declaration

-        """

-        p[0] = p[1] if len(p) == 2 else p[1] + p[2]

-

-    def p_struct_declaration_1(self, p):

-        """ struct_declaration : specifier_qualifier_list struct_declarator_list SEMI

-        """

-        spec = p[1]

-        decls = []

-        

-        for struct_decl in p[2]:

-            if struct_decl['decl'] is not None:

-                decl_coord = struct_decl['decl'].coord

-            else:

-                decl_coord = struct_decl['bitsize'].coord

-            

-            decl = c_ast.Decl(

-                name=None,

-                quals=spec['qual'],

-                funcspec=spec['function'],

-                storage=spec['storage'],

-                type=struct_decl['decl'],

-                init=None,

-                bitsize=struct_decl['bitsize'],

-                coord=decl_coord)

-            

-            typename = spec['type']

-            decls.append(self._fix_decl_name_type(decl, typename))

-        

-        p[0] = decls

-    

-    def p_struct_declarator_list(self, p):

-        """ struct_declarator_list  : struct_declarator

-                                    | struct_declarator_list COMMA struct_declarator

-        """

-        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]

-    

-    # struct_declarator passes up a dict with the keys: decl (for

-    # the underlying declarator) and bitsize (for the bitsize)

-    #

-    def p_struct_declarator_1(self, p):

-        """ struct_declarator : declarator

-        """

-        p[0] = {'decl': p[1], 'bitsize': None}

-    

-    def p_struct_declarator_2(self, p):

-        """ struct_declarator   : declarator COLON constant_expression

-                                | COLON constant_expression

-        """

-        if len(p) > 3:

-            p[0] = {'decl': p[1], 'bitsize': p[3]}

-        else:

-            p[0] = {'decl': c_ast.TypeDecl(None, None, None), 'bitsize': p[2]}

-    

-    def p_enum_specifier_1(self, p):

-        """ enum_specifier  : ENUM ID

-                            | ENUM TYPEID

-        """

-        p[0] = c_ast.Enum(p[2], None, self._coord(p.lineno(1)))

-    

-    def p_enum_specifier_2(self, p):

-        """ enum_specifier  : ENUM LBRACE enumerator_list RBRACE

-        """

-        p[0] = c_ast.Enum(None, p[3], self._coord(p.lineno(1)))

-    

-    def p_enum_specifier_3(self, p):

-        """ enum_specifier  : ENUM ID LBRACE enumerator_list RBRACE

-                            | ENUM TYPEID LBRACE enumerator_list RBRACE

-        """

-        p[0] = c_ast.Enum(p[2], p[4], self._coord(p.lineno(1)))

-        

-    def p_enumerator_list(self, p):

-        """ enumerator_list : enumerator

-                            | enumerator_list COMMA

-                            | enumerator_list COMMA enumerator

-        """

-        if len(p) == 2:

-            p[0] = c_ast.EnumeratorList([p[1]], p[1].coord)

-        elif len(p) == 3:

-            p[0] = p[1]

-        else:

-            p[1].enumerators.append(p[3])

-            p[0] = p[1]

-

-    def p_enumerator(self, p):

-        """ enumerator  : ID

-                        | ID EQUALS constant_expression

-        """

-        if len(p) == 2:

-            p[0] = c_ast.Enumerator(

-                        p[1], None, 

-                        self._coord(p.lineno(1)))

-        else:

-            p[0] = c_ast.Enumerator(

-                        p[1], p[3], 

-                        self._coord(p.lineno(1)))

-    

-    def p_declarator_1(self, p):

-        """ declarator  : direct_declarator 

-        """

-        p[0] = p[1]

-    

-    def p_declarator_2(self, p):

-        """ declarator  : pointer direct_declarator 

-        """

-        p[0] = self._type_modify_decl(p[2], p[1])

-    

-    def p_direct_declarator_1(self, p):

-        """ direct_declarator   : ID 

-        """

-        p[0] = c_ast.TypeDecl(

-            declname=p[1], 

-            type=None, 

-            quals=None,

-            coord=self._coord(p.lineno(1)))

-        

-    def p_direct_declarator_2(self, p):

-        """ direct_declarator   : LPAREN declarator RPAREN 

-        """

-        p[0] = p[2]

-        

-    def p_direct_declarator_3(self, p):

-        """ direct_declarator   : direct_declarator LBRACKET assignment_expression_opt RBRACKET 

-        """

-        arr = c_ast.ArrayDecl(

-            type=None,

-            dim=p[3],

-            coord=p[1].coord)

-        

-        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

-

-    # Special for VLAs

-    #

-    def p_direct_declarator_4(self, p):

-        """ direct_declarator   : direct_declarator LBRACKET TIMES RBRACKET 

-        """

-        arr = c_ast.ArrayDecl(

-            type=None,

-            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),

-            coord=p[1].coord)

-        

-        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

-

-    def p_direct_declarator_5(self, p):

-        """ direct_declarator   : direct_declarator LPAREN parameter_type_list RPAREN 

-                                | direct_declarator LPAREN identifier_list_opt RPAREN

-        """

-        func = c_ast.FuncDecl(

-            args=p[3],

-            type=None,

-            coord=p[1].coord)

-        

-        p[0] = self._type_modify_decl(decl=p[1], modifier=func)

-    

-    def p_pointer(self, p):

-        """ pointer : TIMES type_qualifier_list_opt

-                    | TIMES type_qualifier_list_opt pointer

-        """

-        coord = self._coord(p.lineno(1))

-        

-        p[0] = c_ast.PtrDecl(

-            quals=p[2] or [],

-            type=p[3] if len(p) > 3 else None,

-            coord=coord)

-    

-    def p_type_qualifier_list(self, p):

-        """ type_qualifier_list : type_qualifier

-                                | type_qualifier_list type_qualifier

-        """

-        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]

-    

-    def p_parameter_type_list(self, p):

-        """ parameter_type_list : parameter_list

-                                | parameter_list COMMA ELLIPSIS

-        """

-        if len(p) > 2: 

-            p[1].params.append(c_ast.EllipsisParam())

-        

-        p[0] = p[1]

-

-    def p_parameter_list(self, p):

-        """ parameter_list  : parameter_declaration

-                            | parameter_list COMMA parameter_declaration

-        """

-        if len(p) == 2: # single parameter

-            p[0] = c_ast.ParamList([p[1]], p[1].coord)

-        else:

-            p[1].params.append(p[3])

-            p[0] = p[1]

-

-    def p_parameter_declaration_1(self, p):

-        """ parameter_declaration   : declaration_specifiers declarator

-        """

-        spec = p[1]

-        decl = p[2]

-        

-        decl = c_ast.Decl(

-            name=None,

-            quals=spec['qual'],

-            storage=spec['storage'],

-            funcspec=spec['function'],

-            type=decl, 

-            init=None, 

-            bitsize=None, 

-            coord=decl.coord)

-        

-        typename = spec['type'] or ['int']

-        p[0] = self._fix_decl_name_type(decl, typename)

-        

-    def p_parameter_declaration_2(self, p):

-        """ parameter_declaration   : declaration_specifiers abstract_declarator_opt

-        """

-        spec = p[1]

-        decl = c_ast.Typename(

-            quals=spec['qual'], 

-            type=p[2] or c_ast.TypeDecl(None, None, None))

-            

-        typename = spec['type'] or ['int']

-        p[0] = self._fix_decl_name_type(decl, typename)        

-    

-    def p_identifier_list(self, p):

-        """ identifier_list : identifier

-                            | identifier_list COMMA identifier

-        """

-        if len(p) == 2: # single parameter

-            p[0] = c_ast.ParamList([p[1]], p[1].coord)

-        else:

-            p[1].params.append(p[3])

-            p[0] = p[1]

-

-    def p_initializer_1(self, p):

-        """ initializer : assignment_expression

-        """

-        p[0] = p[1]

-    

-    def p_initializer_2(self, p):

-        """ initializer : LBRACE initializer_list RBRACE

-                        | LBRACE initializer_list COMMA RBRACE

-        """

-        p[0] = p[2]

-

-    def p_initializer_list(self, p):

-        """ initializer_list    : designation_opt initializer

-                                | initializer_list COMMA designation_opt initializer

-        """

-        if len(p) == 3: # single initializer

-            init = p[2] if p[1] is None else c_ast.NamedInitializer(p[1], p[2])

-            p[0] = c_ast.ExprList([init], p[2].coord)

-        else:

-            init = p[4] if p[3] is None else c_ast.NamedInitializer(p[3], p[4])

-            p[1].exprs.append(init)

-            p[0] = p[1]

-    

+        """
+        p[0] = p[1]
+    
+    def p_type_specifier_1(self, p):
+        """ type_specifier  : VOID
+                            | CHAR
+                            | SHORT
+                            | INT
+                            | LONG
+                            | FLOAT
+                            | DOUBLE
+                            | SIGNED
+                            | UNSIGNED
+                            | typedef_name
+                            | enum_specifier
+                            | struct_or_union_specifier
+        """
+        p[0] = p[1]
+    
+    def p_type_qualifier(self, p):
+        """ type_qualifier  : CONST
+                            | RESTRICT
+                            | VOLATILE
+        """
+        p[0] = p[1]
+    
+    def p_init_declarator_list(self, p):
+        """ init_declarator_list    : init_declarator
+                                    | init_declarator_list COMMA init_declarator
+        """
+        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]
+
+    # Returns a (declarator, initializer) pair
+    # If there's no initializer, returns (declarator, None)
+    #
+    def p_init_declarator(self, p):
+        """ init_declarator : declarator
+                            | declarator EQUALS initializer
+        """
+        p[0] = (p[1], p[3] if len(p) > 2 else None)        
+    
+    def p_specifier_qualifier_list_1(self, p):
+        """ specifier_qualifier_list    : type_qualifier specifier_qualifier_list_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'qual')
+        
+    def p_specifier_qualifier_list_2(self, p):
+        """ specifier_qualifier_list    : type_specifier specifier_qualifier_list_opt
+        """
+        p[0] = self._add_declaration_specifier(p[2], p[1], 'type')
+
+    # TYPEID is allowed here (and in other struct/enum related tag names), because
+    # struct/enum tags reside in their own namespace and can be named the same as types
+    #
+    def p_struct_or_union_specifier_1(self, p):
+        """ struct_or_union_specifier   : struct_or_union ID
+                                        | struct_or_union TYPEID
+        """
+        klass = self._select_struct_union_class(p[1])
+        p[0] = klass(
+            name=p[2], 
+            decls=None, 
+            coord=self._coord(p.lineno(2)))
+
+    def p_struct_or_union_specifier_2(self, p):
+        """ struct_or_union_specifier : struct_or_union LBRACE struct_declaration_list RBRACE
+        """
+        klass = self._select_struct_union_class(p[1])
+        p[0] = klass(
+            name=None,
+            decls=p[3],
+            coord=self._coord(p.lineno(2)))
+
+    def p_struct_or_union_specifier_3(self, p):
+        """ struct_or_union_specifier   : struct_or_union ID LBRACE struct_declaration_list RBRACE
+                                        | struct_or_union TYPEID LBRACE struct_declaration_list RBRACE
+        """
+        klass = self._select_struct_union_class(p[1])
+        p[0] = klass(
+            name=p[2],
+            decls=p[4],
+            coord=self._coord(p.lineno(2)))
+
+    def p_struct_or_union(self, p):
+        """ struct_or_union : STRUCT 
+                            | UNION
+        """
+        p[0] = p[1]
+
+    # Combine all declarations into a single list
+    #
+    def p_struct_declaration_list(self, p):
+        """ struct_declaration_list     : struct_declaration
+                                        | struct_declaration_list struct_declaration
+        """
+        p[0] = p[1] if len(p) == 2 else p[1] + p[2]
+
+    def p_struct_declaration_1(self, p):
+        """ struct_declaration : specifier_qualifier_list struct_declarator_list SEMI
+        """
+        spec = p[1]
+        decls = []
+        
+        for struct_decl in p[2]:
+            if struct_decl['decl'] is not None:
+                decl_coord = struct_decl['decl'].coord
+            else:
+                decl_coord = struct_decl['bitsize'].coord
+            
+            decl = c_ast.Decl(
+                name=None,
+                quals=spec['qual'],
+                funcspec=spec['function'],
+                storage=spec['storage'],
+                type=struct_decl['decl'],
+                init=None,
+                bitsize=struct_decl['bitsize'],
+                coord=decl_coord)
+            
+            typename = spec['type']
+            decls.append(self._fix_decl_name_type(decl, typename))
+        
+        p[0] = decls
+    
+    def p_struct_declarator_list(self, p):
+        """ struct_declarator_list  : struct_declarator
+                                    | struct_declarator_list COMMA struct_declarator
+        """
+        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]
+    
+    # struct_declarator passes up a dict with the keys: decl (for
+    # the underlying declarator) and bitsize (for the bitsize)
+    #
+    def p_struct_declarator_1(self, p):
+        """ struct_declarator : declarator
+        """
+        p[0] = {'decl': p[1], 'bitsize': None}
+    
+    def p_struct_declarator_2(self, p):
+        """ struct_declarator   : declarator COLON constant_expression
+                                | COLON constant_expression
+        """
+        if len(p) > 3:
+            p[0] = {'decl': p[1], 'bitsize': p[3]}
+        else:
+            p[0] = {'decl': c_ast.TypeDecl(None, None, None), 'bitsize': p[2]}
+    
+    def p_enum_specifier_1(self, p):
+        """ enum_specifier  : ENUM ID
+                            | ENUM TYPEID
+        """
+        p[0] = c_ast.Enum(p[2], None, self._coord(p.lineno(1)))
+    
+    def p_enum_specifier_2(self, p):
+        """ enum_specifier  : ENUM LBRACE enumerator_list RBRACE
+        """
+        p[0] = c_ast.Enum(None, p[3], self._coord(p.lineno(1)))
+    
+    def p_enum_specifier_3(self, p):
+        """ enum_specifier  : ENUM ID LBRACE enumerator_list RBRACE
+                            | ENUM TYPEID LBRACE enumerator_list RBRACE
+        """
+        p[0] = c_ast.Enum(p[2], p[4], self._coord(p.lineno(1)))
+        
+    def p_enumerator_list(self, p):
+        """ enumerator_list : enumerator
+                            | enumerator_list COMMA
+                            | enumerator_list COMMA enumerator
+        """
+        if len(p) == 2:
+            p[0] = c_ast.EnumeratorList([p[1]], p[1].coord)
+        elif len(p) == 3:
+            p[0] = p[1]
+        else:
+            p[1].enumerators.append(p[3])
+            p[0] = p[1]
+
+    def p_enumerator(self, p):
+        """ enumerator  : ID
+                        | ID EQUALS constant_expression
+        """
+        if len(p) == 2:
+            p[0] = c_ast.Enumerator(
+                        p[1], None, 
+                        self._coord(p.lineno(1)))
+        else:
+            p[0] = c_ast.Enumerator(
+                        p[1], p[3], 
+                        self._coord(p.lineno(1)))
+    
+    def p_declarator_1(self, p):
+        """ declarator  : direct_declarator 
+        """
+        p[0] = p[1]
+    
+    def p_declarator_2(self, p):
+        """ declarator  : pointer direct_declarator 
+        """
+        p[0] = self._type_modify_decl(p[2], p[1])
+    
+    def p_direct_declarator_1(self, p):
+        """ direct_declarator   : ID 
+        """
+        p[0] = c_ast.TypeDecl(
+            declname=p[1], 
+            type=None, 
+            quals=None,
+            coord=self._coord(p.lineno(1)))
+        
+    def p_direct_declarator_2(self, p):
+        """ direct_declarator   : LPAREN declarator RPAREN 
+        """
+        p[0] = p[2]
+        
+    def p_direct_declarator_3(self, p):
+        """ direct_declarator   : direct_declarator LBRACKET assignment_expression_opt RBRACKET 
+        """
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=p[3],
+            coord=p[1].coord)
+        
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    # Special for VLAs
+    #
+    def p_direct_declarator_4(self, p):
+        """ direct_declarator   : direct_declarator LBRACKET TIMES RBRACKET 
+        """
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),
+            coord=p[1].coord)
+        
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    def p_direct_declarator_5(self, p):
+        """ direct_declarator   : direct_declarator LPAREN parameter_type_list RPAREN 
+                                | direct_declarator LPAREN identifier_list_opt RPAREN
+        """
+        func = c_ast.FuncDecl(
+            args=p[3],
+            type=None,
+            coord=p[1].coord)
+        
+        p[0] = self._type_modify_decl(decl=p[1], modifier=func)
+    
+    def p_pointer(self, p):
+        """ pointer : TIMES type_qualifier_list_opt
+                    | TIMES type_qualifier_list_opt pointer
+        """
+        coord = self._coord(p.lineno(1))
+        
+        p[0] = c_ast.PtrDecl(
+            quals=p[2] or [],
+            type=p[3] if len(p) > 3 else None,
+            coord=coord)
+    
+    def p_type_qualifier_list(self, p):
+        """ type_qualifier_list : type_qualifier
+                                | type_qualifier_list type_qualifier
+        """
+        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]
+    
+    def p_parameter_type_list(self, p):
+        """ parameter_type_list : parameter_list
+                                | parameter_list COMMA ELLIPSIS
+        """
+        if len(p) > 2: 
+            p[1].params.append(c_ast.EllipsisParam())
+        
+        p[0] = p[1]
+
+    def p_parameter_list(self, p):
+        """ parameter_list  : parameter_declaration
+                            | parameter_list COMMA parameter_declaration
+        """
+        if len(p) == 2: # single parameter
+            p[0] = c_ast.ParamList([p[1]], p[1].coord)
+        else:
+            p[1].params.append(p[3])
+            p[0] = p[1]
+
+    def p_parameter_declaration_1(self, p):
+        """ parameter_declaration   : declaration_specifiers declarator
+        """
+        spec = p[1]
+        decl = p[2]
+        
+        decl = c_ast.Decl(
+            name=None,
+            quals=spec['qual'],
+            storage=spec['storage'],
+            funcspec=spec['function'],
+            type=decl, 
+            init=None, 
+            bitsize=None, 
+            coord=decl.coord)
+        
+        typename = spec['type'] or ['int']
+        p[0] = self._fix_decl_name_type(decl, typename)
+        
+    def p_parameter_declaration_2(self, p):
+        """ parameter_declaration   : declaration_specifiers abstract_declarator_opt
+        """
+        spec = p[1]
+        decl = c_ast.Typename(
+            quals=spec['qual'], 
+            type=p[2] or c_ast.TypeDecl(None, None, None))
+            
+        typename = spec['type'] or ['int']
+        p[0] = self._fix_decl_name_type(decl, typename)        
+    
+    def p_identifier_list(self, p):
+        """ identifier_list : identifier
+                            | identifier_list COMMA identifier
+        """
+        if len(p) == 2: # single parameter
+            p[0] = c_ast.ParamList([p[1]], p[1].coord)
+        else:
+            p[1].params.append(p[3])
+            p[0] = p[1]
+
+    def p_initializer_1(self, p):
+        """ initializer : assignment_expression
+        """
+        p[0] = p[1]
+    
+    def p_initializer_2(self, p):
+        """ initializer : LBRACE initializer_list RBRACE
+                        | LBRACE initializer_list COMMA RBRACE
+        """
+        p[0] = p[2]
+
+    def p_initializer_list(self, p):
+        """ initializer_list    : designation_opt initializer
+                                | initializer_list COMMA designation_opt initializer
+        """
+        if len(p) == 3: # single initializer
+            init = p[2] if p[1] is None else c_ast.NamedInitializer(p[1], p[2])
+            p[0] = c_ast.ExprList([init], p[2].coord)
+        else:
+            init = p[4] if p[3] is None else c_ast.NamedInitializer(p[3], p[4])
+            p[1].exprs.append(init)
+            p[0] = p[1]
+    
     def p_designation(self, p):
         """ designation : designator_list EQUALS
-        """

-        p[0] = p[1]

-    

-    # Designators are represented as a list of nodes, in the order in which

-    # they're written in the code.

-    #

+        """
+        p[0] = p[1]
+    
+    # Designators are represented as a list of nodes, in the order in which
+    # they're written in the code.
+    #
     def p_designator_list(self, p):
-        """ designator_list : designator

+        """ designator_list : designator
                             | designator_list designator
-        """

-        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]

-    

+        """
+        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]
+    
     def p_designator(self, p):
-        """ designator  : LBRACKET constant_expression RBRACKET

+        """ designator  : LBRACKET constant_expression RBRACKET
                         | PERIOD identifier
-        """

-        p[0] = p[2]

-    

-    def p_type_name(self, p):

-        """ type_name   : specifier_qualifier_list abstract_declarator_opt 

-        """

-        #~ print '=========='

-        #~ print p[1]

-        #~ print p[2]

-        #~ print p[2].children()

-        #~ print '=========='

-        

-        typename = c_ast.Typename(

-            quals=p[1]['qual'], 

-            type=p[2] or c_ast.TypeDecl(None, None, None))

-        

-        p[0] = self._fix_decl_name_type(typename, p[1]['type'])

-

-    def p_abstract_declarator_1(self, p):

-        """ abstract_declarator     : pointer

-        """

-        dummytype = c_ast.TypeDecl(None, None, None)

-        p[0] = self._type_modify_decl(

-            decl=dummytype, 

-            modifier=p[1])

-        

-    def p_abstract_declarator_2(self, p):

-        """ abstract_declarator     : pointer direct_abstract_declarator

-        """

-        p[0] = self._type_modify_decl(p[2], p[1])

-        

-    def p_abstract_declarator_3(self, p):

-        """ abstract_declarator     : direct_abstract_declarator

-        """

-        p[0] = p[1]

-    

-    # Creating and using direct_abstract_declarator_opt here 

-    # instead of listing both direct_abstract_declarator and the

-    # lack of it in the beginning of _1 and _2 caused two 

-    # shift/reduce errors.

-    #

-    def p_direct_abstract_declarator_1(self, p):

-        """ direct_abstract_declarator  : LPAREN abstract_declarator RPAREN """

-        p[0] = p[2]

-    

-    def p_direct_abstract_declarator_2(self, p):

-        """ direct_abstract_declarator  : direct_abstract_declarator LBRACKET assignment_expression_opt RBRACKET 

-        """

-        arr = c_ast.ArrayDecl(

-            type=None,

-            dim=p[3],

-            coord=p[1].coord)

-        

-        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

-        

-    def p_direct_abstract_declarator_3(self, p):

-        """ direct_abstract_declarator  : LBRACKET assignment_expression_opt RBRACKET 

-        """

-        p[0] = c_ast.ArrayDecl(

-            type=c_ast.TypeDecl(None, None, None),

-            dim=p[2],

-            coord=self._coord(p.lineno(1)))

-

-    def p_direct_abstract_declarator_4(self, p):

-        """ direct_abstract_declarator  : direct_abstract_declarator LBRACKET TIMES RBRACKET 

-        """

-        arr = c_ast.ArrayDecl(

-            type=None,

-            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),

-            coord=p[1].coord)

-        

-        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

-

-    def p_direct_abstract_declarator_5(self, p):

-        """ direct_abstract_declarator  : LBRACKET TIMES RBRACKET 

-        """

-        p[0] = c_ast.ArrayDecl(

-            type=c_ast.TypeDecl(None, None, None),

-            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),

-            coord=self._coord(p.lineno(1)))

-

-    def p_direct_abstract_declarator_6(self, p):

-        """ direct_abstract_declarator  : direct_abstract_declarator LPAREN parameter_type_list_opt RPAREN 

-        """

-        func = c_ast.FuncDecl(

-            args=p[3],

-            type=None,

-            coord=p[1].coord)

-        

-        p[0] = self._type_modify_decl(decl=p[1], modifier=func)

-        

-    def p_direct_abstract_declarator_7(self, p):

-        """ direct_abstract_declarator  : LPAREN parameter_type_list_opt RPAREN 

-        """

-        p[0] = c_ast.FuncDecl(

-            args=p[2],

-            type=c_ast.TypeDecl(None, None, None),

-            coord=self._coord(p.lineno(1)))

-    

-    # declaration is a list, statement isn't. To make it consistent, block_item

-    # will always be a list

-    #

+        """
+        p[0] = p[2]
+    
+    def p_type_name(self, p):
+        """ type_name   : specifier_qualifier_list abstract_declarator_opt 
+        """
+        #~ print '=========='
+        #~ print p[1]
+        #~ print p[2]
+        #~ print p[2].children()
+        #~ print '=========='
+        
+        typename = c_ast.Typename(
+            quals=p[1]['qual'], 
+            type=p[2] or c_ast.TypeDecl(None, None, None))
+        
+        p[0] = self._fix_decl_name_type(typename, p[1]['type'])
+
+    def p_abstract_declarator_1(self, p):
+        """ abstract_declarator     : pointer
+        """
+        dummytype = c_ast.TypeDecl(None, None, None)
+        p[0] = self._type_modify_decl(
+            decl=dummytype, 
+            modifier=p[1])
+        
+    def p_abstract_declarator_2(self, p):
+        """ abstract_declarator     : pointer direct_abstract_declarator
+        """
+        p[0] = self._type_modify_decl(p[2], p[1])
+        
+    def p_abstract_declarator_3(self, p):
+        """ abstract_declarator     : direct_abstract_declarator
+        """
+        p[0] = p[1]
+    
+    # Creating and using direct_abstract_declarator_opt here 
+    # instead of listing both direct_abstract_declarator and the
+    # lack of it in the beginning of _1 and _2 caused two 
+    # shift/reduce errors.
+    #
+    def p_direct_abstract_declarator_1(self, p):
+        """ direct_abstract_declarator  : LPAREN abstract_declarator RPAREN """
+        p[0] = p[2]
+    
+    def p_direct_abstract_declarator_2(self, p):
+        """ direct_abstract_declarator  : direct_abstract_declarator LBRACKET assignment_expression_opt RBRACKET 
+        """
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=p[3],
+            coord=p[1].coord)
+        
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+        
+    def p_direct_abstract_declarator_3(self, p):
+        """ direct_abstract_declarator  : LBRACKET assignment_expression_opt RBRACKET 
+        """
+        p[0] = c_ast.ArrayDecl(
+            type=c_ast.TypeDecl(None, None, None),
+            dim=p[2],
+            coord=self._coord(p.lineno(1)))
+
+    def p_direct_abstract_declarator_4(self, p):
+        """ direct_abstract_declarator  : direct_abstract_declarator LBRACKET TIMES RBRACKET 
+        """
+        arr = c_ast.ArrayDecl(
+            type=None,
+            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),
+            coord=p[1].coord)
+        
+        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)
+
+    def p_direct_abstract_declarator_5(self, p):
+        """ direct_abstract_declarator  : LBRACKET TIMES RBRACKET 
+        """
+        p[0] = c_ast.ArrayDecl(
+            type=c_ast.TypeDecl(None, None, None),
+            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),
+            coord=self._coord(p.lineno(1)))
+
+    def p_direct_abstract_declarator_6(self, p):
+        """ direct_abstract_declarator  : direct_abstract_declarator LPAREN parameter_type_list_opt RPAREN 
+        """
+        func = c_ast.FuncDecl(
+            args=p[3],
+            type=None,
+            coord=p[1].coord)
+        
+        p[0] = self._type_modify_decl(decl=p[1], modifier=func)
+        
+    def p_direct_abstract_declarator_7(self, p):
+        """ direct_abstract_declarator  : LPAREN parameter_type_list_opt RPAREN 
+        """
+        p[0] = c_ast.FuncDecl(
+            args=p[2],
+            type=c_ast.TypeDecl(None, None, None),
+            coord=self._coord(p.lineno(1)))
+    
+    # declaration is a list, statement isn't. To make it consistent, block_item
+    # will always be a list
+    #
     def p_block_item(self, p):
-        """ block_item  : declaration

+        """ block_item  : declaration
                         | statement
-        """

-        p[0] = p[1] if isinstance(p[1], list) else [p[1]]

-    

-    # Since we made block_item a list, this just combines lists

-    # 

-    def p_block_item_list(self, p):

-        """ block_item_list : block_item 

-                            | block_item_list block_item

-        """

-        p[0] = p[1] if len(p) == 2 else p[1] + p[2]

-    

-    def p_compound_statement_1(self, p):

-        """ compound_statement : LBRACE block_item_list_opt RBRACE """

-        p[0] = c_ast.Compound(

-            block_items=p[2], 

-            coord=self._coord(p.lineno(1)))

-    

-    def p_labeled_statement_1(self, p):

-        """ labeled_statement : ID COLON statement """

-        p[0] = c_ast.Label(p[1], p[3], self._coord(p.lineno(1)))

-    

-    def p_labeled_statement_2(self, p):

-        """ labeled_statement : CASE constant_expression COLON statement """

-        p[0] = c_ast.Case(p[2], p[4], self._coord(p.lineno(1)))

-        

-    def p_labeled_statement_3(self, p):

-        """ labeled_statement : DEFAULT COLON statement """

-        p[0] = c_ast.Default(p[3], self._coord(p.lineno(1)))

-        

-    def p_selection_statement_1(self, p):

-        """ selection_statement : IF LPAREN expression RPAREN statement """

-        p[0] = c_ast.If(p[3], p[5], None, self._coord(p.lineno(1)))

-    

-    def p_selection_statement_2(self, p):

-        """ selection_statement : IF LPAREN expression RPAREN statement ELSE statement """

-        p[0] = c_ast.If(p[3], p[5], p[7], self._coord(p.lineno(1)))

-    

-    def p_selection_statement_3(self, p):

-        """ selection_statement : SWITCH LPAREN expression RPAREN statement """

-        p[0] = c_ast.Switch(p[3], p[5], self._coord(p.lineno(1)))

-    

-    def p_iteration_statement_1(self, p):

-        """ iteration_statement : WHILE LPAREN expression RPAREN statement """

-        p[0] = c_ast.While(p[3], p[5], self._coord(p.lineno(1)))

-    

-    def p_iteration_statement_2(self, p):

-        """ iteration_statement : DO statement WHILE LPAREN expression RPAREN SEMI """

-        p[0] = c_ast.DoWhile(p[5], p[2], self._coord(p.lineno(1)))

-    

-    def p_iteration_statement_3(self, p):

-        """ iteration_statement : FOR LPAREN expression_opt SEMI expression_opt SEMI expression_opt RPAREN statement """

-        p[0] = c_ast.For(p[3], p[5], p[7], p[9], self._coord(p.lineno(1)))

-    

-    def p_iteration_statement_4(self, p):

-        """ iteration_statement : FOR LPAREN declaration expression_opt SEMI expression_opt RPAREN statement """

-        p[0] = c_ast.For(c_ast.DeclList(p[3]), p[4], p[6], p[8], self._coord(p.lineno(1)))

-

-    def p_jump_statement_1(self, p):

-        """ jump_statement  : GOTO ID SEMI """

-        p[0] = c_ast.Goto(p[2], self._coord(p.lineno(1)))

-    

-    def p_jump_statement_2(self, p):

-        """ jump_statement  : BREAK SEMI """

-        p[0] = c_ast.Break(self._coord(p.lineno(1)))

-    

-    def p_jump_statement_3(self, p):

-        """ jump_statement  : CONTINUE SEMI """

-        p[0] = c_ast.Continue(self._coord(p.lineno(1)))

-        

-    def p_jump_statement_4(self, p):

-        """ jump_statement  : RETURN expression SEMI  

-                            | RETURN SEMI 

-        """

-        p[0] = c_ast.Return(p[2] if len(p) == 4 else None, self._coord(p.lineno(1)))

-    

-    def p_expression_statement(self, p):

-        """ expression_statement : expression_opt SEMI """

-        p[0] = p[1]

-    

-    def p_expression(self, p):

-        """ expression  : assignment_expression 

-                        | expression COMMA assignment_expression

-        """

-        if len(p) == 2:

-            p[0] = p[1]

-        else:

-            if not isinstance(p[1], c_ast.ExprList):

-                p[1] = c_ast.ExprList([p[1]], p[1].coord)

-            

-            p[1].exprs.append(p[3])

-            p[0] = p[1] 

-

-    def p_typedef_name(self, p):

-        """ typedef_name : TYPEID """

-        p[0] = p[1]

-

-    def p_assignment_expression(self, p):

-        """ assignment_expression   : conditional_expression

-                                    | unary_expression assignment_operator assignment_expression

-        """

-        if len(p) == 2:

-            p[0] = p[1]

-        else:

-            p[0] = c_ast.Assignment(p[2], p[1], p[3], p[1].coord)

-

-    # K&R2 defines these as many separate rules, to encode 

-    # precedence and associativity. Why work hard ? I'll just use

-    # the built in precedence/associativity specification feature

-    # of PLY. (see precedence declaration above)

-    #

-    def p_assignment_operator(self, p):

-        """ assignment_operator : EQUALS

-                                | XOREQUAL   

-                                | TIMESEQUAL  

-                                | DIVEQUAL    

-                                | MODEQUAL    

-                                | PLUSEQUAL   

-                                | MINUSEQUAL  

-                                | LSHIFTEQUAL 

-                                | RSHIFTEQUAL 

-                                | ANDEQUAL    

-                                | OREQUAL     

-        """

-        p[0] = p[1]

-        

-    def p_constant_expression(self, p):

-        """ constant_expression : conditional_expression """

-        p[0] = p[1]

-    

-    def p_conditional_expression(self, p):

-        """ conditional_expression  : binary_expression

-                                    | binary_expression CONDOP expression COLON conditional_expression

-        """

-        if len(p) == 2:

-            p[0] = p[1]

-        else:

-            p[0] = c_ast.TernaryOp(p[1], p[3], p[5], p[1].coord)

-    

-    def p_binary_expression(self, p):

-        """ binary_expression   : cast_expression

-                                | binary_expression TIMES binary_expression

-                                | binary_expression DIVIDE binary_expression

-                                | binary_expression MOD binary_expression

-                                | binary_expression PLUS binary_expression

-                                | binary_expression MINUS binary_expression

-                                | binary_expression RSHIFT binary_expression

-                                | binary_expression LSHIFT binary_expression

-                                | binary_expression LT binary_expression

-                                | binary_expression LE binary_expression

-                                | binary_expression GE binary_expression

-                                | binary_expression GT binary_expression

-                                | binary_expression EQ binary_expression

-                                | binary_expression NE binary_expression

-                                | binary_expression AND binary_expression

-                                | binary_expression OR binary_expression

-                                | binary_expression XOR binary_expression

-                                | binary_expression LAND binary_expression

-                                | binary_expression LOR binary_expression

-        """

-        if len(p) == 2:

-            p[0] = p[1]

-        else:

-            p[0] = c_ast.BinaryOp(p[2], p[1], p[3], p[1].coord)

-    

-    def p_cast_expression_1(self, p):

-        """ cast_expression : unary_expression """

-        p[0] = p[1]

-        

-    def p_cast_expression_2(self, p):

-        """ cast_expression : LPAREN type_name RPAREN cast_expression """

-        p[0] = c_ast.Cast(p[2], p[4], p[2].coord)

-    

-    def p_unary_expression_1(self, p):

-        """ unary_expression    : postfix_expression """

-        p[0] = p[1]

-    

-    def p_unary_expression_2(self, p):

-        """ unary_expression    : PLUSPLUS unary_expression 

-                                | MINUSMINUS unary_expression

-                                | unary_operator cast_expression

-        """

-        p[0] = c_ast.UnaryOp(p[1], p[2], p[2].coord)

-    

-    def p_unary_expression_3(self, p):

-        """ unary_expression    : SIZEOF unary_expression 

-                                | SIZEOF LPAREN type_name RPAREN

-        """

-        p[0] = c_ast.UnaryOp(

-            p[1], 

-            p[2] if len(p) == 3 else p[3], 

-            self._coord(p.lineno(1)))

-    

-    def p_unary_operator(self, p):

-        """ unary_operator  : AND

-                            | TIMES

-                            | PLUS

-                            | MINUS

-                            | NOT

-                            | LNOT

-        """

-        p[0] = p[1]

-                                

-    def p_postfix_exptession_1(self, p):

-        """ postfix_expression  : primary_expression """

-        p[0] = p[1]

-    

-    def p_postfix_exptession_2(self, p):

-        """ postfix_expression  : postfix_expression LBRACKET expression RBRACKET """

-        p[0] = c_ast.ArrayRef(p[1], p[3], p[1].coord)

-    

-    def p_postfix_exptession_3(self, p):

-        """ postfix_expression  : postfix_expression LPAREN argument_expression_list RPAREN

-                                | postfix_expression LPAREN RPAREN

-        """

-        p[0] = c_ast.FuncCall(p[1], p[3] if len(p) == 5 else None, p[1].coord)

-    

-    def p_postfix_expression_4(self, p):

-        """ postfix_expression  : postfix_expression PERIOD identifier

-                                | postfix_expression ARROW identifier

-        """

-        p[0] = c_ast.StructRef(p[1], p[2], p[3], p[1].coord)

-

-    def p_postfix_expression_5(self, p):

-        """ postfix_expression  : postfix_expression PLUSPLUS 

-                                | postfix_expression MINUSMINUS

-        """

-        p[0] = c_ast.UnaryOp('p' + p[2], p[1], p[1].coord)

-

+        """
+        p[0] = p[1] if isinstance(p[1], list) else [p[1]]
+    
+    # Since we made block_item a list, this just combines lists
+    # 
+    def p_block_item_list(self, p):
+        """ block_item_list : block_item 
+                            | block_item_list block_item
+        """
+        p[0] = p[1] if len(p) == 2 else p[1] + p[2]
+    
+    def p_compound_statement_1(self, p):
+        """ compound_statement : LBRACE block_item_list_opt RBRACE """
+        p[0] = c_ast.Compound(
+            block_items=p[2], 
+            coord=self._coord(p.lineno(1)))
+    
+    def p_labeled_statement_1(self, p):
+        """ labeled_statement : ID COLON statement """
+        p[0] = c_ast.Label(p[1], p[3], self._coord(p.lineno(1)))
+    
+    def p_labeled_statement_2(self, p):
+        """ labeled_statement : CASE constant_expression COLON statement """
+        p[0] = c_ast.Case(p[2], p[4], self._coord(p.lineno(1)))
+        
+    def p_labeled_statement_3(self, p):
+        """ labeled_statement : DEFAULT COLON statement """
+        p[0] = c_ast.Default(p[3], self._coord(p.lineno(1)))
+        
+    def p_selection_statement_1(self, p):
+        """ selection_statement : IF LPAREN expression RPAREN statement """
+        p[0] = c_ast.If(p[3], p[5], None, self._coord(p.lineno(1)))
+    
+    def p_selection_statement_2(self, p):
+        """ selection_statement : IF LPAREN expression RPAREN statement ELSE statement """
+        p[0] = c_ast.If(p[3], p[5], p[7], self._coord(p.lineno(1)))
+    
+    def p_selection_statement_3(self, p):
+        """ selection_statement : SWITCH LPAREN expression RPAREN statement """
+        p[0] = c_ast.Switch(p[3], p[5], self._coord(p.lineno(1)))
+    
+    def p_iteration_statement_1(self, p):
+        """ iteration_statement : WHILE LPAREN expression RPAREN statement """
+        p[0] = c_ast.While(p[3], p[5], self._coord(p.lineno(1)))
+    
+    def p_iteration_statement_2(self, p):
+        """ iteration_statement : DO statement WHILE LPAREN expression RPAREN SEMI """
+        p[0] = c_ast.DoWhile(p[5], p[2], self._coord(p.lineno(1)))
+    
+    def p_iteration_statement_3(self, p):
+        """ iteration_statement : FOR LPAREN expression_opt SEMI expression_opt SEMI expression_opt RPAREN statement """
+        p[0] = c_ast.For(p[3], p[5], p[7], p[9], self._coord(p.lineno(1)))
+    
+    def p_iteration_statement_4(self, p):
+        """ iteration_statement : FOR LPAREN declaration expression_opt SEMI expression_opt RPAREN statement """
+        p[0] = c_ast.For(c_ast.DeclList(p[3]), p[4], p[6], p[8], self._coord(p.lineno(1)))
+
+    def p_jump_statement_1(self, p):
+        """ jump_statement  : GOTO ID SEMI """
+        p[0] = c_ast.Goto(p[2], self._coord(p.lineno(1)))
+    
+    def p_jump_statement_2(self, p):
+        """ jump_statement  : BREAK SEMI """
+        p[0] = c_ast.Break(self._coord(p.lineno(1)))
+    
+    def p_jump_statement_3(self, p):
+        """ jump_statement  : CONTINUE SEMI """
+        p[0] = c_ast.Continue(self._coord(p.lineno(1)))
+        
+    def p_jump_statement_4(self, p):
+        """ jump_statement  : RETURN expression SEMI  
+                            | RETURN SEMI 
+        """
+        p[0] = c_ast.Return(p[2] if len(p) == 4 else None, self._coord(p.lineno(1)))
+    
+    def p_expression_statement(self, p):
+        """ expression_statement : expression_opt SEMI """
+        p[0] = p[1]
+    
+    def p_expression(self, p):
+        """ expression  : assignment_expression 
+                        | expression COMMA assignment_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            if not isinstance(p[1], c_ast.ExprList):
+                p[1] = c_ast.ExprList([p[1]], p[1].coord)
+            
+            p[1].exprs.append(p[3])
+            p[0] = p[1] 
+
+    def p_typedef_name(self, p):
+        """ typedef_name : TYPEID """
+        p[0] = p[1]
+
+    def p_assignment_expression(self, p):
+        """ assignment_expression   : conditional_expression
+                                    | unary_expression assignment_operator assignment_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = c_ast.Assignment(p[2], p[1], p[3], p[1].coord)
+
+    # K&R2 defines these as many separate rules, to encode 
+    # precedence and associativity. Why work hard ? I'll just use
+    # the built in precedence/associativity specification feature
+    # of PLY. (see precedence declaration above)
+    #
+    def p_assignment_operator(self, p):
+        """ assignment_operator : EQUALS
+                                | XOREQUAL   
+                                | TIMESEQUAL  
+                                | DIVEQUAL    
+                                | MODEQUAL    
+                                | PLUSEQUAL   
+                                | MINUSEQUAL  
+                                | LSHIFTEQUAL 
+                                | RSHIFTEQUAL 
+                                | ANDEQUAL    
+                                | OREQUAL     
+        """
+        p[0] = p[1]
+        
+    def p_constant_expression(self, p):
+        """ constant_expression : conditional_expression """
+        p[0] = p[1]
+    
+    def p_conditional_expression(self, p):
+        """ conditional_expression  : binary_expression
+                                    | binary_expression CONDOP expression COLON conditional_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = c_ast.TernaryOp(p[1], p[3], p[5], p[1].coord)
+    
+    def p_binary_expression(self, p):
+        """ binary_expression   : cast_expression
+                                | binary_expression TIMES binary_expression
+                                | binary_expression DIVIDE binary_expression
+                                | binary_expression MOD binary_expression
+                                | binary_expression PLUS binary_expression
+                                | binary_expression MINUS binary_expression
+                                | binary_expression RSHIFT binary_expression
+                                | binary_expression LSHIFT binary_expression
+                                | binary_expression LT binary_expression
+                                | binary_expression LE binary_expression
+                                | binary_expression GE binary_expression
+                                | binary_expression GT binary_expression
+                                | binary_expression EQ binary_expression
+                                | binary_expression NE binary_expression
+                                | binary_expression AND binary_expression
+                                | binary_expression OR binary_expression
+                                | binary_expression XOR binary_expression
+                                | binary_expression LAND binary_expression
+                                | binary_expression LOR binary_expression
+        """
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = c_ast.BinaryOp(p[2], p[1], p[3], p[1].coord)
+    
+    def p_cast_expression_1(self, p):
+        """ cast_expression : unary_expression """
+        p[0] = p[1]
+        
+    def p_cast_expression_2(self, p):
+        """ cast_expression : LPAREN type_name RPAREN cast_expression """
+        p[0] = c_ast.Cast(p[2], p[4], p[2].coord)
+    
+    def p_unary_expression_1(self, p):
+        """ unary_expression    : postfix_expression """
+        p[0] = p[1]
+    
+    def p_unary_expression_2(self, p):
+        """ unary_expression    : PLUSPLUS unary_expression 
+                                | MINUSMINUS unary_expression
+                                | unary_operator cast_expression
+        """
+        p[0] = c_ast.UnaryOp(p[1], p[2], p[2].coord)
+    
+    def p_unary_expression_3(self, p):
+        """ unary_expression    : SIZEOF unary_expression 
+                                | SIZEOF LPAREN type_name RPAREN
+        """
+        p[0] = c_ast.UnaryOp(
+            p[1], 
+            p[2] if len(p) == 3 else p[3], 
+            self._coord(p.lineno(1)))
+    
+    def p_unary_operator(self, p):
+        """ unary_operator  : AND
+                            | TIMES
+                            | PLUS
+                            | MINUS
+                            | NOT
+                            | LNOT
+        """
+        p[0] = p[1]
+                                
+    def p_postfix_exptession_1(self, p):
+        """ postfix_expression  : primary_expression """
+        p[0] = p[1]
+    
+    def p_postfix_exptession_2(self, p):
+        """ postfix_expression  : postfix_expression LBRACKET expression RBRACKET """
+        p[0] = c_ast.ArrayRef(p[1], p[3], p[1].coord)
+    
+    def p_postfix_exptession_3(self, p):
+        """ postfix_expression  : postfix_expression LPAREN argument_expression_list RPAREN
+                                | postfix_expression LPAREN RPAREN
+        """
+        p[0] = c_ast.FuncCall(p[1], p[3] if len(p) == 5 else None, p[1].coord)
+    
+    def p_postfix_expression_4(self, p):
+        """ postfix_expression  : postfix_expression PERIOD identifier
+                                | postfix_expression ARROW identifier
+        """
+        p[0] = c_ast.StructRef(p[1], p[2], p[3], p[1].coord)
+
+    def p_postfix_expression_5(self, p):
+        """ postfix_expression  : postfix_expression PLUSPLUS 
+                                | postfix_expression MINUSMINUS
+        """
+        p[0] = c_ast.UnaryOp('p' + p[2], p[1], p[1].coord)
+
     def p_postfix_expression_6(self, p):
-        """ postfix_expression  : LPAREN type_name RPAREN LBRACE initializer_list RBRACE

-                                | LPAREN type_name RPAREN LBRACE initializer_list COMMA RBRACE

-        """

-        p[0] = c_ast.CompoundLiteral(p[2], p[5])

-

-    def p_primary_expression_1(self, p):

-        """ primary_expression  : identifier """

-        p[0] = p[1]

-        

-    def p_primary_expression_2(self, p):

-        """ primary_expression  : constant """

-        p[0] = p[1]

-        

-    def p_primary_expression_3(self, p):

-        """ primary_expression  : unified_string_literal 

-                                | unified_wstring_literal

-        """

-        p[0] = p[1]

-            

-    def p_primary_expression_4(self, p):

-        """ primary_expression  : LPAREN expression RPAREN """

-        p[0] = p[2]

-        

-    def p_argument_expression_list(self, p):

-        """ argument_expression_list    : assignment_expression 

-                                        | argument_expression_list COMMA assignment_expression

-        """

-        if len(p) == 2: # single expr

-            p[0] = c_ast.ExprList([p[1]], p[1].coord)

-        else:

-            p[1].exprs.append(p[3])

-            p[0] = p[1]

-        

-    def p_identifier(self, p):

-        """ identifier  : ID """

-        p[0] = c_ast.ID(p[1], self._coord(p.lineno(1)))

-        

-    def p_constant_1(self, p):

-        """ constant    : INT_CONST_DEC

-                        | INT_CONST_OCT

-                        | INT_CONST_HEX

-        """

-        p[0] = c_ast.Constant(

-            'int', p[1], self._coord(p.lineno(1)))

-            

-    def p_constant_2(self, p):

-        """ constant    : FLOAT_CONST """

-        p[0] = c_ast.Constant(

-            'float', p[1], self._coord(p.lineno(1)))

-    

-    def p_constant_3(self, p):

-        """ constant    : CHAR_CONST

-                        | WCHAR_CONST

-        """

-        p[0] = c_ast.Constant(

-            'char', p[1], self._coord(p.lineno(1)))

-    

-    # The "unified" string and wstring literal rules are for supporting 

-    # concatenation of adjacent string literals.

-    # I.e. "hello " "world" is seen by the C compiler as a single string literal

-    # with the value "hello world"

-    #

+        """ postfix_expression  : LPAREN type_name RPAREN LBRACE initializer_list RBRACE
+                                | LPAREN type_name RPAREN LBRACE initializer_list COMMA RBRACE
+        """
+        p[0] = c_ast.CompoundLiteral(p[2], p[5])
+
+    def p_primary_expression_1(self, p):
+        """ primary_expression  : identifier """
+        p[0] = p[1]
+        
+    def p_primary_expression_2(self, p):
+        """ primary_expression  : constant """
+        p[0] = p[1]
+        
+    def p_primary_expression_3(self, p):
+        """ primary_expression  : unified_string_literal 
+                                | unified_wstring_literal
+        """
+        p[0] = p[1]
+            
+    def p_primary_expression_4(self, p):
+        """ primary_expression  : LPAREN expression RPAREN """
+        p[0] = p[2]
+        
+    def p_argument_expression_list(self, p):
+        """ argument_expression_list    : assignment_expression 
+                                        | argument_expression_list COMMA assignment_expression
+        """
+        if len(p) == 2: # single expr
+            p[0] = c_ast.ExprList([p[1]], p[1].coord)
+        else:
+            p[1].exprs.append(p[3])
+            p[0] = p[1]
+        
+    def p_identifier(self, p):
+        """ identifier  : ID """
+        p[0] = c_ast.ID(p[1], self._coord(p.lineno(1)))
+        
+    def p_constant_1(self, p):
+        """ constant    : INT_CONST_DEC
+                        | INT_CONST_OCT
+                        | INT_CONST_HEX
+        """
+        p[0] = c_ast.Constant(
+            'int', p[1], self._coord(p.lineno(1)))
+            
+    def p_constant_2(self, p):
+        """ constant    : FLOAT_CONST """
+        p[0] = c_ast.Constant(
+            'float', p[1], self._coord(p.lineno(1)))
+    
+    def p_constant_3(self, p):
+        """ constant    : CHAR_CONST
+                        | WCHAR_CONST
+        """
+        p[0] = c_ast.Constant(
+            'char', p[1], self._coord(p.lineno(1)))
+    
+    # The "unified" string and wstring literal rules are for supporting 
+    # concatenation of adjacent string literals.
+    # I.e. "hello " "world" is seen by the C compiler as a single string literal
+    # with the value "hello world"
+    #
     def p_unified_string_literal(self, p):
-        """ unified_string_literal  : STRING_LITERAL

+        """ unified_string_literal  : STRING_LITERAL
                                     | unified_string_literal STRING_LITERAL  
-        """

-        if len(p) == 2: # single literal

-            p[0] = c_ast.Constant(

-                'string', p[1], self._coord(p.lineno(1)))

-        else:

-            p[1].value = p[1].value[:-1] + p[2][1:]

-            p[0] = p[1]

-            

-    def p_unified_wstring_literal(self, p):

-        """ unified_wstring_literal : WSTRING_LITERAL

-                                    | unified_wstring_literal WSTRING_LITERAL  

-        """

-        if len(p) == 2: # single literal

-            p[0] = c_ast.Constant(

-                'string', p[1], self._coord(p.lineno(1)))

-        else:

-            p[1].value = p[1].value.rstrip[:-1] + p[2][1:]

-            p[0] = p[1]

-            

-    def p_empty(self, p):

-        'empty : '

-        p[0] = None

-        

-    def p_error(self, p):

-        if p:

-            self._parse_error(

-                'before: %s' % p.value, 

-                self._coord(p.lineno))

-        else:

-            self._parse_error('At end of input', '')

-

-

-if __name__ == "__main__":

-    import pprint

-    import time

-    from portability import printme

-    

-    t1 = time.time()

-    parser = CParser(lex_optimize=True, yacc_debug=True, yacc_optimize=False)

-    printme(time.time() - t1)

-    

-    buf = ''' 

-        int (*k)(int);

-    '''

-    

-    # set debuglevel to 2 for debugging

-    t = parser.parse(buf, 'x.c', debuglevel=0)

-    t.show(showcoord=True)

+        """
+        if len(p) == 2: # single literal
+            p[0] = c_ast.Constant(
+                'string', p[1], self._coord(p.lineno(1)))
+        else:
+            p[1].value = p[1].value[:-1] + p[2][1:]
+            p[0] = p[1]
+            
+    def p_unified_wstring_literal(self, p):
+        """ unified_wstring_literal : WSTRING_LITERAL
+                                    | unified_wstring_literal WSTRING_LITERAL  
+        """
+        if len(p) == 2: # single literal
+            p[0] = c_ast.Constant(
+                'string', p[1], self._coord(p.lineno(1)))
+        else:
+            p[1].value = p[1].value.rstrip[:-1] + p[2][1:]
+            p[0] = p[1]
+            
+    def p_empty(self, p):
+        'empty : '
+        p[0] = None
+        
+    def p_error(self, p):
+        if p:
+            self._parse_error(
+                'before: %s' % p.value, 
+                self._coord(p.lineno))
+        else:
+            self._parse_error('At end of input', '')
+
+
+if __name__ == "__main__":
+    import pprint
+    import time
+    from portability import printme
+    
+    t1 = time.time()
+    parser = CParser(lex_optimize=True, yacc_debug=True, yacc_optimize=False)
+    printme(time.time() - t1)
+    
+    buf = ''' 
+        int (*k)(int);
+    '''
+    
+    # set debuglevel to 2 for debugging
+    t = parser.parse(buf, 'x.c', debuglevel=0)
+    t.show(showcoord=True)