ECC: CParser remove \ in string.
[people/mcb30/basetools.git] / Source / Python / Ecc / CParser.py
index 3828e56..c730091 100644 (file)
@@ -1,4 +1,4 @@
-# $ANTLR 3.0.1 C.g 2008-01-25 19:33:35
+# $ANTLR 3.0.1 C.g 2008-01-28 16:35:58
 
 from antlr3 import *
 from antlr3.compat import set, frozenset
@@ -44,15 +44,15 @@ tokenNames = [
     "UnicodeEscape", "WS", "BS", "UnicodeVocabulary", "COMMENT", "LINE_COMMENT", 
     "LINE_COMMAND", "';'", "'typedef'", "','", "'='", "'extern'", "'static'", 
     "'auto'", "'register'", "'STATIC'", "'void'", "'char'", "'short'", "'int'", 
-    "'long'", "'float'", "'double'", "'signed'", "'unsigned'", "'{'", "'}'", 
-    "'struct'", "'union'", "':'", "'enum'", "'const'", "'volatile'", "'IN'", 
-    "'OUT'", "'OPTIONAL'", "'EFIAPI'", "'('", "')'", "'['", "']'", "'*'", 
-    "'...'", "'+'", "'-'", "'/'", "'%'", "'++'", "'--'", "'sizeof'", "'.'", 
-    "'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='", "'+='", "'-='", 
-    "'<<='", "'>>='", "'&='", "'^='", "'|='", "'?'", "'||'", "'&&'", "'|'", 
-    "'^'", "'=='", "'!='", "'<'", "'>'", "'<='", "'>='", "'<<'", "'>>'", 
-    "'case'", "'default'", "'if'", "'else'", "'switch'", "'while'", "'do'", 
-    "'for'", "'goto'", "'continue'", "'break'", "'return'"
+    "'long'", "'float'", "'double'", "'signed'", "'unsigned'", "'BOOLEAN'", 
+    "'{'", "'}'", "'struct'", "'union'", "':'", "'enum'", "'const'", "'volatile'", 
+    "'IN'", "'OUT'", "'OPTIONAL'", "'CONST'", "'EFIAPI'", "'('", "')'", 
+    "'['", "']'", "'*'", "'...'", "'+'", "'-'", "'/'", "'%'", "'++'", "'--'", 
+    "'sizeof'", "'.'", "'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='", 
+    "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='", "'?'", "'||'", 
+    "'&&'", "'|'", "'^'", "'=='", "'!='", "'<'", "'>'", "'<='", "'>='", 
+    "'<<'", "'>>'", "'case'", "'default'", "'if'", "'else'", "'switch'", 
+    "'while'", "'do'", "'for'", "'goto'", "'continue'", "'break'", "'return'"
 ]
 
 
@@ -135,7 +135,7 @@ class CParser(Parser):
                     alt1 = 2
                     LA1_0 = self.input.LA(1)
 
-                    if (LA1_0 == IDENTIFIER or LA1_0 == 26 or (29 <= LA1_0 <= 42) or (45 <= LA1_0 <= 46) or (48 <= LA1_0 <= 55) or LA1_0 == 59) :
+                    if (LA1_0 == IDENTIFIER or LA1_0 == 26 or (29 <= LA1_0 <= 43) or (46 <= LA1_0 <= 47) or (49 <= LA1_0 <= 57) or LA1_0 == 61) :
                         alt1 = 1
 
 
@@ -354,7 +354,7 @@ class CParser(Parser):
 
                         raise nvae
 
-                elif ((45 <= LA3_0 <= 46)) :
+                elif (LA3_0 == 43) :
                     LA3_11 = self.input.LA(2)
 
                     if (self.synpred4()) :
@@ -370,7 +370,7 @@ class CParser(Parser):
 
                         raise nvae
 
-                elif (LA3_0 == 48) :
+                elif ((46 <= LA3_0 <= 47)) :
                     LA3_12 = self.input.LA(2)
 
                     if (self.synpred4()) :
@@ -386,15 +386,13 @@ class CParser(Parser):
 
                         raise nvae
 
-                elif (LA3_0 == IDENTIFIER) :
+                elif (LA3_0 == 49) :
                     LA3_13 = self.input.LA(2)
 
                     if (self.synpred4()) :
                         alt3 = 1
                     elif (self.synpred5()) :
                         alt3 = 2
-                    elif (True) :
-                        alt3 = 3
                     else:
                         if self.backtracking > 0:
                             self.failed = True
@@ -404,13 +402,15 @@ class CParser(Parser):
 
                         raise nvae
 
-                elif ((49 <= LA3_0 <= 53)) :
+                elif (LA3_0 == IDENTIFIER) :
                     LA3_14 = self.input.LA(2)
 
                     if (self.synpred4()) :
                         alt3 = 1
                     elif (self.synpred5()) :
                         alt3 = 2
+                    elif (True) :
+                        alt3 = 3
                     else:
                         if self.backtracking > 0:
                             self.failed = True
@@ -420,11 +420,27 @@ class CParser(Parser):
 
                         raise nvae
 
-                elif (LA3_0 == 54) and (self.synpred4()):
+                elif ((50 <= LA3_0 <= 55)) :
+                    LA3_15 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return 
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 15, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 56) and (self.synpred4()):
                     alt3 = 1
-                elif (LA3_0 == 59) and (self.synpred4()):
+                elif (LA3_0 == 61) and (self.synpred4()):
                     alt3 = 1
-                elif (LA3_0 == 55) and (self.synpred4()):
+                elif (LA3_0 == 57) and (self.synpred4()):
                     alt3 = 1
                 elif (LA3_0 == 26) :
                     alt3 = 2
@@ -534,20 +550,13 @@ class CParser(Parser):
                 alt4 = 2
                 LA4_0 = self.input.LA(1)
 
-                if ((29 <= LA4_0 <= 42) or (45 <= LA4_0 <= 46) or (48 <= LA4_0 <= 53)) :
+                if ((29 <= LA4_0 <= 43) or (46 <= LA4_0 <= 47) or (49 <= LA4_0 <= 55)) :
                     alt4 = 1
                 elif (LA4_0 == IDENTIFIER) :
                     LA4 = self.input.LA(2)
-                    if LA4 == 54 or LA4 == 59:
-                        alt4 = 1
-                    elif LA4 == IDENTIFIER:
+                    if LA4 == 57:
                         LA4_20 = self.input.LA(3)
 
-                        if (self.synpred7()) :
-                            alt4 = 1
-                    elif LA4 == 55:
-                        LA4_21 = self.input.LA(3)
-
                         if (self.synpred7()) :
                             alt4 = 1
                     elif LA4 == 29 or LA4 == 30 or LA4 == 31 or LA4 == 32 or LA4 == 33:
@@ -600,21 +609,33 @@ class CParser(Parser):
 
                         if (self.synpred7()) :
                             alt4 = 1
-                    elif LA4 == 45 or LA4 == 46:
+                    elif LA4 == 43:
                         LA4_32 = self.input.LA(3)
 
                         if (self.synpred7()) :
                             alt4 = 1
-                    elif LA4 == 48:
+                    elif LA4 == 46 or LA4 == 47:
                         LA4_33 = self.input.LA(3)
 
                         if (self.synpred7()) :
                             alt4 = 1
-                    elif LA4 == 49 or LA4 == 50 or LA4 == 51 or LA4 == 52 or LA4 == 53:
+                    elif LA4 == 49:
                         LA4_34 = self.input.LA(3)
 
                         if (self.synpred7()) :
                             alt4 = 1
+                    elif LA4 == IDENTIFIER:
+                        LA4_35 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 50 or LA4 == 51 or LA4 == 52 or LA4 == 53 or LA4 == 54 or LA4 == 55:
+                        LA4_36 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 56 or LA4 == 61:
+                        alt4 = 1
                 if alt4 == 1:
                     # C.g:0:0: d= declaration_specifiers
                     self.following.append(self.FOLLOW_declaration_specifiers_in_function_definition147)
@@ -634,9 +655,9 @@ class CParser(Parser):
                 alt6 = 2
                 LA6_0 = self.input.LA(1)
 
-                if (LA6_0 == IDENTIFIER or LA6_0 == 26 or (29 <= LA6_0 <= 42) or (45 <= LA6_0 <= 46) or (48 <= LA6_0 <= 53)) :
+                if (LA6_0 == IDENTIFIER or LA6_0 == 26 or (29 <= LA6_0 <= 43) or (46 <= LA6_0 <= 47) or (49 <= LA6_0 <= 55)) :
                     alt6 = 1
-                elif (LA6_0 == 43) :
+                elif (LA6_0 == 44) :
                     alt6 = 2
                 else:
                     if self.backtracking > 0:
@@ -655,7 +676,7 @@ class CParser(Parser):
                         alt5 = 2
                         LA5_0 = self.input.LA(1)
 
-                        if (LA5_0 == IDENTIFIER or LA5_0 == 26 or (29 <= LA5_0 <= 42) or (45 <= LA5_0 <= 46) or (48 <= LA5_0 <= 53)) :
+                        if (LA5_0 == IDENTIFIER or LA5_0 == 26 or (29 <= LA5_0 <= 43) or (46 <= LA5_0 <= 47) or (49 <= LA5_0 <= 55)) :
                             alt5 = 1
 
 
@@ -770,7 +791,7 @@ class CParser(Parser):
 
                 if (LA9_0 == 26) :
                     alt9 = 1
-                elif (LA9_0 == IDENTIFIER or (29 <= LA9_0 <= 42) or (45 <= LA9_0 <= 46) or (48 <= LA9_0 <= 53)) :
+                elif (LA9_0 == IDENTIFIER or (29 <= LA9_0 <= 43) or (46 <= LA9_0 <= 47) or (49 <= LA9_0 <= 55)) :
                     alt9 = 2
                 else:
                     if self.backtracking > 0:
@@ -791,17 +812,17 @@ class CParser(Parser):
                     alt7 = 2
                     LA7_0 = self.input.LA(1)
 
-                    if ((29 <= LA7_0 <= 42) or (45 <= LA7_0 <= 46) or (48 <= LA7_0 <= 53)) :
+                    if ((29 <= LA7_0 <= 43) or (46 <= LA7_0 <= 47) or (49 <= LA7_0 <= 55)) :
                         alt7 = 1
                     elif (LA7_0 == IDENTIFIER) :
-                        LA7_13 = self.input.LA(2)
+                        LA7_14 = self.input.LA(2)
 
-                        if (LA7_13 == 55) :
-                            LA7_19 = self.input.LA(3)
+                        if (LA7_14 == 57) :
+                            LA7_20 = self.input.LA(3)
 
                             if (self.synpred10()) :
                                 alt7 = 1
-                        elif (LA7_13 == IDENTIFIER or (29 <= LA7_13 <= 42) or (45 <= LA7_13 <= 46) or (48 <= LA7_13 <= 54) or LA7_13 == 59) :
+                        elif (LA7_14 == IDENTIFIER or (29 <= LA7_14 <= 43) or (46 <= LA7_14 <= 47) or (49 <= LA7_14 <= 56) or LA7_14 == 61) :
                             alt7 = 1
                     if alt7 == 1:
                         # C.g:0:0: b= declaration_specifiers
@@ -843,7 +864,7 @@ class CParser(Parser):
                     alt8 = 2
                     LA8_0 = self.input.LA(1)
 
-                    if (LA8_0 == IDENTIFIER or (54 <= LA8_0 <= 55) or LA8_0 == 59) :
+                    if (LA8_0 == IDENTIFIER or (56 <= LA8_0 <= 57) or LA8_0 == 61) :
                         alt8 = 1
                     if alt8 == 1:
                         # C.g:0:0: t= init_declarator_list
@@ -889,7 +910,7 @@ class CParser(Parser):
 
 
     # $ANTLR start declaration_specifiers
-    # C.g:130:1: declaration_specifiers : ( storage_class_specifier | type_specifier ( pointer )? | type_qualifier )+ ;
+    # C.g:130:1: declaration_specifiers : ( storage_class_specifier | type_specifier | type_qualifier )+ ;
     def declaration_specifiers(self, ):
 
         retval = self.declaration_specifiers_return()
@@ -900,28 +921,35 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 5):
                     return retval
 
-                # C.g:131:2: ( ( storage_class_specifier | type_specifier ( pointer )? | type_qualifier )+ )
-                # C.g:131:6: ( storage_class_specifier | type_specifier ( pointer )? | type_qualifier )+
-                # C.g:131:6: ( storage_class_specifier | type_specifier ( pointer )? | type_qualifier )+
-                cnt11 = 0
-                while True: #loop11
-                    alt11 = 4
-                    LA11 = self.input.LA(1)
-                    if LA11 == IDENTIFIER:
-                        LA11_3 = self.input.LA(2)
+                # C.g:131:2: ( ( storage_class_specifier | type_specifier | type_qualifier )+ )
+                # C.g:131:6: ( storage_class_specifier | type_specifier | type_qualifier )+
+                # C.g:131:6: ( storage_class_specifier | type_specifier | type_qualifier )+
+                cnt10 = 0
+                while True: #loop10
+                    alt10 = 4
+                    LA10 = self.input.LA(1)
+                    if LA10 == IDENTIFIER:
+                        LA10_3 = self.input.LA(2)
+
+                        if (self.synpred14()) :
+                            alt10 = 2
+
+
+                    elif LA10 == 54:
+                        LA10_7 = self.input.LA(2)
 
                         if (self.synpred15()) :
-                            alt11 = 2
+                            alt10 = 3
 
 
-                    elif LA11 == 29 or LA11 == 30 or LA11 == 31 or LA11 == 32 or LA11 == 33:
-                        alt11 = 1
-                    elif LA11 == 34 or LA11 == 35 or LA11 == 36 or LA11 == 37 or LA11 == 38 or LA11 == 39 or LA11 == 40 or LA11 == 41 or LA11 == 42 or LA11 == 45 or LA11 == 46 or LA11 == 48:
-                        alt11 = 2
-                    elif LA11 == 49 or LA11 == 50 or LA11 == 51 or LA11 == 52 or LA11 == 53:
-                        alt11 = 3
+                    elif LA10 == 29 or LA10 == 30 or LA10 == 31 or LA10 == 32 or LA10 == 33:
+                        alt10 = 1
+                    elif LA10 == 34 or LA10 == 35 or LA10 == 36 or LA10 == 37 or LA10 == 38 or LA10 == 39 or LA10 == 40 or LA10 == 41 or LA10 == 42 or LA10 == 43 or LA10 == 46 or LA10 == 47 or LA10 == 49:
+                        alt10 = 2
+                    elif LA10 == 50 or LA10 == 51 or LA10 == 52 or LA10 == 53 or LA10 == 55:
+                        alt10 = 3
 
-                    if alt11 == 1:
+                    if alt10 == 1:
                         # C.g:131:10: storage_class_specifier
                         self.following.append(self.FOLLOW_storage_class_specifier_in_declaration_specifiers254)
                         self.storage_class_specifier()
@@ -930,37 +958,18 @@ class CParser(Parser):
                             return retval
 
 
-                    elif alt11 == 2:
-                        # C.g:132:7: type_specifier ( pointer )?
+                    elif alt10 == 2:
+                        # C.g:132:7: type_specifier
                         self.following.append(self.FOLLOW_type_specifier_in_declaration_specifiers262)
                         self.type_specifier()
                         self.following.pop()
                         if self.failed:
                             return retval
-                        # C.g:132:22: ( pointer )?
-                        alt10 = 2
-                        LA10_0 = self.input.LA(1)
-
-                        if (LA10_0 == 59) :
-                            LA10_1 = self.input.LA(2)
-
-                            if (self.synpred14()) :
-                                alt10 = 1
-                        if alt10 == 1:
-                            # C.g:0:0: pointer
-                            self.following.append(self.FOLLOW_pointer_in_declaration_specifiers264)
-                            self.pointer()
-                            self.following.pop()
-                            if self.failed:
-                                return retval
-
-
-
 
 
-                    elif alt11 == 3:
+                    elif alt10 == 3:
                         # C.g:133:13: type_qualifier
-                        self.following.append(self.FOLLOW_type_qualifier_in_declaration_specifiers279)
+                        self.following.append(self.FOLLOW_type_qualifier_in_declaration_specifiers276)
                         self.type_qualifier()
                         self.following.pop()
                         if self.failed:
@@ -968,17 +977,17 @@ class CParser(Parser):
 
 
                     else:
-                        if cnt11 >= 1:
-                            break #loop11
+                        if cnt10 >= 1:
+                            break #loop10
 
                         if self.backtracking > 0:
                             self.failed = True
                             return retval
 
-                        eee = EarlyExitException(11, self.input)
+                        eee = EarlyExitException(10, self.input)
                         raise eee
 
-                    cnt11 += 1
+                    cnt10 += 1
 
 
 
@@ -1021,26 +1030,26 @@ class CParser(Parser):
 
                 # C.g:138:2: ( init_declarator ( ',' init_declarator )* )
                 # C.g:138:4: init_declarator ( ',' init_declarator )*
-                self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list301)
+                self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list298)
                 self.init_declarator()
                 self.following.pop()
                 if self.failed:
                     return retval
                 # C.g:138:20: ( ',' init_declarator )*
-                while True: #loop12
-                    alt12 = 2
-                    LA12_0 = self.input.LA(1)
+                while True: #loop11
+                    alt11 = 2
+                    LA11_0 = self.input.LA(1)
 
-                    if (LA12_0 == 27) :
-                        alt12 = 1
+                    if (LA11_0 == 27) :
+                        alt11 = 1
 
 
-                    if alt12 == 1:
+                    if alt11 == 1:
                         # C.g:138:21: ',' init_declarator
-                        self.match(self.input, 27, self.FOLLOW_27_in_init_declarator_list304)
+                        self.match(self.input, 27, self.FOLLOW_27_in_init_declarator_list301)
                         if self.failed:
                             return retval
-                        self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list306)
+                        self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list303)
                         self.init_declarator()
                         self.following.pop()
                         if self.failed:
@@ -1048,7 +1057,7 @@ class CParser(Parser):
 
 
                     else:
-                        break #loop12
+                        break #loop11
 
 
 
@@ -1083,23 +1092,23 @@ class CParser(Parser):
 
                 # C.g:142:2: ( declarator ( '=' initializer )? )
                 # C.g:142:4: declarator ( '=' initializer )?
-                self.following.append(self.FOLLOW_declarator_in_init_declarator319)
+                self.following.append(self.FOLLOW_declarator_in_init_declarator316)
                 self.declarator()
                 self.following.pop()
                 if self.failed:
                     return 
                 # C.g:142:15: ( '=' initializer )?
-                alt13 = 2
-                LA13_0 = self.input.LA(1)
+                alt12 = 2
+                LA12_0 = self.input.LA(1)
 
-                if (LA13_0 == 28) :
-                    alt13 = 1
-                if alt13 == 1:
+                if (LA12_0 == 28) :
+                    alt12 = 1
+                if alt12 == 1:
                     # C.g:142:16: '=' initializer
-                    self.match(self.input, 28, self.FOLLOW_28_in_init_declarator322)
+                    self.match(self.input, 28, self.FOLLOW_28_in_init_declarator319)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_initializer_in_init_declarator324)
+                    self.following.append(self.FOLLOW_initializer_in_init_declarator321)
                     self.initializer()
                     self.following.pop()
                     if self.failed:
@@ -1173,7 +1182,7 @@ class CParser(Parser):
 
 
     # $ANTLR start type_specifier
-    # C.g:153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER declarator )=> type_id );
+    # C.g:153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | 'BOOLEAN' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER declarator )=> type_id );
     def type_specifier(self, ):
 
         type_specifier_StartIndex = self.input.index()
@@ -1187,109 +1196,118 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 9):
                     return 
 
-                # C.g:154:2: ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER declarator )=> type_id )
-                alt14 = 12
-                LA14_0 = self.input.LA(1)
+                # C.g:154:2: ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | 'BOOLEAN' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER declarator )=> type_id )
+                alt13 = 13
+                LA13_0 = self.input.LA(1)
 
-                if (LA14_0 == 34) :
-                    alt14 = 1
-                elif (LA14_0 == 35) :
-                    alt14 = 2
-                elif (LA14_0 == 36) :
-                    alt14 = 3
-                elif (LA14_0 == 37) :
-                    alt14 = 4
-                elif (LA14_0 == 38) :
-                    alt14 = 5
-                elif (LA14_0 == 39) :
-                    alt14 = 6
-                elif (LA14_0 == 40) :
-                    alt14 = 7
-                elif (LA14_0 == 41) :
-                    alt14 = 8
-                elif (LA14_0 == 42) :
-                    alt14 = 9
-                elif ((45 <= LA14_0 <= 46)) :
-                    alt14 = 10
-                elif (LA14_0 == 48) :
-                    alt14 = 11
-                elif (LA14_0 == IDENTIFIER) and (self.synpred34()):
-                    alt14 = 12
+                if (LA13_0 == 34) :
+                    alt13 = 1
+                elif (LA13_0 == 35) :
+                    alt13 = 2
+                elif (LA13_0 == 36) :
+                    alt13 = 3
+                elif (LA13_0 == 37) :
+                    alt13 = 4
+                elif (LA13_0 == 38) :
+                    alt13 = 5
+                elif (LA13_0 == 39) :
+                    alt13 = 6
+                elif (LA13_0 == 40) :
+                    alt13 = 7
+                elif (LA13_0 == 41) :
+                    alt13 = 8
+                elif (LA13_0 == 42) :
+                    alt13 = 9
+                elif (LA13_0 == 43) :
+                    alt13 = 10
+                elif ((46 <= LA13_0 <= 47)) :
+                    alt13 = 11
+                elif (LA13_0 == 49) :
+                    alt13 = 12
+                elif (LA13_0 == IDENTIFIER) and (self.synpred34()):
+                    alt13 = 13
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER declarator )=> type_id );", 14, 0, self.input)
+                    nvae = NoViableAltException("153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | 'BOOLEAN' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER declarator )=> type_id );", 13, 0, self.input)
 
                     raise nvae
 
-                if alt14 == 1:
+                if alt13 == 1:
                     # C.g:154:4: 'void'
-                    self.match(self.input, 34, self.FOLLOW_34_in_type_specifier369)
+                    self.match(self.input, 34, self.FOLLOW_34_in_type_specifier366)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 2:
+                elif alt13 == 2:
                     # C.g:155:4: 'char'
-                    self.match(self.input, 35, self.FOLLOW_35_in_type_specifier374)
+                    self.match(self.input, 35, self.FOLLOW_35_in_type_specifier371)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 3:
+                elif alt13 == 3:
                     # C.g:156:4: 'short'
-                    self.match(self.input, 36, self.FOLLOW_36_in_type_specifier379)
+                    self.match(self.input, 36, self.FOLLOW_36_in_type_specifier376)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 4:
+                elif alt13 == 4:
                     # C.g:157:4: 'int'
-                    self.match(self.input, 37, self.FOLLOW_37_in_type_specifier384)
+                    self.match(self.input, 37, self.FOLLOW_37_in_type_specifier381)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 5:
+                elif alt13 == 5:
                     # C.g:158:4: 'long'
-                    self.match(self.input, 38, self.FOLLOW_38_in_type_specifier389)
+                    self.match(self.input, 38, self.FOLLOW_38_in_type_specifier386)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 6:
+                elif alt13 == 6:
                     # C.g:159:4: 'float'
-                    self.match(self.input, 39, self.FOLLOW_39_in_type_specifier394)
+                    self.match(self.input, 39, self.FOLLOW_39_in_type_specifier391)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 7:
+                elif alt13 == 7:
                     # C.g:160:4: 'double'
-                    self.match(self.input, 40, self.FOLLOW_40_in_type_specifier399)
+                    self.match(self.input, 40, self.FOLLOW_40_in_type_specifier396)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 8:
+                elif alt13 == 8:
                     # C.g:161:4: 'signed'
-                    self.match(self.input, 41, self.FOLLOW_41_in_type_specifier404)
+                    self.match(self.input, 41, self.FOLLOW_41_in_type_specifier401)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 9:
+                elif alt13 == 9:
                     # C.g:162:4: 'unsigned'
-                    self.match(self.input, 42, self.FOLLOW_42_in_type_specifier409)
+                    self.match(self.input, 42, self.FOLLOW_42_in_type_specifier406)
+                    if self.failed:
+                        return 
+
+
+                elif alt13 == 10:
+                    # C.g:163:4: 'BOOLEAN'
+                    self.match(self.input, 43, self.FOLLOW_43_in_type_specifier411)
                     if self.failed:
                         return 
 
 
-                elif alt14 == 10:
-                    # C.g:163:4: s= struct_or_union_specifier
-                    self.following.append(self.FOLLOW_struct_or_union_specifier_in_type_specifier416)
+                elif alt13 == 11:
+                    # C.g:164:4: s= struct_or_union_specifier
+                    self.following.append(self.FOLLOW_struct_or_union_specifier_in_type_specifier418)
                     s = self.struct_or_union_specifier()
                     self.following.pop()
                     if self.failed:
@@ -1299,9 +1317,9 @@ class CParser(Parser):
 
 
 
-                elif alt14 == 11:
-                    # C.g:164:4: e= enum_specifier
-                    self.following.append(self.FOLLOW_enum_specifier_in_type_specifier425)
+                elif alt13 == 12:
+                    # C.g:165:4: e= enum_specifier
+                    self.following.append(self.FOLLOW_enum_specifier_in_type_specifier427)
                     e = self.enum_specifier()
                     self.following.pop()
                     if self.failed:
@@ -1311,9 +1329,9 @@ class CParser(Parser):
 
 
 
-                elif alt14 == 12:
-                    # C.g:165:4: ( IDENTIFIER declarator )=> type_id
-                    self.following.append(self.FOLLOW_type_id_in_type_specifier439)
+                elif alt13 == 13:
+                    # C.g:166:4: ( IDENTIFIER declarator )=> type_id
+                    self.following.append(self.FOLLOW_type_id_in_type_specifier441)
                     self.type_id()
                     self.following.pop()
                     if self.failed:
@@ -1336,7 +1354,7 @@ class CParser(Parser):
 
 
     # $ANTLR start type_id
-    # C.g:168:1: type_id : IDENTIFIER ;
+    # C.g:169:1: type_id : IDENTIFIER ;
     def type_id(self, ):
 
         type_id_StartIndex = self.input.index()
@@ -1345,9 +1363,9 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 10):
                     return 
 
-                # C.g:169:5: ( IDENTIFIER )
-                # C.g:169:9: IDENTIFIER
-                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_type_id455)
+                # C.g:170:5: ( IDENTIFIER )
+                # C.g:170:9: IDENTIFIER
+                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_type_id457)
                 if self.failed:
                     return 
 
@@ -1375,7 +1393,7 @@ class CParser(Parser):
 
 
     # $ANTLR start struct_or_union_specifier
-    # C.g:173:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );
+    # C.g:174:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );
     def struct_or_union_specifier(self, ):
 
         retval = self.struct_or_union_specifier_return()
@@ -1386,37 +1404,37 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 11):
                     return retval
 
-                # C.g:175:2: ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER )
-                alt16 = 2
-                LA16_0 = self.input.LA(1)
+                # C.g:176:2: ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER )
+                alt15 = 2
+                LA15_0 = self.input.LA(1)
 
-                if ((45 <= LA16_0 <= 46)) :
-                    LA16_1 = self.input.LA(2)
+                if ((46 <= LA15_0 <= 47)) :
+                    LA15_1 = self.input.LA(2)
 
-                    if (LA16_1 == IDENTIFIER) :
-                        LA16_2 = self.input.LA(3)
+                    if (LA15_1 == IDENTIFIER) :
+                        LA15_2 = self.input.LA(3)
 
-                        if (LA16_2 == 43) :
-                            alt16 = 1
-                        elif (LA16_2 == EOF or LA16_2 == IDENTIFIER or LA16_2 == 25 or (29 <= LA16_2 <= 42) or (45 <= LA16_2 <= 57) or LA16_2 == 59) :
-                            alt16 = 2
+                        if (LA15_2 == 44) :
+                            alt15 = 1
+                        elif (LA15_2 == EOF or LA15_2 == IDENTIFIER or LA15_2 == 25 or LA15_2 == 27 or (29 <= LA15_2 <= 43) or (46 <= LA15_2 <= 59) or LA15_2 == 61) :
+                            alt15 = 2
                         else:
                             if self.backtracking > 0:
                                 self.failed = True
                                 return retval
 
-                            nvae = NoViableAltException("173:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 16, 2, self.input)
+                            nvae = NoViableAltException("174:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 2, self.input)
 
                             raise nvae
 
-                    elif (LA16_1 == 43) :
-                        alt16 = 1
+                    elif (LA15_1 == 44) :
+                        alt15 = 1
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return retval
 
-                        nvae = NoViableAltException("173:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 16, 1, self.input)
+                        nvae = NoViableAltException("174:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 1, self.input)
 
                         raise nvae
 
@@ -1425,52 +1443,52 @@ class CParser(Parser):
                         self.failed = True
                         return retval
 
-                    nvae = NoViableAltException("173:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 16, 0, self.input)
+                    nvae = NoViableAltException("174:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 0, self.input)
 
                     raise nvae
 
-                if alt16 == 1:
-                    # C.g:175:4: struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}'
-                    self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier482)
+                if alt15 == 1:
+                    # C.g:176:4: struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}'
+                    self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier484)
                     self.struct_or_union()
                     self.following.pop()
                     if self.failed:
                         return retval
-                    # C.g:175:20: ( IDENTIFIER )?
-                    alt15 = 2
-                    LA15_0 = self.input.LA(1)
+                    # C.g:176:20: ( IDENTIFIER )?
+                    alt14 = 2
+                    LA14_0 = self.input.LA(1)
 
-                    if (LA15_0 == IDENTIFIER) :
-                        alt15 = 1
-                    if alt15 == 1:
+                    if (LA14_0 == IDENTIFIER) :
+                        alt14 = 1
+                    if alt14 == 1:
                         # C.g:0:0: IDENTIFIER
-                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier484)
+                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier486)
                         if self.failed:
                             return retval
 
 
 
-                    self.match(self.input, 43, self.FOLLOW_43_in_struct_or_union_specifier487)
+                    self.match(self.input, 44, self.FOLLOW_44_in_struct_or_union_specifier489)
                     if self.failed:
                         return retval
-                    self.following.append(self.FOLLOW_struct_declaration_list_in_struct_or_union_specifier489)
+                    self.following.append(self.FOLLOW_struct_declaration_list_in_struct_or_union_specifier491)
                     self.struct_declaration_list()
                     self.following.pop()
                     if self.failed:
                         return retval
-                    self.match(self.input, 44, self.FOLLOW_44_in_struct_or_union_specifier491)
+                    self.match(self.input, 45, self.FOLLOW_45_in_struct_or_union_specifier493)
                     if self.failed:
                         return retval
 
 
-                elif alt16 == 2:
-                    # C.g:176:4: struct_or_union IDENTIFIER
-                    self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier496)
+                elif alt15 == 2:
+                    # C.g:177:4: struct_or_union IDENTIFIER
+                    self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier498)
                     self.struct_or_union()
                     self.following.pop()
                     if self.failed:
                         return retval
-                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier498)
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier500)
                     if self.failed:
                         return retval
 
@@ -1493,7 +1511,7 @@ class CParser(Parser):
 
 
     # $ANTLR start struct_or_union
-    # C.g:179:1: struct_or_union : ( 'struct' | 'union' );
+    # C.g:180:1: struct_or_union : ( 'struct' | 'union' );
     def struct_or_union(self, ):
 
         struct_or_union_StartIndex = self.input.index()
@@ -1502,9 +1520,9 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 12):
                     return 
 
-                # C.g:180:2: ( 'struct' | 'union' )
+                # C.g:181:2: ( 'struct' | 'union' )
                 # C.g:
-                if (45 <= self.input.LA(1) <= 46):
+                if (46 <= self.input.LA(1) <= 47):
                     self.input.consume();
                     self.errorRecovery = False
                     self.failed = False
@@ -1540,7 +1558,7 @@ class CParser(Parser):
 
 
     # $ANTLR start struct_declaration_list
-    # C.g:184:1: struct_declaration_list : ( struct_declaration )+ ;
+    # C.g:185:1: struct_declaration_list : ( struct_declaration )+ ;
     def struct_declaration_list(self, ):
 
         struct_declaration_list_StartIndex = self.input.index()
@@ -1549,21 +1567,21 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 13):
                     return 
 
-                # C.g:185:2: ( ( struct_declaration )+ )
-                # C.g:185:4: ( struct_declaration )+
-                # C.g:185:4: ( struct_declaration )+
-                cnt17 = 0
-                while True: #loop17
-                    alt17 = 2
-                    LA17_0 = self.input.LA(1)
+                # C.g:186:2: ( ( struct_declaration )+ )
+                # C.g:186:4: ( struct_declaration )+
+                # C.g:186:4: ( struct_declaration )+
+                cnt16 = 0
+                while True: #loop16
+                    alt16 = 2
+                    LA16_0 = self.input.LA(1)
 
-                    if (LA17_0 == IDENTIFIER or (34 <= LA17_0 <= 42) or (45 <= LA17_0 <= 46) or (48 <= LA17_0 <= 53)) :
-                        alt17 = 1
+                    if (LA16_0 == IDENTIFIER or (34 <= LA16_0 <= 43) or (46 <= LA16_0 <= 47) or (49 <= LA16_0 <= 55)) :
+                        alt16 = 1
 
 
-                    if alt17 == 1:
+                    if alt16 == 1:
                         # C.g:0:0: struct_declaration
-                        self.following.append(self.FOLLOW_struct_declaration_in_struct_declaration_list525)
+                        self.following.append(self.FOLLOW_struct_declaration_in_struct_declaration_list527)
                         self.struct_declaration()
                         self.following.pop()
                         if self.failed:
@@ -1571,17 +1589,17 @@ class CParser(Parser):
 
 
                     else:
-                        if cnt17 >= 1:
-                            break #loop17
+                        if cnt16 >= 1:
+                            break #loop16
 
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        eee = EarlyExitException(17, self.input)
+                        eee = EarlyExitException(16, self.input)
                         raise eee
 
-                    cnt17 += 1
+                    cnt16 += 1
 
 
 
@@ -1603,7 +1621,7 @@ class CParser(Parser):
 
 
     # $ANTLR start struct_declaration
-    # C.g:188:1: struct_declaration : specifier_qualifier_list struct_declarator_list ';' ;
+    # C.g:189:1: struct_declaration : specifier_qualifier_list struct_declarator_list ';' ;
     def struct_declaration(self, ):
 
         struct_declaration_StartIndex = self.input.index()
@@ -1612,19 +1630,19 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 14):
                     return 
 
-                # C.g:189:2: ( specifier_qualifier_list struct_declarator_list ';' )
-                # C.g:189:4: specifier_qualifier_list struct_declarator_list ';'
-                self.following.append(self.FOLLOW_specifier_qualifier_list_in_struct_declaration537)
+                # C.g:190:2: ( specifier_qualifier_list struct_declarator_list ';' )
+                # C.g:190:4: specifier_qualifier_list struct_declarator_list ';'
+                self.following.append(self.FOLLOW_specifier_qualifier_list_in_struct_declaration539)
                 self.specifier_qualifier_list()
                 self.following.pop()
                 if self.failed:
                     return 
-                self.following.append(self.FOLLOW_struct_declarator_list_in_struct_declaration539)
+                self.following.append(self.FOLLOW_struct_declarator_list_in_struct_declaration541)
                 self.struct_declarator_list()
                 self.following.pop()
                 if self.failed:
                     return 
-                self.match(self.input, 25, self.FOLLOW_25_in_struct_declaration541)
+                self.match(self.input, 25, self.FOLLOW_25_in_struct_declaration543)
                 if self.failed:
                     return 
 
@@ -1646,7 +1664,7 @@ class CParser(Parser):
 
 
     # $ANTLR start specifier_qualifier_list
-    # C.g:192:1: specifier_qualifier_list : ( type_qualifier | type_specifier )+ ;
+    # C.g:193:1: specifier_qualifier_list : ( type_qualifier | type_specifier )+ ;
     def specifier_qualifier_list(self, ):
 
         specifier_qualifier_list_StartIndex = self.input.index()
@@ -1655,56 +1673,56 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 15):
                     return 
 
-                # C.g:193:2: ( ( type_qualifier | type_specifier )+ )
-                # C.g:193:4: ( type_qualifier | type_specifier )+
-                # C.g:193:4: ( type_qualifier | type_specifier )+
-                cnt18 = 0
-                while True: #loop18
-                    alt18 = 3
-                    LA18 = self.input.LA(1)
-                    if LA18 == IDENTIFIER:
-                        LA18 = self.input.LA(2)
-                        if LA18 == EOF or LA18 == IDENTIFIER or LA18 == 34 or LA18 == 35 or LA18 == 36 or LA18 == 37 or LA18 == 38 or LA18 == 39 or LA18 == 40 or LA18 == 41 or LA18 == 42 or LA18 == 45 or LA18 == 46 or LA18 == 48 or LA18 == 49 or LA18 == 50 or LA18 == 51 or LA18 == 52 or LA18 == 53 or LA18 == 54 or LA18 == 56 or LA18 == 59:
-                            alt18 = 2
-                        elif LA18 == 55:
-                            LA18_24 = self.input.LA(3)
+                # C.g:194:2: ( ( type_qualifier | type_specifier )+ )
+                # C.g:194:4: ( type_qualifier | type_specifier )+
+                # C.g:194:4: ( type_qualifier | type_specifier )+
+                cnt17 = 0
+                while True: #loop17
+                    alt17 = 3
+                    LA17 = self.input.LA(1)
+                    if LA17 == IDENTIFIER:
+                        LA17 = self.input.LA(2)
+                        if LA17 == 59:
+                            LA17_22 = self.input.LA(3)
 
                             if (self.synpred40()) :
-                                alt18 = 2
+                                alt17 = 2
 
 
-                        elif LA18 == 47:
-                            LA18_25 = self.input.LA(3)
+                        elif LA17 == 57:
+                            LA17_23 = self.input.LA(3)
 
                             if (self.synpred40()) :
-                                alt18 = 2
+                                alt17 = 2
 
 
-                        elif LA18 == 57:
-                            LA18_26 = self.input.LA(3)
+                        elif LA17 == 48:
+                            LA17_24 = self.input.LA(3)
 
                             if (self.synpred40()) :
-                                alt18 = 2
+                                alt17 = 2
 
 
+                        elif LA17 == EOF or LA17 == IDENTIFIER or LA17 == 34 or LA17 == 35 or LA17 == 36 or LA17 == 37 or LA17 == 38 or LA17 == 39 or LA17 == 40 or LA17 == 41 or LA17 == 42 or LA17 == 43 or LA17 == 46 or LA17 == 47 or LA17 == 49 or LA17 == 50 or LA17 == 51 or LA17 == 52 or LA17 == 53 or LA17 == 54 or LA17 == 55 or LA17 == 56 or LA17 == 58 or LA17 == 61:
+                            alt17 = 2
 
-                    elif LA18 == 49 or LA18 == 50 or LA18 == 51 or LA18 == 52 or LA18 == 53:
-                        alt18 = 1
-                    elif LA18 == 34 or LA18 == 35 or LA18 == 36 or LA18 == 37 or LA18 == 38 or LA18 == 39 or LA18 == 40 or LA18 == 41 or LA18 == 42 or LA18 == 45 or LA18 == 46 or LA18 == 48:
-                        alt18 = 2
+                    elif LA17 == 50 or LA17 == 51 or LA17 == 52 or LA17 == 53 or LA17 == 54 or LA17 == 55:
+                        alt17 = 1
+                    elif LA17 == 34 or LA17 == 35 or LA17 == 36 or LA17 == 37 or LA17 == 38 or LA17 == 39 or LA17 == 40 or LA17 == 41 or LA17 == 42 or LA17 == 43 or LA17 == 46 or LA17 == 47 or LA17 == 49:
+                        alt17 = 2
 
-                    if alt18 == 1:
-                        # C.g:193:6: type_qualifier
-                        self.following.append(self.FOLLOW_type_qualifier_in_specifier_qualifier_list554)
+                    if alt17 == 1:
+                        # C.g:194:6: type_qualifier
+                        self.following.append(self.FOLLOW_type_qualifier_in_specifier_qualifier_list556)
                         self.type_qualifier()
                         self.following.pop()
                         if self.failed:
                             return 
 
 
-                    elif alt18 == 2:
-                        # C.g:193:23: type_specifier
-                        self.following.append(self.FOLLOW_type_specifier_in_specifier_qualifier_list558)
+                    elif alt17 == 2:
+                        # C.g:194:23: type_specifier
+                        self.following.append(self.FOLLOW_type_specifier_in_specifier_qualifier_list560)
                         self.type_specifier()
                         self.following.pop()
                         if self.failed:
@@ -1712,17 +1730,17 @@ class CParser(Parser):
 
 
                     else:
-                        if cnt18 >= 1:
-                            break #loop18
+                        if cnt17 >= 1:
+                            break #loop17
 
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        eee = EarlyExitException(18, self.input)
+                        eee = EarlyExitException(17, self.input)
                         raise eee
 
-                    cnt18 += 1
+                    cnt17 += 1
 
 
 
@@ -1744,7 +1762,7 @@ class CParser(Parser):
 
 
     # $ANTLR start struct_declarator_list
-    # C.g:196:1: struct_declarator_list : struct_declarator ( ',' struct_declarator )* ;
+    # C.g:197:1: struct_declarator_list : struct_declarator ( ',' struct_declarator )* ;
     def struct_declarator_list(self, ):
 
         struct_declarator_list_StartIndex = self.input.index()
@@ -1753,28 +1771,28 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 16):
                     return 
 
-                # C.g:197:2: ( struct_declarator ( ',' struct_declarator )* )
-                # C.g:197:4: struct_declarator ( ',' struct_declarator )*
-                self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list572)
+                # C.g:198:2: ( struct_declarator ( ',' struct_declarator )* )
+                # C.g:198:4: struct_declarator ( ',' struct_declarator )*
+                self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list574)
                 self.struct_declarator()
                 self.following.pop()
                 if self.failed:
                     return 
-                # C.g:197:22: ( ',' struct_declarator )*
-                while True: #loop19
-                    alt19 = 2
-                    LA19_0 = self.input.LA(1)
+                # C.g:198:22: ( ',' struct_declarator )*
+                while True: #loop18
+                    alt18 = 2
+                    LA18_0 = self.input.LA(1)
 
-                    if (LA19_0 == 27) :
-                        alt19 = 1
+                    if (LA18_0 == 27) :
+                        alt18 = 1
 
 
-                    if alt19 == 1:
-                        # C.g:197:23: ',' struct_declarator
-                        self.match(self.input, 27, self.FOLLOW_27_in_struct_declarator_list575)
+                    if alt18 == 1:
+                        # C.g:198:23: ',' struct_declarator
+                        self.match(self.input, 27, self.FOLLOW_27_in_struct_declarator_list577)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list577)
+                        self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list579)
                         self.struct_declarator()
                         self.following.pop()
                         if self.failed:
@@ -1782,7 +1800,7 @@ class CParser(Parser):
 
 
                     else:
-                        break #loop19
+                        break #loop18
 
 
 
@@ -1804,7 +1822,7 @@ class CParser(Parser):
 
 
     # $ANTLR start struct_declarator
-    # C.g:200:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression );
+    # C.g:201:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression );
     def struct_declarator(self, ):
 
         struct_declarator_StartIndex = self.input.index()
@@ -1813,42 +1831,42 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 17):
                     return 
 
-                # C.g:201:2: ( declarator ( ':' constant_expression )? | ':' constant_expression )
-                alt21 = 2
-                LA21_0 = self.input.LA(1)
+                # C.g:202:2: ( declarator ( ':' constant_expression )? | ':' constant_expression )
+                alt20 = 2
+                LA20_0 = self.input.LA(1)
 
-                if (LA21_0 == IDENTIFIER or (54 <= LA21_0 <= 55) or LA21_0 == 59) :
-                    alt21 = 1
-                elif (LA21_0 == 47) :
-                    alt21 = 2
+                if (LA20_0 == IDENTIFIER or (56 <= LA20_0 <= 57) or LA20_0 == 61) :
+                    alt20 = 1
+                elif (LA20_0 == 48) :
+                    alt20 = 2
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("200:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression );", 21, 0, self.input)
+                    nvae = NoViableAltException("201:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression );", 20, 0, self.input)
 
                     raise nvae
 
-                if alt21 == 1:
-                    # C.g:201:4: declarator ( ':' constant_expression )?
-                    self.following.append(self.FOLLOW_declarator_in_struct_declarator590)
+                if alt20 == 1:
+                    # C.g:202:4: declarator ( ':' constant_expression )?
+                    self.following.append(self.FOLLOW_declarator_in_struct_declarator592)
                     self.declarator()
                     self.following.pop()
                     if self.failed:
                         return 
-                    # C.g:201:15: ( ':' constant_expression )?
-                    alt20 = 2
-                    LA20_0 = self.input.LA(1)
+                    # C.g:202:15: ( ':' constant_expression )?
+                    alt19 = 2
+                    LA19_0 = self.input.LA(1)
 
-                    if (LA20_0 == 47) :
-                        alt20 = 1
-                    if alt20 == 1:
-                        # C.g:201:16: ':' constant_expression
-                        self.match(self.input, 47, self.FOLLOW_47_in_struct_declarator593)
+                    if (LA19_0 == 48) :
+                        alt19 = 1
+                    if alt19 == 1:
+                        # C.g:202:16: ':' constant_expression
+                        self.match(self.input, 48, self.FOLLOW_48_in_struct_declarator595)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_constant_expression_in_struct_declarator595)
+                        self.following.append(self.FOLLOW_constant_expression_in_struct_declarator597)
                         self.constant_expression()
                         self.following.pop()
                         if self.failed:
@@ -1858,12 +1876,12 @@ class CParser(Parser):
 
 
 
-                elif alt21 == 2:
-                    # C.g:202:4: ':' constant_expression
-                    self.match(self.input, 47, self.FOLLOW_47_in_struct_declarator602)
+                elif alt20 == 2:
+                    # C.g:203:4: ':' constant_expression
+                    self.match(self.input, 48, self.FOLLOW_48_in_struct_declarator604)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_constant_expression_in_struct_declarator604)
+                    self.following.append(self.FOLLOW_constant_expression_in_struct_declarator606)
                     self.constant_expression()
                     self.following.pop()
                     if self.failed:
@@ -1892,7 +1910,7 @@ class CParser(Parser):
 
 
     # $ANTLR start enum_specifier
-    # C.g:205:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );
+    # C.g:206:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );
     def enum_specifier(self, ):
 
         retval = self.enum_specifier_return()
@@ -1903,37 +1921,37 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 18):
                     return retval
 
-                # C.g:207:2: ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER )
-                alt22 = 3
-                LA22_0 = self.input.LA(1)
+                # C.g:208:2: ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER )
+                alt21 = 3
+                LA21_0 = self.input.LA(1)
 
-                if (LA22_0 == 48) :
-                    LA22_1 = self.input.LA(2)
+                if (LA21_0 == 49) :
+                    LA21_1 = self.input.LA(2)
 
-                    if (LA22_1 == IDENTIFIER) :
-                        LA22_2 = self.input.LA(3)
+                    if (LA21_1 == IDENTIFIER) :
+                        LA21_2 = self.input.LA(3)
 
-                        if (LA22_2 == 43) :
-                            alt22 = 2
-                        elif (LA22_2 == EOF or LA22_2 == IDENTIFIER or LA22_2 == 25 or (29 <= LA22_2 <= 42) or (45 <= LA22_2 <= 57) or LA22_2 == 59) :
-                            alt22 = 3
+                        if (LA21_2 == 44) :
+                            alt21 = 2
+                        elif (LA21_2 == EOF or LA21_2 == IDENTIFIER or LA21_2 == 25 or LA21_2 == 27 or (29 <= LA21_2 <= 43) or (46 <= LA21_2 <= 59) or LA21_2 == 61) :
+                            alt21 = 3
                         else:
                             if self.backtracking > 0:
                                 self.failed = True
                                 return retval
 
-                            nvae = NoViableAltException("205:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );", 22, 2, self.input)
+                            nvae = NoViableAltException("206:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );", 21, 2, self.input)
 
                             raise nvae
 
-                    elif (LA22_1 == 43) :
-                        alt22 = 1
+                    elif (LA21_1 == 44) :
+                        alt21 = 1
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return retval
 
-                        nvae = NoViableAltException("205:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );", 22, 1, self.input)
+                        nvae = NoViableAltException("206:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );", 21, 1, self.input)
 
                         raise nvae
 
@@ -1942,55 +1960,55 @@ class CParser(Parser):
                         self.failed = True
                         return retval
 
-                    nvae = NoViableAltException("205:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );", 22, 0, self.input)
+                    nvae = NoViableAltException("206:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list '}' | 'enum' IDENTIFIER '{' enumerator_list '}' | 'enum' IDENTIFIER );", 21, 0, self.input)
 
                     raise nvae
 
-                if alt22 == 1:
-                    # C.g:207:4: 'enum' '{' enumerator_list '}'
-                    self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier622)
+                if alt21 == 1:
+                    # C.g:208:4: 'enum' '{' enumerator_list '}'
+                    self.match(self.input, 49, self.FOLLOW_49_in_enum_specifier624)
                     if self.failed:
                         return retval
-                    self.match(self.input, 43, self.FOLLOW_43_in_enum_specifier624)
+                    self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier626)
                     if self.failed:
                         return retval
-                    self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier626)
+                    self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier628)
                     self.enumerator_list()
                     self.following.pop()
                     if self.failed:
                         return retval
-                    self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier628)
+                    self.match(self.input, 45, self.FOLLOW_45_in_enum_specifier630)
                     if self.failed:
                         return retval
 
 
-                elif alt22 == 2:
-                    # C.g:208:4: 'enum' IDENTIFIER '{' enumerator_list '}'
-                    self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier633)
+                elif alt21 == 2:
+                    # C.g:209:4: 'enum' IDENTIFIER '{' enumerator_list '}'
+                    self.match(self.input, 49, self.FOLLOW_49_in_enum_specifier635)
                     if self.failed:
                         return retval
-                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier635)
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier637)
                     if self.failed:
                         return retval
-                    self.match(self.input, 43, self.FOLLOW_43_in_enum_specifier637)
+                    self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier639)
                     if self.failed:
                         return retval
-                    self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier639)
+                    self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier641)
                     self.enumerator_list()
                     self.following.pop()
                     if self.failed:
                         return retval
-                    self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier641)
+                    self.match(self.input, 45, self.FOLLOW_45_in_enum_specifier643)
                     if self.failed:
                         return retval
 
 
-                elif alt22 == 3:
-                    # C.g:209:4: 'enum' IDENTIFIER
-                    self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier646)
+                elif alt21 == 3:
+                    # C.g:210:4: 'enum' IDENTIFIER
+                    self.match(self.input, 49, self.FOLLOW_49_in_enum_specifier648)
                     if self.failed:
                         return retval
-                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier648)
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier650)
                     if self.failed:
                         return retval
 
@@ -2013,7 +2031,7 @@ class CParser(Parser):
 
 
     # $ANTLR start enumerator_list
-    # C.g:212:1: enumerator_list : enumerator ( ',' enumerator )* ;
+    # C.g:213:1: enumerator_list : enumerator ( ',' enumerator )* ;
     def enumerator_list(self, ):
 
         enumerator_list_StartIndex = self.input.index()
@@ -2022,28 +2040,28 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 19):
                     return 
 
-                # C.g:213:2: ( enumerator ( ',' enumerator )* )
-                # C.g:213:4: enumerator ( ',' enumerator )*
-                self.following.append(self.FOLLOW_enumerator_in_enumerator_list659)
+                # C.g:214:2: ( enumerator ( ',' enumerator )* )
+                # C.g:214:4: enumerator ( ',' enumerator )*
+                self.following.append(self.FOLLOW_enumerator_in_enumerator_list661)
                 self.enumerator()
                 self.following.pop()
                 if self.failed:
                     return 
-                # C.g:213:15: ( ',' enumerator )*
-                while True: #loop23
-                    alt23 = 2
-                    LA23_0 = self.input.LA(1)
+                # C.g:214:15: ( ',' enumerator )*
+                while True: #loop22
+                    alt22 = 2
+                    LA22_0 = self.input.LA(1)
 
-                    if (LA23_0 == 27) :
-                        alt23 = 1
+                    if (LA22_0 == 27) :
+                        alt22 = 1
 
 
-                    if alt23 == 1:
-                        # C.g:213:16: ',' enumerator
-                        self.match(self.input, 27, self.FOLLOW_27_in_enumerator_list662)
+                    if alt22 == 1:
+                        # C.g:214:16: ',' enumerator
+                        self.match(self.input, 27, self.FOLLOW_27_in_enumerator_list664)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_enumerator_in_enumerator_list664)
+                        self.following.append(self.FOLLOW_enumerator_in_enumerator_list666)
                         self.enumerator()
                         self.following.pop()
                         if self.failed:
@@ -2051,7 +2069,7 @@ class CParser(Parser):
 
 
                     else:
-                        break #loop23
+                        break #loop22
 
 
 
@@ -2073,7 +2091,7 @@ class CParser(Parser):
 
 
     # $ANTLR start enumerator
-    # C.g:216:1: enumerator : IDENTIFIER ( '=' constant_expression )? ;
+    # C.g:217:1: enumerator : IDENTIFIER ( '=' constant_expression )? ;
     def enumerator(self, ):
 
         enumerator_StartIndex = self.input.index()
@@ -2082,23 +2100,23 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 20):
                     return 
 
-                # C.g:217:2: ( IDENTIFIER ( '=' constant_expression )? )
-                # C.g:217:4: IDENTIFIER ( '=' constant_expression )?
-                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enumerator677)
+                # C.g:218:2: ( IDENTIFIER ( '=' constant_expression )? )
+                # C.g:218:4: IDENTIFIER ( '=' constant_expression )?
+                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enumerator679)
                 if self.failed:
                     return 
-                # C.g:217:15: ( '=' constant_expression )?
-                alt24 = 2
-                LA24_0 = self.input.LA(1)
+                # C.g:218:15: ( '=' constant_expression )?
+                alt23 = 2
+                LA23_0 = self.input.LA(1)
 
-                if (LA24_0 == 28) :
-                    alt24 = 1
-                if alt24 == 1:
-                    # C.g:217:16: '=' constant_expression
-                    self.match(self.input, 28, self.FOLLOW_28_in_enumerator680)
+                if (LA23_0 == 28) :
+                    alt23 = 1
+                if alt23 == 1:
+                    # C.g:218:16: '=' constant_expression
+                    self.match(self.input, 28, self.FOLLOW_28_in_enumerator682)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_constant_expression_in_enumerator682)
+                    self.following.append(self.FOLLOW_constant_expression_in_enumerator684)
                     self.constant_expression()
                     self.following.pop()
                     if self.failed:
@@ -2125,7 +2143,7 @@ class CParser(Parser):
 
 
     # $ANTLR start type_qualifier
-    # C.g:220:1: type_qualifier : ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' );
+    # C.g:221:1: type_qualifier : ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' | 'CONST' );
     def type_qualifier(self, ):
 
         type_qualifier_StartIndex = self.input.index()
@@ -2134,9 +2152,9 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 21):
                     return 
 
-                # C.g:221:2: ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' )
+                # C.g:222:2: ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' | 'CONST' )
                 # C.g:
-                if (49 <= self.input.LA(1) <= 53):
+                if (50 <= self.input.LA(1) <= 55):
                     self.input.consume();
                     self.errorRecovery = False
                     self.failed = False
@@ -2178,7 +2196,7 @@ class CParser(Parser):
 
 
     # $ANTLR start declarator
-    # C.g:228:1: declarator : ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer );
+    # C.g:230:1: declarator : ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer );
     def declarator(self, ):
 
         retval = self.declarator_return()
@@ -2189,25 +2207,25 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 22):
                     return retval
 
-                # C.g:229:2: ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer )
-                alt27 = 2
-                LA27_0 = self.input.LA(1)
+                # C.g:231:2: ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer )
+                alt26 = 2
+                LA26_0 = self.input.LA(1)
 
-                if (LA27_0 == IDENTIFIER or (54 <= LA27_0 <= 55)) :
-                    alt27 = 1
-                elif (LA27_0 == 59) :
-                    LA27_2 = self.input.LA(2)
+                if (LA26_0 == IDENTIFIER or (56 <= LA26_0 <= 57)) :
+                    alt26 = 1
+                elif (LA26_0 == 61) :
+                    LA26_2 = self.input.LA(2)
 
-                    if (self.synpred54()) :
-                        alt27 = 1
+                    if (self.synpred55()) :
+                        alt26 = 1
                     elif (True) :
-                        alt27 = 2
+                        alt26 = 2
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return retval
 
-                        nvae = NoViableAltException("228:1: declarator : ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer );", 27, 2, self.input)
+                        nvae = NoViableAltException("230:1: declarator : ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer );", 26, 2, self.input)
 
                         raise nvae
 
@@ -2216,35 +2234,35 @@ class CParser(Parser):
                         self.failed = True
                         return retval
 
-                    nvae = NoViableAltException("228:1: declarator : ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer );", 27, 0, self.input)
+                    nvae = NoViableAltException("230:1: declarator : ( ( 'EFIAPI' )? ( pointer )? direct_declarator | pointer );", 26, 0, self.input)
 
                     raise nvae
 
-                if alt27 == 1:
-                    # C.g:229:4: ( 'EFIAPI' )? ( pointer )? direct_declarator
-                    # C.g:229:4: ( 'EFIAPI' )?
-                    alt25 = 2
-                    LA25_0 = self.input.LA(1)
-
-                    if (LA25_0 == 54) :
-                        alt25 = 1
-                    if alt25 == 1:
-                        # C.g:229:5: 'EFIAPI'
-                        self.match(self.input, 54, self.FOLLOW_54_in_declarator727)
+                if alt26 == 1:
+                    # C.g:231:4: ( 'EFIAPI' )? ( pointer )? direct_declarator
+                    # C.g:231:4: ( 'EFIAPI' )?
+                    alt24 = 2
+                    LA24_0 = self.input.LA(1)
+
+                    if (LA24_0 == 56) :
+                        alt24 = 1
+                    if alt24 == 1:
+                        # C.g:231:5: 'EFIAPI'
+                        self.match(self.input, 56, self.FOLLOW_56_in_declarator734)
                         if self.failed:
                             return retval
 
 
 
-                    # C.g:229:16: ( pointer )?
-                    alt26 = 2
-                    LA26_0 = self.input.LA(1)
+                    # C.g:231:16: ( pointer )?
+                    alt25 = 2
+                    LA25_0 = self.input.LA(1)
 
-                    if (LA26_0 == 59) :
-                        alt26 = 1
-                    if alt26 == 1:
+                    if (LA25_0 == 61) :
+                        alt25 = 1
+                    if alt25 == 1:
                         # C.g:0:0: pointer
-                        self.following.append(self.FOLLOW_pointer_in_declarator731)
+                        self.following.append(self.FOLLOW_pointer_in_declarator738)
                         self.pointer()
                         self.following.pop()
                         if self.failed:
@@ -2252,16 +2270,16 @@ class CParser(Parser):
 
 
 
-                    self.following.append(self.FOLLOW_direct_declarator_in_declarator734)
+                    self.following.append(self.FOLLOW_direct_declarator_in_declarator741)
                     self.direct_declarator()
                     self.following.pop()
                     if self.failed:
                         return retval
 
 
-                elif alt27 == 2:
-                    # C.g:230:4: pointer
-                    self.following.append(self.FOLLOW_pointer_in_declarator739)
+                elif alt26 == 2:
+                    # C.g:232:4: pointer
+                    self.following.append(self.FOLLOW_pointer_in_declarator746)
                     self.pointer()
                     self.following.pop()
                     if self.failed:
@@ -2286,7 +2304,7 @@ class CParser(Parser):
 
 
     # $ANTLR start direct_declarator
-    # C.g:233:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' declarator ')' ( declarator_suffix )+ );
+    # C.g:235:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' declarator ')' ( declarator_suffix )+ );
     def direct_declarator(self, ):
 
         direct_declarator_StartIndex = self.input.index()
@@ -2295,240 +2313,247 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 23):
                     return 
 
-                # C.g:234:2: ( IDENTIFIER ( declarator_suffix )* | '(' declarator ')' ( declarator_suffix )+ )
-                alt30 = 2
-                LA30_0 = self.input.LA(1)
+                # C.g:236:2: ( IDENTIFIER ( declarator_suffix )* | '(' declarator ')' ( declarator_suffix )+ )
+                alt29 = 2
+                LA29_0 = self.input.LA(1)
 
-                if (LA30_0 == IDENTIFIER) :
-                    alt30 = 1
-                elif (LA30_0 == 55) :
-                    alt30 = 2
+                if (LA29_0 == IDENTIFIER) :
+                    alt29 = 1
+                elif (LA29_0 == 57) :
+                    alt29 = 2
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("233:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' declarator ')' ( declarator_suffix )+ );", 30, 0, self.input)
+                    nvae = NoViableAltException("235:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' declarator ')' ( declarator_suffix )+ );", 29, 0, self.input)
 
                     raise nvae
 
-                if alt30 == 1:
-                    # C.g:234:4: IDENTIFIER ( declarator_suffix )*
-                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_direct_declarator750)
+                if alt29 == 1:
+                    # C.g:236:4: IDENTIFIER ( declarator_suffix )*
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_direct_declarator757)
                     if self.failed:
                         return 
-                    # C.g:234:15: ( declarator_suffix )*
-                    while True: #loop28
-                        alt28 = 2
-                        LA28_0 = self.input.LA(1)
+                    # C.g:236:15: ( declarator_suffix )*
+                    while True: #loop27
+                        alt27 = 2
+                        LA27_0 = self.input.LA(1)
 
-                        if (LA28_0 == 55) :
-                            LA28 = self.input.LA(2)
-                            if LA28 == 56:
-                                LA28_28 = self.input.LA(3)
+                        if (LA27_0 == 57) :
+                            LA27 = self.input.LA(2)
+                            if LA27 == 58:
+                                LA27_29 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 29 or LA28 == 30 or LA28 == 31 or LA28 == 32 or LA28 == 33:
-                                LA28_32 = self.input.LA(3)
+                            elif LA27 == 29 or LA27 == 30 or LA27 == 31 or LA27 == 32 or LA27 == 33:
+                                LA27_33 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 34:
-                                LA28_33 = self.input.LA(3)
+                            elif LA27 == 34:
+                                LA27_34 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 35:
-                                LA28_34 = self.input.LA(3)
+                            elif LA27 == 35:
+                                LA27_35 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 36:
-                                LA28_35 = self.input.LA(3)
+                            elif LA27 == 36:
+                                LA27_36 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 37:
-                                LA28_36 = self.input.LA(3)
+                            elif LA27 == 37:
+                                LA27_37 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 38:
-                                LA28_37 = self.input.LA(3)
+                            elif LA27 == 38:
+                                LA27_38 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 39:
-                                LA28_38 = self.input.LA(3)
+                            elif LA27 == 39:
+                                LA27_39 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 40:
-                                LA28_39 = self.input.LA(3)
+                            elif LA27 == 40:
+                                LA27_40 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 41:
-                                LA28_40 = self.input.LA(3)
+                            elif LA27 == 41:
+                                LA27_41 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 42:
-                                LA28_41 = self.input.LA(3)
+                            elif LA27 == 42:
+                                LA27_42 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 45 or LA28 == 46:
-                                LA28_42 = self.input.LA(3)
+                            elif LA27 == 43:
+                                LA27_43 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 48:
-                                LA28_43 = self.input.LA(3)
+                            elif LA27 == 46 or LA27 == 47:
+                                LA27_44 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == IDENTIFIER:
-                                LA28_44 = self.input.LA(3)
+                            elif LA27 == 49:
+                                LA27_45 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 49 or LA28 == 50 or LA28 == 51 or LA28 == 52 or LA28 == 53:
-                                LA28_45 = self.input.LA(3)
+                            elif LA27 == IDENTIFIER:
+                                LA27_46 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
+                            elif LA27 == 50 or LA27 == 51 or LA27 == 52 or LA27 == 53 or LA27 == 54 or LA27 == 55:
+                                LA27_47 = self.input.LA(3)
 
-                        elif (LA28_0 == 57) :
-                            LA28 = self.input.LA(2)
-                            if LA28 == 58:
-                                LA28_47 = self.input.LA(3)
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
 
 
-                            elif LA28 == 55:
-                                LA28_48 = self.input.LA(3)
+                        elif (LA27_0 == 59) :
+                            LA27 = self.input.LA(2)
+                            if LA27 == 60:
+                                LA27_49 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == IDENTIFIER:
-                                LA28_49 = self.input.LA(3)
+                            elif LA27 == 57:
+                                LA27_50 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == HEX_LITERAL:
-                                LA28_50 = self.input.LA(3)
+                            elif LA27 == IDENTIFIER:
+                                LA27_51 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == OCTAL_LITERAL:
-                                LA28_51 = self.input.LA(3)
+                            elif LA27 == HEX_LITERAL:
+                                LA27_52 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == DECIMAL_LITERAL:
-                                LA28_52 = self.input.LA(3)
+                            elif LA27 == OCTAL_LITERAL:
+                                LA27_53 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == CHARACTER_LITERAL:
-                                LA28_53 = self.input.LA(3)
+                            elif LA27 == DECIMAL_LITERAL:
+                                LA27_54 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == STRING_LITERAL:
-                                LA28_54 = self.input.LA(3)
+                            elif LA27 == CHARACTER_LITERAL:
+                                LA27_55 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == FLOATING_POINT_LITERAL:
-                                LA28_55 = self.input.LA(3)
+                            elif LA27 == STRING_LITERAL:
+                                LA27_56 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 65:
-                                LA28_56 = self.input.LA(3)
+                            elif LA27 == FLOATING_POINT_LITERAL:
+                                LA27_57 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 66:
-                                LA28_57 = self.input.LA(3)
+                            elif LA27 == 67:
+                                LA27_58 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 59 or LA28 == 61 or LA28 == 62 or LA28 == 70 or LA28 == 71 or LA28 == 72:
-                                LA28_58 = self.input.LA(3)
+                            elif LA27 == 68:
+                                LA27_59 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                            elif LA28 == 67:
-                                LA28_59 = self.input.LA(3)
+                            elif LA27 == 61 or LA27 == 63 or LA27 == 64 or LA27 == 72 or LA27 == 73 or LA27 == 74:
+                                LA27_60 = self.input.LA(3)
 
-                                if (self.synpred55()) :
-                                    alt28 = 1
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
+                            elif LA27 == 69:
+                                LA27_61 = self.input.LA(3)
 
+                                if (self.synpred56()) :
+                                    alt27 = 1
 
 
-                        if alt28 == 1:
+
+
+
+                        if alt27 == 1:
                             # C.g:0:0: declarator_suffix
-                            self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator752)
+                            self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator759)
                             self.declarator_suffix()
                             self.following.pop()
                             if self.failed:
@@ -2536,237 +2561,244 @@ class CParser(Parser):
 
 
                         else:
-                            break #loop28
+                            break #loop27
 
 
 
 
-                elif alt30 == 2:
-                    # C.g:235:4: '(' declarator ')' ( declarator_suffix )+
-                    self.match(self.input, 55, self.FOLLOW_55_in_direct_declarator758)
+                elif alt29 == 2:
+                    # C.g:237:4: '(' declarator ')' ( declarator_suffix )+
+                    self.match(self.input, 57, self.FOLLOW_57_in_direct_declarator765)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_declarator_in_direct_declarator760)
+                    self.following.append(self.FOLLOW_declarator_in_direct_declarator767)
                     self.declarator()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_direct_declarator762)
+                    self.match(self.input, 58, self.FOLLOW_58_in_direct_declarator769)
                     if self.failed:
                         return 
-                    # C.g:235:23: ( declarator_suffix )+
-                    cnt29 = 0
-                    while True: #loop29
-                        alt29 = 2
-                        LA29_0 = self.input.LA(1)
+                    # C.g:237:23: ( declarator_suffix )+
+                    cnt28 = 0
+                    while True: #loop28
+                        alt28 = 2
+                        LA28_0 = self.input.LA(1)
 
-                        if (LA29_0 == 55) :
-                            LA29 = self.input.LA(2)
-                            if LA29 == 56:
-                                LA29_28 = self.input.LA(3)
+                        if (LA28_0 == 57) :
+                            LA28 = self.input.LA(2)
+                            if LA28 == 58:
+                                LA28_29 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 29 or LA29 == 30 or LA29 == 31 or LA29 == 32 or LA29 == 33:
-                                LA29_32 = self.input.LA(3)
+                            elif LA28 == 29 or LA28 == 30 or LA28 == 31 or LA28 == 32 or LA28 == 33:
+                                LA28_33 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 34:
-                                LA29_33 = self.input.LA(3)
+                            elif LA28 == 34:
+                                LA28_34 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 35:
-                                LA29_34 = self.input.LA(3)
+                            elif LA28 == 35:
+                                LA28_35 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 36:
-                                LA29_35 = self.input.LA(3)
+                            elif LA28 == 36:
+                                LA28_36 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 37:
-                                LA29_36 = self.input.LA(3)
+                            elif LA28 == 37:
+                                LA28_37 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 38:
-                                LA29_37 = self.input.LA(3)
+                            elif LA28 == 38:
+                                LA28_38 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 39:
-                                LA29_38 = self.input.LA(3)
+                            elif LA28 == 39:
+                                LA28_39 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 40:
-                                LA29_39 = self.input.LA(3)
+                            elif LA28 == 40:
+                                LA28_40 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 41:
-                                LA29_40 = self.input.LA(3)
+                            elif LA28 == 41:
+                                LA28_41 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 42:
-                                LA29_41 = self.input.LA(3)
+                            elif LA28 == 42:
+                                LA28_42 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 45 or LA29 == 46:
-                                LA29_42 = self.input.LA(3)
+                            elif LA28 == 43:
+                                LA28_43 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 48:
-                                LA29_43 = self.input.LA(3)
+                            elif LA28 == 46 or LA28 == 47:
+                                LA28_44 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == IDENTIFIER:
-                                LA29_44 = self.input.LA(3)
+                            elif LA28 == 49:
+                                LA28_45 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 49 or LA29 == 50 or LA29 == 51 or LA29 == 52 or LA29 == 53:
-                                LA29_45 = self.input.LA(3)
+                            elif LA28 == IDENTIFIER:
+                                LA28_46 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
+                            elif LA28 == 50 or LA28 == 51 or LA28 == 52 or LA28 == 53 or LA28 == 54 or LA28 == 55:
+                                LA28_47 = self.input.LA(3)
 
-                        elif (LA29_0 == 57) :
-                            LA29 = self.input.LA(2)
-                            if LA29 == 58:
-                                LA29_47 = self.input.LA(3)
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
 
 
-                            elif LA29 == 55:
-                                LA29_48 = self.input.LA(3)
+                        elif (LA28_0 == 59) :
+                            LA28 = self.input.LA(2)
+                            if LA28 == 60:
+                                LA28_49 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == IDENTIFIER:
-                                LA29_49 = self.input.LA(3)
+                            elif LA28 == 57:
+                                LA28_50 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == HEX_LITERAL:
-                                LA29_50 = self.input.LA(3)
+                            elif LA28 == IDENTIFIER:
+                                LA28_51 = self.input.LA(3)
+
+                                if (self.synpred58()) :
+                                    alt28 = 1
+
+
+                            elif LA28 == HEX_LITERAL:
+                                LA28_52 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == OCTAL_LITERAL:
-                                LA29_51 = self.input.LA(3)
+                            elif LA28 == OCTAL_LITERAL:
+                                LA28_53 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == DECIMAL_LITERAL:
-                                LA29_52 = self.input.LA(3)
+                            elif LA28 == DECIMAL_LITERAL:
+                                LA28_54 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == CHARACTER_LITERAL:
-                                LA29_53 = self.input.LA(3)
+                            elif LA28 == CHARACTER_LITERAL:
+                                LA28_55 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == STRING_LITERAL:
-                                LA29_54 = self.input.LA(3)
+                            elif LA28 == STRING_LITERAL:
+                                LA28_56 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == FLOATING_POINT_LITERAL:
-                                LA29_55 = self.input.LA(3)
+                            elif LA28 == FLOATING_POINT_LITERAL:
+                                LA28_57 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 65:
-                                LA29_56 = self.input.LA(3)
+                            elif LA28 == 67:
+                                LA28_58 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 66:
-                                LA29_57 = self.input.LA(3)
+                            elif LA28 == 68:
+                                LA28_59 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 59 or LA29 == 61 or LA29 == 62 or LA29 == 70 or LA29 == 71 or LA29 == 72:
-                                LA29_58 = self.input.LA(3)
+                            elif LA28 == 61 or LA28 == 63 or LA28 == 64 or LA28 == 72 or LA28 == 73 or LA28 == 74:
+                                LA28_60 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
-                            elif LA29 == 67:
-                                LA29_59 = self.input.LA(3)
+                            elif LA28 == 69:
+                                LA28_61 = self.input.LA(3)
 
-                                if (self.synpred57()) :
-                                    alt29 = 1
+                                if (self.synpred58()) :
+                                    alt28 = 1
 
 
 
 
 
-                        if alt29 == 1:
+                        if alt28 == 1:
                             # C.g:0:0: declarator_suffix
-                            self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator764)
+                            self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator771)
                             self.declarator_suffix()
                             self.following.pop()
                             if self.failed:
@@ -2774,17 +2806,17 @@ class CParser(Parser):
 
 
                         else:
-                            if cnt29 >= 1:
-                                break #loop29
+                            if cnt28 >= 1:
+                                break #loop28
 
                             if self.backtracking > 0:
                                 self.failed = True
                                 return 
 
-                            eee = EarlyExitException(29, self.input)
+                            eee = EarlyExitException(28, self.input)
                             raise eee
 
-                        cnt29 += 1
+                        cnt28 += 1
 
 
 
@@ -2805,7 +2837,7 @@ class CParser(Parser):
 
 
     # $ANTLR start declarator_suffix
-    # C.g:238:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );
+    # C.g:240:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );
     def declarator_suffix(self, ):
 
         declarator_suffix_StartIndex = self.input.index()
@@ -2814,54 +2846,54 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 24):
                     return 
 
-                # C.g:239:2: ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' )
-                alt31 = 5
-                LA31_0 = self.input.LA(1)
+                # C.g:241:2: ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' )
+                alt30 = 5
+                LA30_0 = self.input.LA(1)
 
-                if (LA31_0 == 57) :
-                    LA31_1 = self.input.LA(2)
+                if (LA30_0 == 59) :
+                    LA30_1 = self.input.LA(2)
 
-                    if (LA31_1 == 58) :
-                        alt31 = 2
-                    elif ((IDENTIFIER <= LA31_1 <= FLOATING_POINT_LITERAL) or LA31_1 == 55 or LA31_1 == 59 or (61 <= LA31_1 <= 62) or (65 <= LA31_1 <= 67) or (70 <= LA31_1 <= 72)) :
-                        alt31 = 1
+                    if (LA30_1 == 60) :
+                        alt30 = 2
+                    elif ((IDENTIFIER <= LA30_1 <= FLOATING_POINT_LITERAL) or LA30_1 == 57 or LA30_1 == 61 or (63 <= LA30_1 <= 64) or (67 <= LA30_1 <= 69) or (72 <= LA30_1 <= 74)) :
+                        alt30 = 1
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("238:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 31, 1, self.input)
+                        nvae = NoViableAltException("240:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 30, 1, self.input)
 
                         raise nvae
 
-                elif (LA31_0 == 55) :
-                    LA31 = self.input.LA(2)
-                    if LA31 == 56:
-                        alt31 = 5
-                    elif LA31 == IDENTIFIER:
-                        LA31_17 = self.input.LA(3)
+                elif (LA30_0 == 57) :
+                    LA30 = self.input.LA(2)
+                    if LA30 == 58:
+                        alt30 = 5
+                    elif LA30 == 29 or LA30 == 30 or LA30 == 31 or LA30 == 32 or LA30 == 33 or LA30 == 34 or LA30 == 35 or LA30 == 36 or LA30 == 37 or LA30 == 38 or LA30 == 39 or LA30 == 40 or LA30 == 41 or LA30 == 42 or LA30 == 43 or LA30 == 46 or LA30 == 47 or LA30 == 49 or LA30 == 50 or LA30 == 51 or LA30 == 52 or LA30 == 53 or LA30 == 54 or LA30 == 55:
+                        alt30 = 3
+                    elif LA30 == IDENTIFIER:
+                        LA30_30 = self.input.LA(3)
 
-                        if (self.synpred60()) :
-                            alt31 = 3
-                        elif (self.synpred61()) :
-                            alt31 = 4
+                        if (self.synpred61()) :
+                            alt30 = 3
+                        elif (self.synpred62()) :
+                            alt30 = 4
                         else:
                             if self.backtracking > 0:
                                 self.failed = True
                                 return 
 
-                            nvae = NoViableAltException("238:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 31, 17, self.input)
+                            nvae = NoViableAltException("240:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 30, 30, self.input)
 
                             raise nvae
 
-                    elif LA31 == 29 or LA31 == 30 or LA31 == 31 or LA31 == 32 or LA31 == 33 or LA31 == 34 or LA31 == 35 or LA31 == 36 or LA31 == 37 or LA31 == 38 or LA31 == 39 or LA31 == 40 or LA31 == 41 or LA31 == 42 or LA31 == 45 or LA31 == 46 or LA31 == 48 or LA31 == 49 or LA31 == 50 or LA31 == 51 or LA31 == 52 or LA31 == 53:
-                        alt31 = 3
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("238:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 31, 2, self.input)
+                        nvae = NoViableAltException("240:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 30, 2, self.input)
 
                         raise nvae
 
@@ -2870,71 +2902,71 @@ class CParser(Parser):
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("238:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 31, 0, self.input)
+                    nvae = NoViableAltException("240:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 30, 0, self.input)
 
                     raise nvae
 
-                if alt31 == 1:
-                    # C.g:239:6: '[' constant_expression ']'
-                    self.match(self.input, 57, self.FOLLOW_57_in_declarator_suffix778)
+                if alt30 == 1:
+                    # C.g:241:6: '[' constant_expression ']'
+                    self.match(self.input, 59, self.FOLLOW_59_in_declarator_suffix785)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_constant_expression_in_declarator_suffix780)
+                    self.following.append(self.FOLLOW_constant_expression_in_declarator_suffix787)
                     self.constant_expression()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 58, self.FOLLOW_58_in_declarator_suffix782)
+                    self.match(self.input, 60, self.FOLLOW_60_in_declarator_suffix789)
                     if self.failed:
                         return 
 
 
-                elif alt31 == 2:
-                    # C.g:240:9: '[' ']'
-                    self.match(self.input, 57, self.FOLLOW_57_in_declarator_suffix792)
+                elif alt30 == 2:
+                    # C.g:242:9: '[' ']'
+                    self.match(self.input, 59, self.FOLLOW_59_in_declarator_suffix799)
                     if self.failed:
                         return 
-                    self.match(self.input, 58, self.FOLLOW_58_in_declarator_suffix794)
+                    self.match(self.input, 60, self.FOLLOW_60_in_declarator_suffix801)
                     if self.failed:
                         return 
 
 
-                elif alt31 == 3:
-                    # C.g:241:9: '(' parameter_type_list ')'
-                    self.match(self.input, 55, self.FOLLOW_55_in_declarator_suffix804)
+                elif alt30 == 3:
+                    # C.g:243:9: '(' parameter_type_list ')'
+                    self.match(self.input, 57, self.FOLLOW_57_in_declarator_suffix811)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_parameter_type_list_in_declarator_suffix806)
+                    self.following.append(self.FOLLOW_parameter_type_list_in_declarator_suffix813)
                     self.parameter_type_list()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_declarator_suffix808)
+                    self.match(self.input, 58, self.FOLLOW_58_in_declarator_suffix815)
                     if self.failed:
                         return 
 
 
-                elif alt31 == 4:
-                    # C.g:242:9: '(' identifier_list ')'
-                    self.match(self.input, 55, self.FOLLOW_55_in_declarator_suffix818)
+                elif alt30 == 4:
+                    # C.g:244:9: '(' identifier_list ')'
+                    self.match(self.input, 57, self.FOLLOW_57_in_declarator_suffix825)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_identifier_list_in_declarator_suffix820)
+                    self.following.append(self.FOLLOW_identifier_list_in_declarator_suffix827)
                     self.identifier_list()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_declarator_suffix822)
+                    self.match(self.input, 58, self.FOLLOW_58_in_declarator_suffix829)
                     if self.failed:
                         return 
 
 
-                elif alt31 == 5:
-                    # C.g:243:9: '(' ')'
-                    self.match(self.input, 55, self.FOLLOW_55_in_declarator_suffix832)
+                elif alt30 == 5:
+                    # C.g:245:9: '(' ')'
+                    self.match(self.input, 57, self.FOLLOW_57_in_declarator_suffix839)
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_declarator_suffix834)
+                    self.match(self.input, 58, self.FOLLOW_58_in_declarator_suffix841)
                     if self.failed:
                         return 
 
@@ -2955,7 +2987,7 @@ class CParser(Parser):
 
 
     # $ANTLR start pointer
-    # C.g:246:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );
+    # C.g:248:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );
     def pointer(self, ):
 
         pointer_StartIndex = self.input.index()
@@ -2964,59 +2996,59 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 25):
                     return 
 
-                # C.g:247:2: ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' )
-                alt34 = 3
-                LA34_0 = self.input.LA(1)
+                # C.g:249:2: ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' )
+                alt33 = 3
+                LA33_0 = self.input.LA(1)
 
-                if (LA34_0 == 59) :
-                    LA34 = self.input.LA(2)
-                    if LA34 == EOF or LA34 == IDENTIFIER or LA34 == 25 or LA34 == 26 or LA34 == 27 or LA34 == 28 or LA34 == 29 or LA34 == 30 or LA34 == 31 or LA34 == 32 or LA34 == 33 or LA34 == 34 or LA34 == 35 or LA34 == 36 or LA34 == 37 or LA34 == 38 or LA34 == 39 or LA34 == 40 or LA34 == 41 or LA34 == 42 or LA34 == 43 or LA34 == 45 or LA34 == 46 or LA34 == 47 or LA34 == 48 or LA34 == 54 or LA34 == 55 or LA34 == 56 or LA34 == 57:
-                        alt34 = 3
-                    elif LA34 == 59:
-                        LA34_3 = self.input.LA(3)
+                if (LA33_0 == 61) :
+                    LA33 = self.input.LA(2)
+                    if LA33 == 61:
+                        LA33_2 = self.input.LA(3)
 
-                        if (self.synpred65()) :
-                            alt34 = 2
+                        if (self.synpred66()) :
+                            alt33 = 2
                         elif (True) :
-                            alt34 = 3
+                            alt33 = 3
                         else:
                             if self.backtracking > 0:
                                 self.failed = True
                                 return 
 
-                            nvae = NoViableAltException("246:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 34, 3, self.input)
+                            nvae = NoViableAltException("248:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 33, 2, self.input)
 
                             raise nvae
 
-                    elif LA34 == 53:
-                        LA34_21 = self.input.LA(3)
+                    elif LA33 == EOF or LA33 == IDENTIFIER or LA33 == 25 or LA33 == 26 or LA33 == 27 or LA33 == 28 or LA33 == 29 or LA33 == 30 or LA33 == 31 or LA33 == 32 or LA33 == 33 or LA33 == 34 or LA33 == 35 or LA33 == 36 or LA33 == 37 or LA33 == 38 or LA33 == 39 or LA33 == 40 or LA33 == 41 or LA33 == 42 or LA33 == 43 or LA33 == 44 or LA33 == 46 or LA33 == 47 or LA33 == 48 or LA33 == 49 or LA33 == 56 or LA33 == 57 or LA33 == 58 or LA33 == 59:
+                        alt33 = 3
+                    elif LA33 == 54:
+                        LA33_19 = self.input.LA(3)
 
-                        if (self.synpred64()) :
-                            alt34 = 1
+                        if (self.synpred65()) :
+                            alt33 = 1
                         elif (True) :
-                            alt34 = 3
+                            alt33 = 3
                         else:
                             if self.backtracking > 0:
                                 self.failed = True
                                 return 
 
-                            nvae = NoViableAltException("246:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 34, 21, self.input)
+                            nvae = NoViableAltException("248:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 33, 19, self.input)
 
                             raise nvae
 
-                    elif LA34 == 49 or LA34 == 50 or LA34 == 51 or LA34 == 52:
-                        LA34_28 = self.input.LA(3)
+                    elif LA33 == 50 or LA33 == 51 or LA33 == 52 or LA33 == 53 or LA33 == 55:
+                        LA33_27 = self.input.LA(3)
 
-                        if (self.synpred64()) :
-                            alt34 = 1
+                        if (self.synpred65()) :
+                            alt33 = 1
                         elif (True) :
-                            alt34 = 3
+                            alt33 = 3
                         else:
                             if self.backtracking > 0:
                                 self.failed = True
                                 return 
 
-                            nvae = NoViableAltException("246:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 34, 28, self.input)
+                            nvae = NoViableAltException("248:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 33, 27, self.input)
 
                             raise nvae
 
@@ -3025,7 +3057,7 @@ class CParser(Parser):
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("246:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 34, 1, self.input)
+                        nvae = NoViableAltException("248:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 33, 1, self.input)
 
                         raise nvae
 
@@ -3034,40 +3066,40 @@ class CParser(Parser):
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("246:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 34, 0, self.input)
+                    nvae = NoViableAltException("248:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 33, 0, self.input)
 
                     raise nvae
 
-                if alt34 == 1:
-                    # C.g:247:4: '*' ( type_qualifier )+ ( pointer )?
-                    self.match(self.input, 59, self.FOLLOW_59_in_pointer845)
+                if alt33 == 1:
+                    # C.g:249:4: '*' ( type_qualifier )+ ( pointer )?
+                    self.match(self.input, 61, self.FOLLOW_61_in_pointer852)
                     if self.failed:
                         return 
-                    # C.g:247:8: ( type_qualifier )+
-                    cnt32 = 0
-                    while True: #loop32
-                        alt32 = 2
-                        LA32_0 = self.input.LA(1)
+                    # C.g:249:8: ( type_qualifier )+
+                    cnt31 = 0
+                    while True: #loop31
+                        alt31 = 2
+                        LA31_0 = self.input.LA(1)
 
-                        if (LA32_0 == 53) :
-                            LA32_20 = self.input.LA(2)
+                        if (LA31_0 == 54) :
+                            LA31_18 = self.input.LA(2)
 
-                            if (self.synpred62()) :
-                                alt32 = 1
+                            if (self.synpred63()) :
+                                alt31 = 1
 
 
-                        elif ((49 <= LA32_0 <= 52)) :
-                            LA32_27 = self.input.LA(2)
+                        elif ((50 <= LA31_0 <= 53) or LA31_0 == 55) :
+                            LA31_26 = self.input.LA(2)
 
-                            if (self.synpred62()) :
-                                alt32 = 1
+                            if (self.synpred63()) :
+                                alt31 = 1
 
 
 
 
-                        if alt32 == 1:
+                        if alt31 == 1:
                             # C.g:0:0: type_qualifier
-                            self.following.append(self.FOLLOW_type_qualifier_in_pointer847)
+                            self.following.append(self.FOLLOW_type_qualifier_in_pointer854)
                             self.type_qualifier()
                             self.following.pop()
                             if self.failed:
@@ -3075,31 +3107,31 @@ class CParser(Parser):
 
 
                         else:
-                            if cnt32 >= 1:
-                                break #loop32
+                            if cnt31 >= 1:
+                                break #loop31
 
                             if self.backtracking > 0:
                                 self.failed = True
                                 return 
 
-                            eee = EarlyExitException(32, self.input)
+                            eee = EarlyExitException(31, self.input)
                             raise eee
 
-                        cnt32 += 1
+                        cnt31 += 1
 
 
-                    # C.g:247:24: ( pointer )?
-                    alt33 = 2
-                    LA33_0 = self.input.LA(1)
+                    # C.g:249:24: ( pointer )?
+                    alt32 = 2
+                    LA32_0 = self.input.LA(1)
 
-                    if (LA33_0 == 59) :
-                        LA33_1 = self.input.LA(2)
+                    if (LA32_0 == 61) :
+                        LA32_1 = self.input.LA(2)
 
-                        if (self.synpred63()) :
-                            alt33 = 1
-                    if alt33 == 1:
+                        if (self.synpred64()) :
+                            alt32 = 1
+                    if alt32 == 1:
                         # C.g:0:0: pointer
-                        self.following.append(self.FOLLOW_pointer_in_pointer850)
+                        self.following.append(self.FOLLOW_pointer_in_pointer857)
                         self.pointer()
                         self.following.pop()
                         if self.failed:
@@ -3109,21 +3141,21 @@ class CParser(Parser):
 
 
 
-                elif alt34 == 2:
-                    # C.g:248:4: '*' pointer
-                    self.match(self.input, 59, self.FOLLOW_59_in_pointer856)
+                elif alt33 == 2:
+                    # C.g:250:4: '*' pointer
+                    self.match(self.input, 61, self.FOLLOW_61_in_pointer863)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_pointer_in_pointer858)
+                    self.following.append(self.FOLLOW_pointer_in_pointer865)
                     self.pointer()
                     self.following.pop()
                     if self.failed:
                         return 
 
 
-                elif alt34 == 3:
-                    # C.g:249:4: '*'
-                    self.match(self.input, 59, self.FOLLOW_59_in_pointer863)
+                elif alt33 == 3:
+                    # C.g:251:4: '*'
+                    self.match(self.input, 61, self.FOLLOW_61_in_pointer870)
                     if self.failed:
                         return 
 
@@ -3144,7 +3176,7 @@ class CParser(Parser):
 
 
     # $ANTLR start parameter_type_list
-    # C.g:252:1: parameter_type_list : parameter_list ( ',' '...' )? ;
+    # C.g:254:1: parameter_type_list : parameter_list ( ',' '...' )? ;
     def parameter_type_list(self, ):
 
         parameter_type_list_StartIndex = self.input.index()
@@ -3153,25 +3185,25 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 26):
                     return 
 
-                # C.g:253:2: ( parameter_list ( ',' '...' )? )
-                # C.g:253:4: parameter_list ( ',' '...' )?
-                self.following.append(self.FOLLOW_parameter_list_in_parameter_type_list874)
+                # C.g:255:2: ( parameter_list ( ',' '...' )? )
+                # C.g:255:4: parameter_list ( ',' '...' )?
+                self.following.append(self.FOLLOW_parameter_list_in_parameter_type_list881)
                 self.parameter_list()
                 self.following.pop()
                 if self.failed:
                     return 
-                # C.g:253:19: ( ',' '...' )?
-                alt35 = 2
-                LA35_0 = self.input.LA(1)
+                # C.g:255:19: ( ',' '...' )?
+                alt34 = 2
+                LA34_0 = self.input.LA(1)
 
-                if (LA35_0 == 27) :
-                    alt35 = 1
-                if alt35 == 1:
-                    # C.g:253:20: ',' '...'
-                    self.match(self.input, 27, self.FOLLOW_27_in_parameter_type_list877)
+                if (LA34_0 == 27) :
+                    alt34 = 1
+                if alt34 == 1:
+                    # C.g:255:20: ',' '...'
+                    self.match(self.input, 27, self.FOLLOW_27_in_parameter_type_list884)
                     if self.failed:
                         return 
-                    self.match(self.input, 60, self.FOLLOW_60_in_parameter_type_list879)
+                    self.match(self.input, 62, self.FOLLOW_62_in_parameter_type_list886)
                     if self.failed:
                         return 
 
@@ -3196,7 +3228,7 @@ class CParser(Parser):
 
 
     # $ANTLR start parameter_list
-    # C.g:256:1: parameter_list : parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* ;
+    # C.g:258:1: parameter_list : parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* ;
     def parameter_list(self, ):
 
         parameter_list_StartIndex = self.input.index()
@@ -3205,50 +3237,50 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 27):
                     return 
 
-                # C.g:257:2: ( parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* )
-                # C.g:257:4: parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )*
-                self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list892)
+                # C.g:259:2: ( parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* )
+                # C.g:259:4: parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )*
+                self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list899)
                 self.parameter_declaration()
                 self.following.pop()
                 if self.failed:
                     return 
-                # C.g:257:26: ( ',' ( 'OPTIONAL' )? parameter_declaration )*
-                while True: #loop37
-                    alt37 = 2
-                    LA37_0 = self.input.LA(1)
+                # C.g:259:26: ( ',' ( 'OPTIONAL' )? parameter_declaration )*
+                while True: #loop36
+                    alt36 = 2
+                    LA36_0 = self.input.LA(1)
 
-                    if (LA37_0 == 27) :
-                        LA37_1 = self.input.LA(2)
+                    if (LA36_0 == 27) :
+                        LA36_1 = self.input.LA(2)
 
-                        if (LA37_1 == IDENTIFIER or (29 <= LA37_1 <= 42) or (45 <= LA37_1 <= 46) or (48 <= LA37_1 <= 53)) :
-                            alt37 = 1
+                        if (LA36_1 == IDENTIFIER or (29 <= LA36_1 <= 43) or (46 <= LA36_1 <= 47) or (49 <= LA36_1 <= 55)) :
+                            alt36 = 1
 
 
 
 
-                    if alt37 == 1:
-                        # C.g:257:27: ',' ( 'OPTIONAL' )? parameter_declaration
-                        self.match(self.input, 27, self.FOLLOW_27_in_parameter_list895)
+                    if alt36 == 1:
+                        # C.g:259:27: ',' ( 'OPTIONAL' )? parameter_declaration
+                        self.match(self.input, 27, self.FOLLOW_27_in_parameter_list902)
                         if self.failed:
                             return 
-                        # C.g:257:31: ( 'OPTIONAL' )?
-                        alt36 = 2
-                        LA36_0 = self.input.LA(1)
-
-                        if (LA36_0 == 53) :
-                            LA36_1 = self.input.LA(2)
-
-                            if (self.synpred67()) :
-                                alt36 = 1
-                        if alt36 == 1:
-                            # C.g:257:32: 'OPTIONAL'
-                            self.match(self.input, 53, self.FOLLOW_53_in_parameter_list898)
+                        # C.g:259:31: ( 'OPTIONAL' )?
+                        alt35 = 2
+                        LA35_0 = self.input.LA(1)
+
+                        if (LA35_0 == 54) :
+                            LA35_1 = self.input.LA(2)
+
+                            if (self.synpred68()) :
+                                alt35 = 1
+                        if alt35 == 1:
+                            # C.g:259:32: 'OPTIONAL'
+                            self.match(self.input, 54, self.FOLLOW_54_in_parameter_list905)
                             if self.failed:
                                 return 
 
 
 
-                        self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list902)
+                        self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list909)
                         self.parameter_declaration()
                         self.following.pop()
                         if self.failed:
@@ -3256,7 +3288,7 @@ class CParser(Parser):
 
 
                     else:
-                        break #loop37
+                        break #loop36
 
 
 
@@ -3278,7 +3310,7 @@ class CParser(Parser):
 
 
     # $ANTLR start parameter_declaration
-    # C.g:260:1: parameter_declaration : declaration_specifiers ( declarator | abstract_declarator )+ ( 'OPTIONAL' )? ;
+    # C.g:262:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | IDENTIFIER );
     def parameter_declaration(self, ):
 
         parameter_declaration_StartIndex = self.input.index()
@@ -3287,115 +3319,141 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 28):
                     return 
 
-                # C.g:261:2: ( declaration_specifiers ( declarator | abstract_declarator )+ ( 'OPTIONAL' )? )
-                # C.g:261:4: declaration_specifiers ( declarator | abstract_declarator )+ ( 'OPTIONAL' )?
-                self.following.append(self.FOLLOW_declaration_specifiers_in_parameter_declaration915)
-                self.declaration_specifiers()
-                self.following.pop()
-                if self.failed:
-                    return 
-                # C.g:261:27: ( declarator | abstract_declarator )+
-                cnt38 = 0
-                while True: #loop38
-                    alt38 = 3
-                    LA38 = self.input.LA(1)
-                    if LA38 == IDENTIFIER or LA38 == 54:
-                        alt38 = 1
-                    elif LA38 == 59:
-                        LA38_6 = self.input.LA(2)
+                # C.g:263:2: ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | IDENTIFIER )
+                alt39 = 2
+                LA39_0 = self.input.LA(1)
+
+                if ((29 <= LA39_0 <= 43) or (46 <= LA39_0 <= 47) or (49 <= LA39_0 <= 55)) :
+                    alt39 = 1
+                elif (LA39_0 == IDENTIFIER) :
+                    LA39_14 = self.input.LA(2)
+
+                    if (self.synpred73()) :
+                        alt39 = 1
+                    elif (True) :
+                        alt39 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return 
 
-                        if (self.synpred69()) :
-                            alt38 = 1
-                        elif (self.synpred70()) :
-                            alt38 = 2
+                        nvae = NoViableAltException("262:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | IDENTIFIER );", 39, 14, self.input)
 
+                        raise nvae
 
-                    elif LA38 == 55:
-                        LA38 = self.input.LA(2)
-                        if LA38 == 29 or LA38 == 30 or LA38 == 31 or LA38 == 32 or LA38 == 33 or LA38 == 34 or LA38 == 35 or LA38 == 36 or LA38 == 37 or LA38 == 38 or LA38 == 39 or LA38 == 40 or LA38 == 41 or LA38 == 42 or LA38 == 45 or LA38 == 46 or LA38 == 48 or LA38 == 49 or LA38 == 50 or LA38 == 51 or LA38 == 52 or LA38 == 53 or LA38 == 56 or LA38 == 57:
-                            alt38 = 2
-                        elif LA38 == 59:
-                            LA38_21 = self.input.LA(3)
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return 
 
-                            if (self.synpred69()) :
-                                alt38 = 1
-                            elif (self.synpred70()) :
-                                alt38 = 2
+                    nvae = NoViableAltException("262:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | IDENTIFIER );", 39, 0, self.input)
 
+                    raise nvae
 
-                        elif LA38 == 55:
-                            LA38_22 = self.input.LA(3)
+                if alt39 == 1:
+                    # C.g:263:4: declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )?
+                    self.following.append(self.FOLLOW_declaration_specifiers_in_parameter_declaration922)
+                    self.declaration_specifiers()
+                    self.following.pop()
+                    if self.failed:
+                        return 
+                    # C.g:263:27: ( declarator | abstract_declarator )*
+                    while True: #loop37
+                        alt37 = 3
+                        LA37 = self.input.LA(1)
+                        if LA37 == IDENTIFIER or LA37 == 56:
+                            alt37 = 1
+                        elif LA37 == 61:
+                            LA37_6 = self.input.LA(2)
 
-                            if (self.synpred69()) :
-                                alt38 = 1
-                            elif (self.synpred70()) :
-                                alt38 = 2
+                            if (self.synpred70()) :
+                                alt37 = 1
+                            elif (self.synpred71()) :
+                                alt37 = 2
 
 
-                        elif LA38 == 54:
-                            alt38 = 1
-                        elif LA38 == IDENTIFIER:
-                            LA38_25 = self.input.LA(3)
+                        elif LA37 == 57:
+                            LA37 = self.input.LA(2)
+                            if LA37 == 29 or LA37 == 30 or LA37 == 31 or LA37 == 32 or LA37 == 33 or LA37 == 34 or LA37 == 35 or LA37 == 36 or LA37 == 37 or LA37 == 38 or LA37 == 39 or LA37 == 40 or LA37 == 41 or LA37 == 42 or LA37 == 43 or LA37 == 46 or LA37 == 47 or LA37 == 49 or LA37 == 50 or LA37 == 51 or LA37 == 52 or LA37 == 53 or LA37 == 54 or LA37 == 55 or LA37 == 58 or LA37 == 59:
+                                alt37 = 2
+                            elif LA37 == 61:
+                                LA37_21 = self.input.LA(3)
 
-                            if (self.synpred69()) :
-                                alt38 = 1
-                            elif (self.synpred70()) :
-                                alt38 = 2
+                                if (self.synpred70()) :
+                                    alt37 = 1
+                                elif (self.synpred71()) :
+                                    alt37 = 2
 
 
+                            elif LA37 == 57:
+                                LA37_22 = self.input.LA(3)
 
-                    elif LA38 == 57:
-                        alt38 = 2
+                                if (self.synpred70()) :
+                                    alt37 = 1
+                                elif (self.synpred71()) :
+                                    alt37 = 2
 
-                    if alt38 == 1:
-                        # C.g:261:28: declarator
-                        self.following.append(self.FOLLOW_declarator_in_parameter_declaration918)
-                        self.declarator()
-                        self.following.pop()
-                        if self.failed:
-                            return 
 
+                            elif LA37 == IDENTIFIER:
+                                LA37_37 = self.input.LA(3)
 
-                    elif alt38 == 2:
-                        # C.g:261:39: abstract_declarator
-                        self.following.append(self.FOLLOW_abstract_declarator_in_parameter_declaration920)
-                        self.abstract_declarator()
-                        self.following.pop()
-                        if self.failed:
-                            return 
+                                if (self.synpred70()) :
+                                    alt37 = 1
+                                elif (self.synpred71()) :
+                                    alt37 = 2
 
 
-                    else:
-                        if cnt38 >= 1:
-                            break #loop38
+                            elif LA37 == 56:
+                                alt37 = 1
 
-                        if self.backtracking > 0:
-                            self.failed = True
-                            return 
+                        elif LA37 == 59:
+                            alt37 = 2
 
-                        eee = EarlyExitException(38, self.input)
-                        raise eee
+                        if alt37 == 1:
+                            # C.g:263:28: declarator
+                            self.following.append(self.FOLLOW_declarator_in_parameter_declaration925)
+                            self.declarator()
+                            self.following.pop()
+                            if self.failed:
+                                return 
 
-                    cnt38 += 1
 
+                        elif alt37 == 2:
+                            # C.g:263:39: abstract_declarator
+                            self.following.append(self.FOLLOW_abstract_declarator_in_parameter_declaration927)
+                            self.abstract_declarator()
+                            self.following.pop()
+                            if self.failed:
+                                return 
 
-                # C.g:261:61: ( 'OPTIONAL' )?
-                alt39 = 2
-                LA39_0 = self.input.LA(1)
 
-                if (LA39_0 == 53) :
-                    alt39 = 1
-                if alt39 == 1:
-                    # C.g:261:62: 'OPTIONAL'
-                    self.match(self.input, 53, self.FOLLOW_53_in_parameter_declaration925)
-                    if self.failed:
-                        return 
+                        else:
+                            break #loop37
+
+
+                    # C.g:263:61: ( 'OPTIONAL' )?
+                    alt38 = 2
+                    LA38_0 = self.input.LA(1)
 
+                    if (LA38_0 == 54) :
+                        alt38 = 1
+                    if alt38 == 1:
+                        # C.g:263:62: 'OPTIONAL'
+                        self.match(self.input, 54, self.FOLLOW_54_in_parameter_declaration932)
+                        if self.failed:
+                            return 
 
 
 
 
 
+                elif alt39 == 2:
+                    # C.g:265:4: IDENTIFIER
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_parameter_declaration941)
+                    if self.failed:
+                        return 
+
+
 
             except RecognitionException, re:
                 self.reportError(re)
@@ -3412,7 +3470,7 @@ class CParser(Parser):
 
 
     # $ANTLR start identifier_list
-    # C.g:264:1: identifier_list : IDENTIFIER ( ',' IDENTIFIER )* ;
+    # C.g:268:1: identifier_list : IDENTIFIER ( ',' IDENTIFIER )* ;
     def identifier_list(self, ):
 
         identifier_list_StartIndex = self.input.index()
@@ -3421,12 +3479,12 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 29):
                     return 
 
-                # C.g:265:2: ( IDENTIFIER ( ',' IDENTIFIER )* )
-                # C.g:265:4: IDENTIFIER ( ',' IDENTIFIER )*
-                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list938)
+                # C.g:269:2: ( IDENTIFIER ( ',' IDENTIFIER )* )
+                # C.g:269:4: IDENTIFIER ( ',' IDENTIFIER )*
+                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list952)
                 if self.failed:
                     return 
-                # C.g:266:2: ( ',' IDENTIFIER )*
+                # C.g:270:2: ( ',' IDENTIFIER )*
                 while True: #loop40
                     alt40 = 2
                     LA40_0 = self.input.LA(1)
@@ -3436,11 +3494,11 @@ class CParser(Parser):
 
 
                     if alt40 == 1:
-                        # C.g:266:3: ',' IDENTIFIER
-                        self.match(self.input, 27, self.FOLLOW_27_in_identifier_list942)
+                        # C.g:270:3: ',' IDENTIFIER
+                        self.match(self.input, 27, self.FOLLOW_27_in_identifier_list956)
                         if self.failed:
                             return 
-                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list944)
+                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list958)
                         if self.failed:
                             return 
 
@@ -3468,7 +3526,7 @@ class CParser(Parser):
 
 
     # $ANTLR start type_name
-    # C.g:269:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );
+    # C.g:273:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );
     def type_name(self, ):
 
         type_name_StartIndex = self.input.index()
@@ -3477,16 +3535,16 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 30):
                     return 
 
-                # C.g:270:2: ( specifier_qualifier_list ( abstract_declarator )? | type_id )
+                # C.g:274:2: ( specifier_qualifier_list ( abstract_declarator )? | type_id )
                 alt42 = 2
                 LA42_0 = self.input.LA(1)
 
-                if ((34 <= LA42_0 <= 42) or (45 <= LA42_0 <= 46) or (48 <= LA42_0 <= 53)) :
+                if ((34 <= LA42_0 <= 43) or (46 <= LA42_0 <= 47) or (49 <= LA42_0 <= 55)) :
                     alt42 = 1
                 elif (LA42_0 == IDENTIFIER) :
-                    LA42_13 = self.input.LA(2)
+                    LA42_14 = self.input.LA(2)
 
-                    if (self.synpred74()) :
+                    if (self.synpred76()) :
                         alt42 = 1
                     elif (True) :
                         alt42 = 2
@@ -3495,7 +3553,7 @@ class CParser(Parser):
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("269:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 42, 13, self.input)
+                        nvae = NoViableAltException("273:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 42, 14, self.input)
 
                         raise nvae
 
@@ -3504,26 +3562,26 @@ class CParser(Parser):
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("269:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 42, 0, self.input)
+                    nvae = NoViableAltException("273:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 42, 0, self.input)
 
                     raise nvae
 
                 if alt42 == 1:
-                    # C.g:270:4: specifier_qualifier_list ( abstract_declarator )?
-                    self.following.append(self.FOLLOW_specifier_qualifier_list_in_type_name957)
+                    # C.g:274:4: specifier_qualifier_list ( abstract_declarator )?
+                    self.following.append(self.FOLLOW_specifier_qualifier_list_in_type_name971)
                     self.specifier_qualifier_list()
                     self.following.pop()
                     if self.failed:
                         return 
-                    # C.g:270:29: ( abstract_declarator )?
+                    # C.g:274:29: ( abstract_declarator )?
                     alt41 = 2
                     LA41_0 = self.input.LA(1)
 
-                    if (LA41_0 == 55 or LA41_0 == 57 or LA41_0 == 59) :
+                    if (LA41_0 == 57 or LA41_0 == 59 or LA41_0 == 61) :
                         alt41 = 1
                     if alt41 == 1:
                         # C.g:0:0: abstract_declarator
-                        self.following.append(self.FOLLOW_abstract_declarator_in_type_name959)
+                        self.following.append(self.FOLLOW_abstract_declarator_in_type_name973)
                         self.abstract_declarator()
                         self.following.pop()
                         if self.failed:
@@ -3534,8 +3592,8 @@ class CParser(Parser):
 
 
                 elif alt42 == 2:
-                    # C.g:271:4: type_id
-                    self.following.append(self.FOLLOW_type_id_in_type_name965)
+                    # C.g:275:4: type_id
+                    self.following.append(self.FOLLOW_type_id_in_type_name979)
                     self.type_id()
                     self.following.pop()
                     if self.failed:
@@ -3558,7 +3616,7 @@ class CParser(Parser):
 
 
     # $ANTLR start abstract_declarator
-    # C.g:274:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );
+    # C.g:278:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );
     def abstract_declarator(self, ):
 
         abstract_declarator_StartIndex = self.input.index()
@@ -3567,196 +3625,201 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 31):
                     return 
 
-                # C.g:275:2: ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator )
+                # C.g:279:2: ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator )
                 alt44 = 2
                 LA44_0 = self.input.LA(1)
 
-                if (LA44_0 == 59) :
+                if (LA44_0 == 61) :
                     alt44 = 1
-                elif (LA44_0 == 55 or LA44_0 == 57) :
+                elif (LA44_0 == 57 or LA44_0 == 59) :
                     alt44 = 2
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("274:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );", 44, 0, self.input)
+                    nvae = NoViableAltException("278:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );", 44, 0, self.input)
 
                     raise nvae
 
                 if alt44 == 1:
-                    # C.g:275:4: pointer ( direct_abstract_declarator )?
-                    self.following.append(self.FOLLOW_pointer_in_abstract_declarator976)
+                    # C.g:279:4: pointer ( direct_abstract_declarator )?
+                    self.following.append(self.FOLLOW_pointer_in_abstract_declarator990)
                     self.pointer()
                     self.following.pop()
                     if self.failed:
                         return 
-                    # C.g:275:12: ( direct_abstract_declarator )?
+                    # C.g:279:12: ( direct_abstract_declarator )?
                     alt43 = 2
                     LA43_0 = self.input.LA(1)
 
-                    if (LA43_0 == 55) :
+                    if (LA43_0 == 57) :
                         LA43 = self.input.LA(2)
-                        if LA43 == 56:
+                        if LA43 == 58:
                             LA43_10 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 59:
+                        elif LA43 == 61:
                             LA43_11 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 55:
+                        elif LA43 == 57:
                             LA43_12 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 57:
+                        elif LA43 == 59:
                             LA43_13 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 29 or LA43 == 30 or LA43 == 31 or LA43 == 32 or LA43 == 33:
                             LA43_14 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 34:
                             LA43_15 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 35:
                             LA43_16 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 36:
                             LA43_17 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 37:
                             LA43_18 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 38:
                             LA43_19 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 39:
                             LA43_20 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 40:
                             LA43_21 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 41:
                             LA43_22 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
                         elif LA43 == 42:
                             LA43_23 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 45 or LA43 == 46:
+                        elif LA43 == 43:
                             LA43_24 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 48:
+                        elif LA43 == 46 or LA43 == 47:
                             LA43_25 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == IDENTIFIER:
+                        elif LA43 == 49:
                             LA43_26 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 49 or LA43 == 50 or LA43 == 51 or LA43 == 52 or LA43 == 53:
+                        elif LA43 == IDENTIFIER:
                             LA43_27 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                    elif (LA43_0 == 57) :
-                        LA43 = self.input.LA(2)
-                        if LA43 == 58:
-                            LA43_29 = self.input.LA(3)
+                        elif LA43 == 50 or LA43 == 51 or LA43 == 52 or LA43 == 53 or LA43 == 54 or LA43 == 55:
+                            LA43_28 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 55:
+                    elif (LA43_0 == 59) :
+                        LA43 = self.input.LA(2)
+                        if LA43 == 60:
                             LA43_30 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == IDENTIFIER:
+                        elif LA43 == 57:
                             LA43_31 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == HEX_LITERAL:
+                        elif LA43 == IDENTIFIER:
                             LA43_32 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == OCTAL_LITERAL:
+                        elif LA43 == HEX_LITERAL:
                             LA43_33 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == DECIMAL_LITERAL:
+                        elif LA43 == OCTAL_LITERAL:
                             LA43_34 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == CHARACTER_LITERAL:
+                        elif LA43 == DECIMAL_LITERAL:
                             LA43_35 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == STRING_LITERAL:
+                        elif LA43 == CHARACTER_LITERAL:
                             LA43_36 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == FLOATING_POINT_LITERAL:
+                        elif LA43 == STRING_LITERAL:
                             LA43_37 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 65:
+                        elif LA43 == FLOATING_POINT_LITERAL:
                             LA43_38 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 66:
+                        elif LA43 == 67:
                             LA43_39 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 59 or LA43 == 61 or LA43 == 62 or LA43 == 70 or LA43 == 71 or LA43 == 72:
+                        elif LA43 == 68:
                             LA43_40 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
                                 alt43 = 1
-                        elif LA43 == 67:
+                        elif LA43 == 61 or LA43 == 63 or LA43 == 64 or LA43 == 72 or LA43 == 73 or LA43 == 74:
                             LA43_41 = self.input.LA(3)
 
-                            if (self.synpred75()) :
+                            if (self.synpred77()) :
+                                alt43 = 1
+                        elif LA43 == 69:
+                            LA43_42 = self.input.LA(3)
+
+                            if (self.synpred77()) :
                                 alt43 = 1
                     if alt43 == 1:
                         # C.g:0:0: direct_abstract_declarator
-                        self.following.append(self.FOLLOW_direct_abstract_declarator_in_abstract_declarator978)
+                        self.following.append(self.FOLLOW_direct_abstract_declarator_in_abstract_declarator992)
                         self.direct_abstract_declarator()
                         self.following.pop()
                         if self.failed:
@@ -3767,8 +3830,8 @@ class CParser(Parser):
 
 
                 elif alt44 == 2:
-                    # C.g:276:4: direct_abstract_declarator
-                    self.following.append(self.FOLLOW_direct_abstract_declarator_in_abstract_declarator984)
+                    # C.g:280:4: direct_abstract_declarator
+                    self.following.append(self.FOLLOW_direct_abstract_declarator_in_abstract_declarator998)
                     self.direct_abstract_declarator()
                     self.following.pop()
                     if self.failed:
@@ -3791,7 +3854,7 @@ class CParser(Parser):
 
 
     # $ANTLR start direct_abstract_declarator
-    # C.g:279:1: direct_abstract_declarator : ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )* ;
+    # C.g:283:1: direct_abstract_declarator : ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )* ;
     def direct_abstract_declarator(self, ):
 
         direct_abstract_declarator_StartIndex = self.input.index()
@@ -3800,57 +3863,57 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 32):
                     return 
 
-                # C.g:280:2: ( ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )* )
-                # C.g:280:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )*
-                # C.g:280:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )
+                # C.g:284:2: ( ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )* )
+                # C.g:284:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix ) ( abstract_declarator_suffix )*
+                # C.g:284:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )
                 alt45 = 2
                 LA45_0 = self.input.LA(1)
 
-                if (LA45_0 == 55) :
+                if (LA45_0 == 57) :
                     LA45_1 = self.input.LA(2)
 
-                    if (LA45_1 == IDENTIFIER or (29 <= LA45_1 <= 42) or (45 <= LA45_1 <= 46) or (48 <= LA45_1 <= 53) or LA45_1 == 56) :
+                    if (LA45_1 == IDENTIFIER or (29 <= LA45_1 <= 43) or (46 <= LA45_1 <= 47) or (49 <= LA45_1 <= 55) or LA45_1 == 58) :
                         alt45 = 2
-                    elif (LA45_1 == 55 or LA45_1 == 57 or LA45_1 == 59) :
+                    elif (LA45_1 == 57 or LA45_1 == 59 or LA45_1 == 61) :
                         alt45 = 1
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("280:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )", 45, 1, self.input)
+                        nvae = NoViableAltException("284:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )", 45, 1, self.input)
 
                         raise nvae
 
-                elif (LA45_0 == 57) :
+                elif (LA45_0 == 59) :
                     alt45 = 2
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("280:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )", 45, 0, self.input)
+                    nvae = NoViableAltException("284:4: ( '(' abstract_declarator ')' | abstract_declarator_suffix )", 45, 0, self.input)
 
                     raise nvae
 
                 if alt45 == 1:
-                    # C.g:280:6: '(' abstract_declarator ')'
-                    self.match(self.input, 55, self.FOLLOW_55_in_direct_abstract_declarator997)
+                    # C.g:284:6: '(' abstract_declarator ')'
+                    self.match(self.input, 57, self.FOLLOW_57_in_direct_abstract_declarator1011)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_abstract_declarator_in_direct_abstract_declarator999)
+                    self.following.append(self.FOLLOW_abstract_declarator_in_direct_abstract_declarator1013)
                     self.abstract_declarator()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_direct_abstract_declarator1001)
+                    self.match(self.input, 58, self.FOLLOW_58_in_direct_abstract_declarator1015)
                     if self.failed:
                         return 
 
 
                 elif alt45 == 2:
-                    # C.g:280:36: abstract_declarator_suffix
-                    self.following.append(self.FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1005)
+                    # C.g:284:36: abstract_declarator_suffix
+                    self.following.append(self.FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1019)
                     self.abstract_declarator_suffix()
                     self.following.pop()
                     if self.failed:
@@ -3858,209 +3921,216 @@ class CParser(Parser):
 
 
 
-                # C.g:280:65: ( abstract_declarator_suffix )*
+                # C.g:284:65: ( abstract_declarator_suffix )*
                 while True: #loop46
                     alt46 = 2
                     LA46_0 = self.input.LA(1)
 
-                    if (LA46_0 == 55) :
+                    if (LA46_0 == 57) :
                         LA46 = self.input.LA(2)
-                        if LA46 == 56:
+                        if LA46 == 58:
                             LA46_10 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 29 or LA46 == 30 or LA46 == 31 or LA46 == 32 or LA46 == 33:
                             LA46_14 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 34:
                             LA46_15 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 35:
                             LA46_16 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 36:
                             LA46_17 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 37:
                             LA46_18 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 38:
                             LA46_19 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 39:
                             LA46_20 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 40:
                             LA46_21 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 41:
                             LA46_22 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
                         elif LA46 == 42:
                             LA46_23 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 45 or LA46 == 46:
+                        elif LA46 == 43:
                             LA46_24 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 48:
+                        elif LA46 == 46 or LA46 == 47:
                             LA46_25 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == IDENTIFIER:
+                        elif LA46 == 49:
                             LA46_26 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 49 or LA46 == 50 or LA46 == 51 or LA46 == 52 or LA46 == 53:
+                        elif LA46 == IDENTIFIER:
                             LA46_27 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
+                        elif LA46 == 50 or LA46 == 51 or LA46 == 52 or LA46 == 53 or LA46 == 54 or LA46 == 55:
+                            LA46_28 = self.input.LA(3)
 
-                    elif (LA46_0 == 57) :
-                        LA46 = self.input.LA(2)
-                        if LA46 == 58:
-                            LA46_29 = self.input.LA(3)
-
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 55:
+
+                    elif (LA46_0 == 59) :
+                        LA46 = self.input.LA(2)
+                        if LA46 == 60:
                             LA46_30 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == IDENTIFIER:
+                        elif LA46 == 57:
                             LA46_31 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == HEX_LITERAL:
+                        elif LA46 == IDENTIFIER:
                             LA46_32 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == OCTAL_LITERAL:
+                        elif LA46 == HEX_LITERAL:
                             LA46_33 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == DECIMAL_LITERAL:
+                        elif LA46 == OCTAL_LITERAL:
                             LA46_34 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == CHARACTER_LITERAL:
+                        elif LA46 == DECIMAL_LITERAL:
                             LA46_35 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == STRING_LITERAL:
+                        elif LA46 == CHARACTER_LITERAL:
                             LA46_36 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == FLOATING_POINT_LITERAL:
+                        elif LA46 == STRING_LITERAL:
                             LA46_37 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 65:
+                        elif LA46 == FLOATING_POINT_LITERAL:
                             LA46_38 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 66:
+                        elif LA46 == 67:
                             LA46_39 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 59 or LA46 == 61 or LA46 == 62 or LA46 == 70 or LA46 == 71 or LA46 == 72:
+                        elif LA46 == 68:
                             LA46_40 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
-                        elif LA46 == 67:
+                        elif LA46 == 61 or LA46 == 63 or LA46 == 64 or LA46 == 72 or LA46 == 73 or LA46 == 74:
                             LA46_41 = self.input.LA(3)
 
-                            if (self.synpred78()) :
+                            if (self.synpred80()) :
+                                alt46 = 1
+
+
+                        elif LA46 == 69:
+                            LA46_42 = self.input.LA(3)
+
+                            if (self.synpred80()) :
                                 alt46 = 1
 
 
@@ -4069,7 +4139,7 @@ class CParser(Parser):
 
                     if alt46 == 1:
                         # C.g:0:0: abstract_declarator_suffix
-                        self.following.append(self.FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1009)
+                        self.following.append(self.FOLLOW_abstract_declarator_suffix_in_direct_abstract_declarator1023)
                         self.abstract_declarator_suffix()
                         self.following.pop()
                         if self.failed:
@@ -4099,7 +4169,7 @@ class CParser(Parser):
 
 
     # $ANTLR start abstract_declarator_suffix
-    # C.g:283:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );
+    # C.g:287:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );
     def abstract_declarator_suffix(self, ):
 
         abstract_declarator_suffix_StartIndex = self.input.index()
@@ -4108,39 +4178,39 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 33):
                     return 
 
-                # C.g:284:2: ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' )
+                # C.g:288:2: ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' )
                 alt47 = 4
                 LA47_0 = self.input.LA(1)
 
-                if (LA47_0 == 57) :
+                if (LA47_0 == 59) :
                     LA47_1 = self.input.LA(2)
 
-                    if (LA47_1 == 58) :
+                    if (LA47_1 == 60) :
                         alt47 = 1
-                    elif ((IDENTIFIER <= LA47_1 <= FLOATING_POINT_LITERAL) or LA47_1 == 55 or LA47_1 == 59 or (61 <= LA47_1 <= 62) or (65 <= LA47_1 <= 67) or (70 <= LA47_1 <= 72)) :
+                    elif ((IDENTIFIER <= LA47_1 <= FLOATING_POINT_LITERAL) or LA47_1 == 57 or LA47_1 == 61 or (63 <= LA47_1 <= 64) or (67 <= LA47_1 <= 69) or (72 <= LA47_1 <= 74)) :
                         alt47 = 2
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("283:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 47, 1, self.input)
+                        nvae = NoViableAltException("287:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 47, 1, self.input)
 
                         raise nvae
 
-                elif (LA47_0 == 55) :
+                elif (LA47_0 == 57) :
                     LA47_2 = self.input.LA(2)
 
-                    if (LA47_2 == 56) :
+                    if (LA47_2 == 58) :
                         alt47 = 3
-                    elif (LA47_2 == IDENTIFIER or (29 <= LA47_2 <= 42) or (45 <= LA47_2 <= 46) or (48 <= LA47_2 <= 53)) :
+                    elif (LA47_2 == IDENTIFIER or (29 <= LA47_2 <= 43) or (46 <= LA47_2 <= 47) or (49 <= LA47_2 <= 55)) :
                         alt47 = 4
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("283:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 47, 2, self.input)
+                        nvae = NoViableAltException("287:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 47, 2, self.input)
 
                         raise nvae
 
@@ -4149,56 +4219,56 @@ class CParser(Parser):
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("283:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 47, 0, self.input)
+                    nvae = NoViableAltException("287:1: abstract_declarator_suffix : ( '[' ']' | '[' constant_expression ']' | '(' ')' | '(' parameter_type_list ')' );", 47, 0, self.input)
 
                     raise nvae
 
                 if alt47 == 1:
-                    # C.g:284:4: '[' ']'
-                    self.match(self.input, 57, self.FOLLOW_57_in_abstract_declarator_suffix1021)
+                    # C.g:288:4: '[' ']'
+                    self.match(self.input, 59, self.FOLLOW_59_in_abstract_declarator_suffix1035)
                     if self.failed:
                         return 
-                    self.match(self.input, 58, self.FOLLOW_58_in_abstract_declarator_suffix1023)
+                    self.match(self.input, 60, self.FOLLOW_60_in_abstract_declarator_suffix1037)
                     if self.failed:
                         return 
 
 
                 elif alt47 == 2:
-                    # C.g:285:4: '[' constant_expression ']'
-                    self.match(self.input, 57, self.FOLLOW_57_in_abstract_declarator_suffix1028)
+                    # C.g:289:4: '[' constant_expression ']'
+                    self.match(self.input, 59, self.FOLLOW_59_in_abstract_declarator_suffix1042)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_constant_expression_in_abstract_declarator_suffix1030)
+                    self.following.append(self.FOLLOW_constant_expression_in_abstract_declarator_suffix1044)
                     self.constant_expression()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 58, self.FOLLOW_58_in_abstract_declarator_suffix1032)
+                    self.match(self.input, 60, self.FOLLOW_60_in_abstract_declarator_suffix1046)
                     if self.failed:
                         return 
 
 
                 elif alt47 == 3:
-                    # C.g:286:4: '(' ')'
-                    self.match(self.input, 55, self.FOLLOW_55_in_abstract_declarator_suffix1037)
+                    # C.g:290:4: '(' ')'
+                    self.match(self.input, 57, self.FOLLOW_57_in_abstract_declarator_suffix1051)
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_abstract_declarator_suffix1039)
+                    self.match(self.input, 58, self.FOLLOW_58_in_abstract_declarator_suffix1053)
                     if self.failed:
                         return 
 
 
                 elif alt47 == 4:
-                    # C.g:287:4: '(' parameter_type_list ')'
-                    self.match(self.input, 55, self.FOLLOW_55_in_abstract_declarator_suffix1044)
+                    # C.g:291:4: '(' parameter_type_list ')'
+                    self.match(self.input, 57, self.FOLLOW_57_in_abstract_declarator_suffix1058)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_parameter_type_list_in_abstract_declarator_suffix1046)
+                    self.following.append(self.FOLLOW_parameter_type_list_in_abstract_declarator_suffix1060)
                     self.parameter_type_list()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_abstract_declarator_suffix1048)
+                    self.match(self.input, 58, self.FOLLOW_58_in_abstract_declarator_suffix1062)
                     if self.failed:
                         return 
 
@@ -4219,7 +4289,7 @@ class CParser(Parser):
 
 
     # $ANTLR start initializer
-    # C.g:290:1: initializer : ( assignment_expression | '{' initializer_list ( ',' )? '}' );
+    # C.g:294:1: initializer : ( assignment_expression | '{' initializer_list ( ',' )? '}' );
     def initializer(self, ):
 
         initializer_StartIndex = self.input.index()
@@ -4228,26 +4298,26 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 34):
                     return 
 
-                # C.g:292:2: ( assignment_expression | '{' initializer_list ( ',' )? '}' )
+                # C.g:296:2: ( assignment_expression | '{' initializer_list ( ',' )? '}' )
                 alt49 = 2
                 LA49_0 = self.input.LA(1)
 
-                if ((IDENTIFIER <= LA49_0 <= FLOATING_POINT_LITERAL) or LA49_0 == 55 or LA49_0 == 59 or (61 <= LA49_0 <= 62) or (65 <= LA49_0 <= 67) or (70 <= LA49_0 <= 72)) :
+                if ((IDENTIFIER <= LA49_0 <= FLOATING_POINT_LITERAL) or LA49_0 == 57 or LA49_0 == 61 or (63 <= LA49_0 <= 64) or (67 <= LA49_0 <= 69) or (72 <= LA49_0 <= 74)) :
                     alt49 = 1
-                elif (LA49_0 == 43) :
+                elif (LA49_0 == 44) :
                     alt49 = 2
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("290:1: initializer : ( assignment_expression | '{' initializer_list ( ',' )? '}' );", 49, 0, self.input)
+                    nvae = NoViableAltException("294:1: initializer : ( assignment_expression | '{' initializer_list ( ',' )? '}' );", 49, 0, self.input)
 
                     raise nvae
 
                 if alt49 == 1:
-                    # C.g:292:4: assignment_expression
-                    self.following.append(self.FOLLOW_assignment_expression_in_initializer1061)
+                    # C.g:296:4: assignment_expression
+                    self.following.append(self.FOLLOW_assignment_expression_in_initializer1075)
                     self.assignment_expression()
                     self.following.pop()
                     if self.failed:
@@ -4255,16 +4325,16 @@ class CParser(Parser):
 
 
                 elif alt49 == 2:
-                    # C.g:293:4: '{' initializer_list ( ',' )? '}'
-                    self.match(self.input, 43, self.FOLLOW_43_in_initializer1066)
+                    # C.g:297:4: '{' initializer_list ( ',' )? '}'
+                    self.match(self.input, 44, self.FOLLOW_44_in_initializer1080)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_initializer_list_in_initializer1068)
+                    self.following.append(self.FOLLOW_initializer_list_in_initializer1082)
                     self.initializer_list()
                     self.following.pop()
                     if self.failed:
                         return 
-                    # C.g:293:25: ( ',' )?
+                    # C.g:297:25: ( ',' )?
                     alt48 = 2
                     LA48_0 = self.input.LA(1)
 
@@ -4272,13 +4342,13 @@ class CParser(Parser):
                         alt48 = 1
                     if alt48 == 1:
                         # C.g:0:0: ','
-                        self.match(self.input, 27, self.FOLLOW_27_in_initializer1070)
+                        self.match(self.input, 27, self.FOLLOW_27_in_initializer1084)
                         if self.failed:
                             return 
 
 
 
-                    self.match(self.input, 44, self.FOLLOW_44_in_initializer1073)
+                    self.match(self.input, 45, self.FOLLOW_45_in_initializer1087)
                     if self.failed:
                         return 
 
@@ -4299,7 +4369,7 @@ class CParser(Parser):
 
 
     # $ANTLR start initializer_list
-    # C.g:296:1: initializer_list : initializer ( ',' initializer )* ;
+    # C.g:300:1: initializer_list : initializer ( ',' initializer )* ;
     def initializer_list(self, ):
 
         initializer_list_StartIndex = self.input.index()
@@ -4308,14 +4378,14 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 35):
                     return 
 
-                # C.g:297:2: ( initializer ( ',' initializer )* )
-                # C.g:297:4: initializer ( ',' initializer )*
-                self.following.append(self.FOLLOW_initializer_in_initializer_list1084)
+                # C.g:301:2: ( initializer ( ',' initializer )* )
+                # C.g:301:4: initializer ( ',' initializer )*
+                self.following.append(self.FOLLOW_initializer_in_initializer_list1098)
                 self.initializer()
                 self.following.pop()
                 if self.failed:
                     return 
-                # C.g:297:16: ( ',' initializer )*
+                # C.g:301:16: ( ',' initializer )*
                 while True: #loop50
                     alt50 = 2
                     LA50_0 = self.input.LA(1)
@@ -4323,18 +4393,18 @@ class CParser(Parser):
                     if (LA50_0 == 27) :
                         LA50_1 = self.input.LA(2)
 
-                        if ((IDENTIFIER <= LA50_1 <= FLOATING_POINT_LITERAL) or LA50_1 == 43 or LA50_1 == 55 or LA50_1 == 59 or (61 <= LA50_1 <= 62) or (65 <= LA50_1 <= 67) or (70 <= LA50_1 <= 72)) :
+                        if ((IDENTIFIER <= LA50_1 <= FLOATING_POINT_LITERAL) or LA50_1 == 44 or LA50_1 == 57 or LA50_1 == 61 or (63 <= LA50_1 <= 64) or (67 <= LA50_1 <= 69) or (72 <= LA50_1 <= 74)) :
                             alt50 = 1
 
 
 
 
                     if alt50 == 1:
-                        # C.g:297:17: ',' initializer
-                        self.match(self.input, 27, self.FOLLOW_27_in_initializer_list1087)
+                        # C.g:301:17: ',' initializer
+                        self.match(self.input, 27, self.FOLLOW_27_in_initializer_list1101)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_initializer_in_initializer_list1089)
+                        self.following.append(self.FOLLOW_initializer_in_initializer_list1103)
                         self.initializer()
                         self.following.pop()
                         if self.failed:
@@ -4370,7 +4440,7 @@ class CParser(Parser):
 
 
     # $ANTLR start argument_expression_list
-    # C.g:302:1: argument_expression_list : assignment_expression ( ',' assignment_expression )* ;
+    # C.g:306:1: argument_expression_list : assignment_expression ( ',' assignment_expression )* ;
     def argument_expression_list(self, ):
 
         retval = self.argument_expression_list_return()
@@ -4381,14 +4451,14 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 36):
                     return retval
 
-                # C.g:303:2: ( assignment_expression ( ',' assignment_expression )* )
-                # C.g:303:6: assignment_expression ( ',' assignment_expression )*
-                self.following.append(self.FOLLOW_assignment_expression_in_argument_expression_list1107)
+                # C.g:307:2: ( assignment_expression ( ',' assignment_expression )* )
+                # C.g:307:6: assignment_expression ( ',' assignment_expression )*
+                self.following.append(self.FOLLOW_assignment_expression_in_argument_expression_list1121)
                 self.assignment_expression()
                 self.following.pop()
                 if self.failed:
                     return retval
-                # C.g:303:28: ( ',' assignment_expression )*
+                # C.g:307:28: ( ',' assignment_expression )*
                 while True: #loop51
                     alt51 = 2
                     LA51_0 = self.input.LA(1)
@@ -4398,11 +4468,11 @@ class CParser(Parser):
 
 
                     if alt51 == 1:
-                        # C.g:303:29: ',' assignment_expression
-                        self.match(self.input, 27, self.FOLLOW_27_in_argument_expression_list1110)
+                        # C.g:307:29: ',' assignment_expression
+                        self.match(self.input, 27, self.FOLLOW_27_in_argument_expression_list1124)
                         if self.failed:
                             return retval
-                        self.following.append(self.FOLLOW_assignment_expression_in_argument_expression_list1112)
+                        self.following.append(self.FOLLOW_assignment_expression_in_argument_expression_list1126)
                         self.assignment_expression()
                         self.following.pop()
                         if self.failed:
@@ -4434,7 +4504,7 @@ class CParser(Parser):
 
 
     # $ANTLR start additive_expression
-    # C.g:306:1: additive_expression : ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* ;
+    # C.g:310:1: additive_expression : ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* ;
     def additive_expression(self, ):
 
         additive_expression_StartIndex = self.input.index()
@@ -4443,11 +4513,11 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 37):
                     return 
 
-                # C.g:307:2: ( ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* )
-                # C.g:307:4: ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )*
-                # C.g:307:4: ( multiplicative_expression )
-                # C.g:307:5: multiplicative_expression
-                self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1126)
+                # C.g:311:2: ( ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )* )
+                # C.g:311:4: ( multiplicative_expression ) ( '+' multiplicative_expression | '-' multiplicative_expression )*
+                # C.g:311:4: ( multiplicative_expression )
+                # C.g:311:5: multiplicative_expression
+                self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1140)
                 self.multiplicative_expression()
                 self.following.pop()
                 if self.failed:
@@ -4455,23 +4525,23 @@ class CParser(Parser):
 
 
 
-                # C.g:307:32: ( '+' multiplicative_expression | '-' multiplicative_expression )*
+                # C.g:311:32: ( '+' multiplicative_expression | '-' multiplicative_expression )*
                 while True: #loop52
                     alt52 = 3
                     LA52_0 = self.input.LA(1)
 
-                    if (LA52_0 == 61) :
+                    if (LA52_0 == 63) :
                         alt52 = 1
-                    elif (LA52_0 == 62) :
+                    elif (LA52_0 == 64) :
                         alt52 = 2
 
 
                     if alt52 == 1:
-                        # C.g:307:33: '+' multiplicative_expression
-                        self.match(self.input, 61, self.FOLLOW_61_in_additive_expression1130)
+                        # C.g:311:33: '+' multiplicative_expression
+                        self.match(self.input, 63, self.FOLLOW_63_in_additive_expression1144)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1132)
+                        self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1146)
                         self.multiplicative_expression()
                         self.following.pop()
                         if self.failed:
@@ -4479,11 +4549,11 @@ class CParser(Parser):
 
 
                     elif alt52 == 2:
-                        # C.g:307:65: '-' multiplicative_expression
-                        self.match(self.input, 62, self.FOLLOW_62_in_additive_expression1136)
+                        # C.g:311:65: '-' multiplicative_expression
+                        self.match(self.input, 64, self.FOLLOW_64_in_additive_expression1150)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1138)
+                        self.following.append(self.FOLLOW_multiplicative_expression_in_additive_expression1152)
                         self.multiplicative_expression()
                         self.following.pop()
                         if self.failed:
@@ -4513,7 +4583,7 @@ class CParser(Parser):
 
 
     # $ANTLR start multiplicative_expression
-    # C.g:310:1: multiplicative_expression : ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* ;
+    # C.g:314:1: multiplicative_expression : ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* ;
     def multiplicative_expression(self, ):
 
         multiplicative_expression_StartIndex = self.input.index()
@@ -4522,11 +4592,11 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 38):
                     return 
 
-                # C.g:311:2: ( ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* )
-                # C.g:311:4: ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )*
-                # C.g:311:4: ( cast_expression )
-                # C.g:311:5: cast_expression
-                self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1152)
+                # C.g:315:2: ( ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )* )
+                # C.g:315:4: ( cast_expression ) ( '*' cast_expression | '/' cast_expression | '%' cast_expression )*
+                # C.g:315:4: ( cast_expression )
+                # C.g:315:5: cast_expression
+                self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1166)
                 self.cast_expression()
                 self.following.pop()
                 if self.failed:
@@ -4534,23 +4604,23 @@ class CParser(Parser):
 
 
 
-                # C.g:311:22: ( '*' cast_expression | '/' cast_expression | '%' cast_expression )*
+                # C.g:315:22: ( '*' cast_expression | '/' cast_expression | '%' cast_expression )*
                 while True: #loop53
                     alt53 = 4
                     LA53 = self.input.LA(1)
-                    if LA53 == 59:
+                    if LA53 == 61:
                         alt53 = 1
-                    elif LA53 == 63:
+                    elif LA53 == 65:
                         alt53 = 2
-                    elif LA53 == 64:
+                    elif LA53 == 66:
                         alt53 = 3
 
                     if alt53 == 1:
-                        # C.g:311:23: '*' cast_expression
-                        self.match(self.input, 59, self.FOLLOW_59_in_multiplicative_expression1156)
+                        # C.g:315:23: '*' cast_expression
+                        self.match(self.input, 61, self.FOLLOW_61_in_multiplicative_expression1170)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1158)
+                        self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1172)
                         self.cast_expression()
                         self.following.pop()
                         if self.failed:
@@ -4558,11 +4628,11 @@ class CParser(Parser):
 
 
                     elif alt53 == 2:
-                        # C.g:311:45: '/' cast_expression
-                        self.match(self.input, 63, self.FOLLOW_63_in_multiplicative_expression1162)
+                        # C.g:315:45: '/' cast_expression
+                        self.match(self.input, 65, self.FOLLOW_65_in_multiplicative_expression1176)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1164)
+                        self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1178)
                         self.cast_expression()
                         self.following.pop()
                         if self.failed:
@@ -4570,11 +4640,11 @@ class CParser(Parser):
 
 
                     elif alt53 == 3:
-                        # C.g:311:67: '%' cast_expression
-                        self.match(self.input, 64, self.FOLLOW_64_in_multiplicative_expression1168)
+                        # C.g:315:67: '%' cast_expression
+                        self.match(self.input, 66, self.FOLLOW_66_in_multiplicative_expression1182)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1170)
+                        self.following.append(self.FOLLOW_cast_expression_in_multiplicative_expression1184)
                         self.cast_expression()
                         self.following.pop()
                         if self.failed:
@@ -4604,7 +4674,7 @@ class CParser(Parser):
 
 
     # $ANTLR start cast_expression
-    # C.g:314:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );
+    # C.g:318:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );
     def cast_expression(self, ):
 
         cast_expression_StartIndex = self.input.index()
@@ -4613,16 +4683,16 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 39):
                     return 
 
-                # C.g:315:2: ( '(' type_name ')' cast_expression | unary_expression )
+                # C.g:319:2: ( '(' type_name ')' cast_expression | unary_expression )
                 alt54 = 2
                 LA54_0 = self.input.LA(1)
 
-                if (LA54_0 == 55) :
+                if (LA54_0 == 57) :
                     LA54 = self.input.LA(2)
                     if LA54 == IDENTIFIER:
                         LA54_13 = self.input.LA(3)
 
-                        if (self.synpred91()) :
+                        if (self.synpred93()) :
                             alt54 = 1
                         elif (True) :
                             alt54 = 2
@@ -4631,48 +4701,48 @@ class CParser(Parser):
                                 self.failed = True
                                 return 
 
-                            nvae = NoViableAltException("314:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 54, 13, self.input)
+                            nvae = NoViableAltException("318:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 54, 13, self.input)
 
                             raise nvae
 
-                    elif LA54 == HEX_LITERAL or LA54 == OCTAL_LITERAL or LA54 == DECIMAL_LITERAL or LA54 == CHARACTER_LITERAL or LA54 == STRING_LITERAL or LA54 == FLOATING_POINT_LITERAL or LA54 == 55 or LA54 == 59 or LA54 == 61 or LA54 == 62 or LA54 == 65 or LA54 == 66 or LA54 == 67 or LA54 == 70 or LA54 == 71 or LA54 == 72:
+                    elif LA54 == HEX_LITERAL or LA54 == OCTAL_LITERAL or LA54 == DECIMAL_LITERAL or LA54 == CHARACTER_LITERAL or LA54 == STRING_LITERAL or LA54 == FLOATING_POINT_LITERAL or LA54 == 57 or LA54 == 61 or LA54 == 63 or LA54 == 64 or LA54 == 67 or LA54 == 68 or LA54 == 69 or LA54 == 72 or LA54 == 73 or LA54 == 74:
                         alt54 = 2
-                    elif LA54 == 34 or LA54 == 35 or LA54 == 36 or LA54 == 37 or LA54 == 38 or LA54 == 39 or LA54 == 40 or LA54 == 41 or LA54 == 42 or LA54 == 45 or LA54 == 46 or LA54 == 48 or LA54 == 49 or LA54 == 50 or LA54 == 51 or LA54 == 52 or LA54 == 53:
+                    elif LA54 == 34 or LA54 == 35 or LA54 == 36 or LA54 == 37 or LA54 == 38 or LA54 == 39 or LA54 == 40 or LA54 == 41 or LA54 == 42 or LA54 == 43 or LA54 == 46 or LA54 == 47 or LA54 == 49 or LA54 == 50 or LA54 == 51 or LA54 == 52 or LA54 == 53 or LA54 == 54 or LA54 == 55:
                         alt54 = 1
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("314:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 54, 1, self.input)
+                        nvae = NoViableAltException("318:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 54, 1, self.input)
 
                         raise nvae
 
-                elif ((IDENTIFIER <= LA54_0 <= FLOATING_POINT_LITERAL) or LA54_0 == 59 or (61 <= LA54_0 <= 62) or (65 <= LA54_0 <= 67) or (70 <= LA54_0 <= 72)) :
+                elif ((IDENTIFIER <= LA54_0 <= FLOATING_POINT_LITERAL) or LA54_0 == 61 or (63 <= LA54_0 <= 64) or (67 <= LA54_0 <= 69) or (72 <= LA54_0 <= 74)) :
                     alt54 = 2
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("314:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 54, 0, self.input)
+                    nvae = NoViableAltException("318:1: cast_expression : ( '(' type_name ')' cast_expression | unary_expression );", 54, 0, self.input)
 
                     raise nvae
 
                 if alt54 == 1:
-                    # C.g:315:4: '(' type_name ')' cast_expression
-                    self.match(self.input, 55, self.FOLLOW_55_in_cast_expression1183)
+                    # C.g:319:4: '(' type_name ')' cast_expression
+                    self.match(self.input, 57, self.FOLLOW_57_in_cast_expression1197)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_type_name_in_cast_expression1185)
+                    self.following.append(self.FOLLOW_type_name_in_cast_expression1199)
                     self.type_name()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_cast_expression1187)
+                    self.match(self.input, 58, self.FOLLOW_58_in_cast_expression1201)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_cast_expression_in_cast_expression1189)
+                    self.following.append(self.FOLLOW_cast_expression_in_cast_expression1203)
                     self.cast_expression()
                     self.following.pop()
                     if self.failed:
@@ -4680,8 +4750,8 @@ class CParser(Parser):
 
 
                 elif alt54 == 2:
-                    # C.g:316:4: unary_expression
-                    self.following.append(self.FOLLOW_unary_expression_in_cast_expression1194)
+                    # C.g:320:4: unary_expression
+                    self.following.append(self.FOLLOW_unary_expression_in_cast_expression1208)
                     self.unary_expression()
                     self.following.pop()
                     if self.failed:
@@ -4704,7 +4774,7 @@ class CParser(Parser):
 
 
     # $ANTLR start unary_expression
-    # C.g:319:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );
+    # C.g:323:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );
     def unary_expression(self, ):
 
         unary_expression_StartIndex = self.input.index()
@@ -4713,24 +4783,24 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 40):
                     return 
 
-                # C.g:320:2: ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' )
+                # C.g:324:2: ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' )
                 alt55 = 6
                 LA55 = self.input.LA(1)
-                if LA55 == IDENTIFIER or LA55 == HEX_LITERAL or LA55 == OCTAL_LITERAL or LA55 == DECIMAL_LITERAL or LA55 == CHARACTER_LITERAL or LA55 == STRING_LITERAL or LA55 == FLOATING_POINT_LITERAL or LA55 == 55:
+                if LA55 == IDENTIFIER or LA55 == HEX_LITERAL or LA55 == OCTAL_LITERAL or LA55 == DECIMAL_LITERAL or LA55 == CHARACTER_LITERAL or LA55 == STRING_LITERAL or LA55 == FLOATING_POINT_LITERAL or LA55 == 57:
                     alt55 = 1
-                elif LA55 == 65:
+                elif LA55 == 67:
                     alt55 = 2
-                elif LA55 == 66:
+                elif LA55 == 68:
                     alt55 = 3
-                elif LA55 == 59 or LA55 == 61 or LA55 == 62 or LA55 == 70 or LA55 == 71 or LA55 == 72:
+                elif LA55 == 61 or LA55 == 63 or LA55 == 64 or LA55 == 72 or LA55 == 73 or LA55 == 74:
                     alt55 = 4
-                elif LA55 == 67:
+                elif LA55 == 69:
                     LA55_12 = self.input.LA(2)
 
-                    if (LA55_12 == 55) :
+                    if (LA55_12 == 57) :
                         LA55_13 = self.input.LA(3)
 
-                        if (self.synpred96()) :
+                        if (self.synpred98()) :
                             alt55 = 5
                         elif (True) :
                             alt55 = 6
@@ -4739,18 +4809,18 @@ class CParser(Parser):
                                 self.failed = True
                                 return 
 
-                            nvae = NoViableAltException("319:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 55, 13, self.input)
+                            nvae = NoViableAltException("323:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 55, 13, self.input)
 
                             raise nvae
 
-                    elif ((IDENTIFIER <= LA55_12 <= FLOATING_POINT_LITERAL) or LA55_12 == 59 or (61 <= LA55_12 <= 62) or (65 <= LA55_12 <= 67) or (70 <= LA55_12 <= 72)) :
+                    elif ((IDENTIFIER <= LA55_12 <= FLOATING_POINT_LITERAL) or LA55_12 == 61 or (63 <= LA55_12 <= 64) or (67 <= LA55_12 <= 69) or (72 <= LA55_12 <= 74)) :
                         alt55 = 5
                     else:
                         if self.backtracking > 0:
                             self.failed = True
                             return 
 
-                        nvae = NoViableAltException("319:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 55, 12, self.input)
+                        nvae = NoViableAltException("323:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 55, 12, self.input)
 
                         raise nvae
 
@@ -4759,13 +4829,13 @@ class CParser(Parser):
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("319:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 55, 0, self.input)
+                    nvae = NoViableAltException("323:1: unary_expression : ( postfix_expression | '++' unary_expression | '--' unary_expression | unary_operator cast_expression | 'sizeof' unary_expression | 'sizeof' '(' type_name ')' );", 55, 0, self.input)
 
                     raise nvae
 
                 if alt55 == 1:
-                    # C.g:320:4: postfix_expression
-                    self.following.append(self.FOLLOW_postfix_expression_in_unary_expression1205)
+                    # C.g:324:4: postfix_expression
+                    self.following.append(self.FOLLOW_postfix_expression_in_unary_expression1219)
                     self.postfix_expression()
                     self.following.pop()
                     if self.failed:
@@ -4773,11 +4843,11 @@ class CParser(Parser):
 
 
                 elif alt55 == 2:
-                    # C.g:321:4: '++' unary_expression
-                    self.match(self.input, 65, self.FOLLOW_65_in_unary_expression1210)
+                    # C.g:325:4: '++' unary_expression
+                    self.match(self.input, 67, self.FOLLOW_67_in_unary_expression1224)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_unary_expression_in_unary_expression1212)
+                    self.following.append(self.FOLLOW_unary_expression_in_unary_expression1226)
                     self.unary_expression()
                     self.following.pop()
                     if self.failed:
@@ -4785,11 +4855,11 @@ class CParser(Parser):
 
 
                 elif alt55 == 3:
-                    # C.g:322:4: '--' unary_expression
-                    self.match(self.input, 66, self.FOLLOW_66_in_unary_expression1217)
+                    # C.g:326:4: '--' unary_expression
+                    self.match(self.input, 68, self.FOLLOW_68_in_unary_expression1231)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_unary_expression_in_unary_expression1219)
+                    self.following.append(self.FOLLOW_unary_expression_in_unary_expression1233)
                     self.unary_expression()
                     self.following.pop()
                     if self.failed:
@@ -4797,13 +4867,13 @@ class CParser(Parser):
 
 
                 elif alt55 == 4:
-                    # C.g:323:4: unary_operator cast_expression
-                    self.following.append(self.FOLLOW_unary_operator_in_unary_expression1224)
+                    # C.g:327:4: unary_operator cast_expression
+                    self.following.append(self.FOLLOW_unary_operator_in_unary_expression1238)
                     self.unary_operator()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_cast_expression_in_unary_expression1226)
+                    self.following.append(self.FOLLOW_cast_expression_in_unary_expression1240)
                     self.cast_expression()
                     self.following.pop()
                     if self.failed:
@@ -4811,11 +4881,11 @@ class CParser(Parser):
 
 
                 elif alt55 == 5:
-                    # C.g:324:4: 'sizeof' unary_expression
-                    self.match(self.input, 67, self.FOLLOW_67_in_unary_expression1231)
+                    # C.g:328:4: 'sizeof' unary_expression
+                    self.match(self.input, 69, self.FOLLOW_69_in_unary_expression1245)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_unary_expression_in_unary_expression1233)
+                    self.following.append(self.FOLLOW_unary_expression_in_unary_expression1247)
                     self.unary_expression()
                     self.following.pop()
                     if self.failed:
@@ -4823,19 +4893,19 @@ class CParser(Parser):
 
 
                 elif alt55 == 6:
-                    # C.g:325:4: 'sizeof' '(' type_name ')'
-                    self.match(self.input, 67, self.FOLLOW_67_in_unary_expression1238)
+                    # C.g:329:4: 'sizeof' '(' type_name ')'
+                    self.match(self.input, 69, self.FOLLOW_69_in_unary_expression1252)
                     if self.failed:
                         return 
-                    self.match(self.input, 55, self.FOLLOW_55_in_unary_expression1240)
+                    self.match(self.input, 57, self.FOLLOW_57_in_unary_expression1254)
                     if self.failed:
                         return 
-                    self.following.append(self.FOLLOW_type_name_in_unary_expression1242)
+                    self.following.append(self.FOLLOW_type_name_in_unary_expression1256)
                     self.type_name()
                     self.following.pop()
                     if self.failed:
                         return 
-                    self.match(self.input, 56, self.FOLLOW_56_in_unary_expression1244)
+                    self.match(self.input, 58, self.FOLLOW_58_in_unary_expression1258)
                     if self.failed:
                         return 
 
@@ -4856,7 +4926,7 @@ class CParser(Parser):
 
 
     # $ANTLR start postfix_expression
-    # C.g:328:1: postfix_expression : p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )* ;
+    # C.g:332:1: postfix_expression : p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )* ;
     def postfix_expression(self, ):
 
         postfix_expression_StartIndex = self.input.index()
@@ -4872,71 +4942,71 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 41):
                     return 
 
-                # C.g:329:2: (p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )* )
-                # C.g:329:6: p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )*
-                self.following.append(self.FOLLOW_primary_expression_in_postfix_expression1259)
+                # C.g:333:2: (p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )* )
+                # C.g:333:6: p= primary_expression ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )*
+                self.following.append(self.FOLLOW_primary_expression_in_postfix_expression1273)
                 p = self.primary_expression()
                 self.following.pop()
                 if self.failed:
                     return 
-                # C.g:330:9: ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )*
+                # C.g:334:9: ( '[' expression ']' | '(' a= ')' | '(' c= argument_expression_list b= ')' | '.' IDENTIFIER | '*' IDENTIFIER | '->' IDENTIFIER | '++' | '--' )*
                 while True: #loop56
                     alt56 = 9
                     LA56 = self.input.LA(1)
-                    if LA56 == 59:
+                    if LA56 == 61:
                         LA56_1 = self.input.LA(2)
 
                         if (LA56_1 == IDENTIFIER) :
                             LA56_29 = self.input.LA(3)
 
-                            if (self.synpred101()) :
+                            if (self.synpred103()) :
                                 alt56 = 5
 
 
 
 
-                    elif LA56 == 57:
+                    elif LA56 == 59:
                         alt56 = 1
-                    elif LA56 == 55:
+                    elif LA56 == 57:
                         LA56_24 = self.input.LA(2)
 
-                        if (LA56_24 == 56) :
+                        if (LA56_24 == 58) :
                             alt56 = 2
-                        elif ((IDENTIFIER <= LA56_24 <= FLOATING_POINT_LITERAL) or LA56_24 == 55 or LA56_24 == 59 or (61 <= LA56_24 <= 62) or (65 <= LA56_24 <= 67) or (70 <= LA56_24 <= 72)) :
+                        elif ((IDENTIFIER <= LA56_24 <= FLOATING_POINT_LITERAL) or LA56_24 == 57 or LA56_24 == 61 or (63 <= LA56_24 <= 64) or (67 <= LA56_24 <= 69) or (72 <= LA56_24 <= 74)) :
                             alt56 = 3
 
 
-                    elif LA56 == 68:
+                    elif LA56 == 70:
                         alt56 = 4
-                    elif LA56 == 69:
+                    elif LA56 == 71:
                         alt56 = 6
-                    elif LA56 == 65:
+                    elif LA56 == 67:
                         alt56 = 7
-                    elif LA56 == 66:
+                    elif LA56 == 68:
                         alt56 = 8
 
                     if alt56 == 1:
-                        # C.g:330:13: '[' expression ']'
-                        self.match(self.input, 57, self.FOLLOW_57_in_postfix_expression1273)
+                        # C.g:334:13: '[' expression ']'
+                        self.match(self.input, 59, self.FOLLOW_59_in_postfix_expression1287)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_expression_in_postfix_expression1275)
+                        self.following.append(self.FOLLOW_expression_in_postfix_expression1289)
                         self.expression()
                         self.following.pop()
                         if self.failed:
                             return 
-                        self.match(self.input, 58, self.FOLLOW_58_in_postfix_expression1277)
+                        self.match(self.input, 60, self.FOLLOW_60_in_postfix_expression1291)
                         if self.failed:
                             return 
 
 
                     elif alt56 == 2:
-                        # C.g:331:13: '(' a= ')'
-                        self.match(self.input, 55, self.FOLLOW_55_in_postfix_expression1291)
+                        # C.g:335:13: '(' a= ')'
+                        self.match(self.input, 57, self.FOLLOW_57_in_postfix_expression1305)
                         if self.failed:
                             return 
                         a = self.input.LT(1)
-                        self.match(self.input, 56, self.FOLLOW_56_in_postfix_expression1295)
+                        self.match(self.input, 58, self.FOLLOW_58_in_postfix_expression1309)
                         if self.failed:
                             return 
                         if self.backtracking == 0:
@@ -4945,17 +5015,17 @@ class CParser(Parser):
 
 
                     elif alt56 == 3:
-                        # C.g:332:13: '(' c= argument_expression_list b= ')'
-                        self.match(self.input, 55, self.FOLLOW_55_in_postfix_expression1310)
+                        # C.g:336:13: '(' c= argument_expression_list b= ')'
+                        self.match(self.input, 57, self.FOLLOW_57_in_postfix_expression1324)
                         if self.failed:
                             return 
-                        self.following.append(self.FOLLOW_argument_expression_list_in_postfix_expression1314)
+                        self.following.append(self.FOLLOW_argument_expression_list_in_postfix_expression1328)
                         c = self.argument_expression_list()
                         self.following.pop()
                         if self.failed:
                             return 
                         b = self.input.LT(1)
-                        self.match(self.input, 56, self.FOLLOW_56_in_postfix_expression1318)
+                        self.match(self.input, 58, self.FOLLOW_58_in_postfix_expression1332)
                         if self.failed:
                             return 
                         if self.backtracking == 0:
@@ -4964,45 +5034,45 @@ class CParser(Parser):
 
 
                     elif alt56 == 4:
-                        # C.g:333:13: '.' IDENTIFIER
-                        self.match(self.input, 68, self.FOLLOW_68_in_postfix_expression1334)
+                        # C.g:337:13: '.' IDENTIFIER
+                        self.match(self.input, 70, self.FOLLOW_70_in_postfix_expression1348)
                         if self.failed:
                             return 
-                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1336)
+                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1350)
                         if self.failed:
                             return 
 
 
                     elif alt56 == 5:
-                        # C.g:334:13: '*' IDENTIFIER
-                        self.match(self.input, 59, self.FOLLOW_59_in_postfix_expression1350)
+                        # C.g:338:13: '*' IDENTIFIER
+                        self.match(self.input, 61, self.FOLLOW_61_in_postfix_expression1364)
                         if self.failed:
                             return 
-                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1352)
+                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1366)
                         if self.failed:
                             return 
 
 
                     elif alt56 == 6:
-                        # C.g:335:13: '->' IDENTIFIER
-                        self.match(self.input, 69, self.FOLLOW_69_in_postfix_expression1366)
+                        # C.g:339:13: '->' IDENTIFIER
+                        self.match(self.input, 71, self.FOLLOW_71_in_postfix_expression1380)
                         if self.failed:
                             return 
-                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1368)
+                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_postfix_expression1382)
                         if self.failed:
                             return 
 
 
                     elif alt56 == 7:
-                        # C.g:336:13: '++'
-                        self.match(self.input, 65, self.FOLLOW_65_in_postfix_expression1382)
+                        # C.g:340:13: '++'
+                        self.match(self.input, 67, self.FOLLOW_67_in_postfix_expression1396)
                         if self.failed:
                             return 
 
 
                     elif alt56 == 8:
-                        # C.g:337:13: '--'
-                        self.match(self.input, 66, self.FOLLOW_66_in_postfix_expression1396)
+                        # C.g:341:13: '--'
+                        self.match(self.input, 68, self.FOLLOW_68_in_postfix_expression1410)
                         if self.failed:
                             return 
 
@@ -5030,7 +5100,7 @@ class CParser(Parser):
 
 
     # $ANTLR start unary_operator
-    # C.g:341:1: unary_operator : ( '&' | '*' | '+' | '-' | '~' | '!' );
+    # C.g:345:1: unary_operator : ( '&' | '*' | '+' | '-' | '~' | '!' );
     def unary_operator(self, ):
 
         unary_operator_StartIndex = self.input.index()
@@ -5039,9 +5109,9 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 42):
                     return 
 
-                # C.g:342:2: ( '&' | '*' | '+' | '-' | '~' | '!' )
+                # C.g:346:2: ( '&' | '*' | '+' | '-' | '~' | '!' )
                 # C.g:
-                if self.input.LA(1) == 59 or (61 <= self.input.LA(1) <= 62) or (70 <= self.input.LA(1) <= 72):
+                if self.input.LA(1) == 61 or (63 <= self.input.LA(1) <= 64) or (72 <= self.input.LA(1) <= 74):
                     self.input.consume();
                     self.errorRecovery = False
                     self.failed = False
@@ -5083,7 +5153,7 @@ class CParser(Parser):
 
 
     # $ANTLR start primary_expression
-    # C.g:350:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );
+    # C.g:354:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );
     def primary_expression(self, ):
 
         retval = self.primary_expression_return()
@@ -5094,34 +5164,34 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 43):
                     return retval
 
-                # C.g:351:2: ( IDENTIFIER | constant | '(' expression ')' )
+                # C.g:355:2: ( IDENTIFIER | constant | '(' expression ')' )
                 alt57 = 3
                 LA57 = self.input.LA(1)
                 if LA57 == IDENTIFIER:
                     alt57 = 1
                 elif LA57 == HEX_LITERAL or LA57 == OCTAL_LITERAL or LA57 == DECIMAL_LITERAL or LA57 == CHARACTER_LITERAL or LA57 == STRING_LITERAL or LA57 == FLOATING_POINT_LITERAL:
                     alt57 = 2
-                elif LA57 == 55:
+                elif LA57 == 57:
                     alt57 = 3
                 else:
                     if self.backtracking > 0:
                         self.failed = True
                         return retval
 
-                    nvae = NoViableAltException("350:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );", 57, 0, self.input)
+                    nvae = NoViableAltException("354:1: primary_expression : ( IDENTIFIER | constant | '(' expression ')' );", 57, 0, self.input)
 
                     raise nvae
 
                 if alt57 == 1:
-                    # C.g:351:4: IDENTIFIER
-                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_primary_expression1454)
+                    # C.g:355:4: IDENTIFIER
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_primary_expression1468)
                     if self.failed:
                         return retval
 
 
                 elif alt57 == 2:
-                    # C.g:352:4: constant
-                    self.following.append(self.FOLLOW_constant_in_primary_expression1459)
+                    # C.g:356:4: constant
+                    self.following.append(self.FOLLOW_constant_in_primary_expression1473)
                     self.constant()
                     self.following.pop()
                     if self.failed:
@@ -5129,16 +5199,16 @@ class CParser(Parser):
 
 
                 elif alt57 == 3:
-                    # C.g:353:4: '(' expression ')'
-                    self.match(self.input, 55, self.FOLLOW_55_in_primary_expression1464)
+                    # C.g:357:4: '(' expression ')'
+                    self.match(self.input, 57, self.FOLLOW_57_in_primary_expression1478)
                     if self.failed:
                         return retval
-                    self.following.append(self.FOLLOW_expression_in_primary_expression1466)
+                    self.following.append(self.FOLLOW_expression_in_primary_expression1480)
                     self.expression()
                     self.following.pop()
                     if self.failed:
                         return retval
-                    self.match(self.input, 56, self.FOLLOW_56_in_primary_expression1468)
+                    self.match(self.input, 58, self.FOLLOW_58_in_primary_expression1482)
                     if self.failed:
                         return retval
 
@@ -5161,7 +5231,7 @@ class CParser(Parser):
 
 
     # $ANTLR start constant
-    # C.g:356:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( STRING_LITERAL )+ | FLOATING_POINT_LITERAL );
+    # C.g:360:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( STRING_LITERAL )+ | FLOATING_POINT_LITERAL );
     def constant(self, ):
 
         constant_StartIndex = self.input.index()
@@ -5170,7 +5240,7 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 44):
                     return 
 
-                # C.g:357:5: ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( STRING_LITERAL )+ | FLOATING_POINT_LITERAL )
+                # C.g:361:5: ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( STRING_LITERAL )+ | FLOATING_POINT_LITERAL )
                 alt59 = 6
                 LA59 = self.input.LA(1)
                 if LA59 == HEX_LITERAL:
@@ -5190,41 +5260,41 @@ class CParser(Parser):
                         self.failed = True
                         return 
 
-                    nvae = NoViableAltException("356:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( STRING_LITERAL )+ | FLOATING_POINT_LITERAL );", 59, 0, self.input)
+                    nvae = NoViableAltException("360:1: constant : ( HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL | CHARACTER_LITERAL | ( STRING_LITERAL )+ | FLOATING_POINT_LITERAL );", 59, 0, self.input)
 
                     raise nvae
 
                 if alt59 == 1:
-                    # C.g:357:9: HEX_LITERAL
-                    self.match(self.input, HEX_LITERAL, self.FOLLOW_HEX_LITERAL_in_constant1484)
+                    # C.g:361:9: HEX_LITERAL
+                    self.match(self.input, HEX_LITERAL, self.FOLLOW_HEX_LITERAL_in_constant1498)
                     if self.failed:
                         return 
 
 
                 elif alt59 == 2:
-                    # C.g:358:9: OCTAL_LITERAL
-                    self.match(self.input, OCTAL_LITERAL, self.FOLLOW_OCTAL_LITERAL_in_constant1494)
+                    # C.g:362:9: OCTAL_LITERAL
+                    self.match(self.input, OCTAL_LITERAL, self.FOLLOW_OCTAL_LITERAL_in_constant1508)
                     if self.failed:
                         return 
 
 
                 elif alt59 == 3:
-                    # C.g:359:9: DECIMAL_LITERAL
-                    self.match(self.input, DECIMAL_LITERAL, self.FOLLOW_DECIMAL_LITERAL_in_constant1504)
+                    # C.g:363:9: DECIMAL_LITERAL
+                    self.match(self.input, DECIMAL_LITERAL, self.FOLLOW_DECIMAL_LITERAL_in_constant1518)
                     if self.failed:
                         return 
 
 
                 elif alt59 == 4:
-                    # C.g:360:7: CHARACTER_LITERAL
-                    self.match(self.input, CHARACTER_LITERAL, self.FOLLOW_CHARACTER_LITERAL_in_constant1512)
+                    # C.g:364:7: CHARACTER_LITERAL
+                    self.match(self.input, CHARACTER_LITERAL, self.FOLLOW_CHARACTER_LITERAL_in_constant1526)
                     if self.failed:
                         return 
 
 
                 elif alt59 == 5:
-                    # C.g:361:7: ( STRING_LITERAL )+
-                    # C.g:361:7: ( STRING_LITERAL )+
+                    # C.g:365:7: ( STRING_LITERAL )+
+                    # C.g:365:7: ( STRING_LITERAL )+
                     cnt58 = 0
                     while True: #loop58
                         alt58 = 2
@@ -5236,7 +5306,7 @@ class CParser(Parser):
 
                         if alt58 == 1:
                             # C.g:0:0: STRING_LITERAL
-                            self.match(self.input, STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_constant1520)
+                            self.match(self.input, STRING_LITERAL, self.FOLLOW_STRING_LITERAL_in_constant1534)
                             if self.failed:
                                 return 
 
@@ -5258,8 +5328,8 @@ class CParser(Parser):
 
 
                 elif alt59 == 6:
-                    # C.g:362:9: FLOATING_POINT_LITERAL
-                    self.match(self.input, FLOATING_POINT_LITERAL, self.FOLLOW_FLOATING_POINT_LITERAL_in_constant1531)
+                    # C.g:366:9: FLOATING_POINT_LITERAL
+                    self.match(self.input, FLOATING_POINT_LITERAL, self.FOLLOW_FLOATING_POINT_LITERAL_in_constant1545)
                     if self.failed:
                         return 
 
@@ -5286,7 +5356,7 @@ class CParser(Parser):
 
 
     # $ANTLR start expression
-    # C.g:367:1: expression : assignment_expression ( ',' assignment_expression )* ;
+    # C.g:371:1: expression : assignment_expression ( ',' assignment_expression )* ;
     def expression(self, ):
 
         retval = self.expression_return()
@@ -5297,14 +5367,14 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 45):
                     return retval
 
-                # C.g:368:2: ( assignment_expression ( ',' assignment_expression )* )
-                # C.g:368:4: assignment_expression ( ',' assignment_expression )*
-                self.following.append(self.FOLLOW_assignment_expression_in_expression1547)
+                # C.g:372:2: ( assignment_expression ( ',' assignment_expression )* )
+                # C.g:372:4: assignment_expression ( ',' assignment_expression )*
+                self.following.append(self.FOLLOW_assignment_expression_in_expression1561)
                 self.assignment_expression()
                 self.following.pop()
                 if self.failed:
                     return retval
-                # C.g:368:26: ( ',' assignment_expression )*
+                # C.g:372:26: ( ',' assignment_expression )*
                 while True: #loop60
                     alt60 = 2
                     LA60_0 = self.input.LA(1)
@@ -5314,11 +5384,11 @@ class CParser(Parser):
 
 
                     if alt60 == 1:
-                        # C.g:368:27: ',' assignment_expression
-                        self.match(self.input, 27, self.FOLLOW_27_in_expression1550)
+                        # C.g:372:27: ',' assignment_expression
+                        self.match(self.input, 27, self.FOLLOW_27_in_expression1564)
                         if self.failed:
                             return retval
-                        self.following.append(self.FOLLOW_assignment_expression_in_expression1552)
+                        self.following.append(self.FOLLOW_assignment_expression_in_expression1566)
                         self.assignment_expression()
                         self.following.pop()
                         if self.failed:
@@ -5350,7 +5420,7 @@ class CParser(Parser):
 
 
     # $ANTLR start constant_expression
-    # C.g:371:1: constant_expression : conditional_expression ;
+    # C.g:375:1: constant_expression : conditional_expression ;
     def constant_expression(self, ):
 
         constant_expression_StartIndex = self.input.index()
@@ -5359,9 +5429,9 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 46):
                     return 
 
-                # C.g:372:2: ( conditional_expression )
-                # C.g:372:4: conditional_expression
-                self.following.append(self.FOLLOW_conditional_expression_in_constant_expression1565)
+                # C.g:376:2: ( conditional_expression )
+                # C.g:376:4: conditional_expression
+                self.following.append(self.FOLLOW_conditional_expression_in_constant_expression1579)
                 self.conditional_expression()
                 self.following.pop()
                 if self.failed:
@@ -5385,7 +5455,7 @@ class CParser(Parser):
 
 
     # $ANTLR start assignment_expression
-    # C.g:375:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );
+    # C.g:379:1: assignment_expression : ( lvalue assignment_operator assignment_expression | conditional_expression );
     def assignment_expression(self, ):
 
         assignment_expression_StartIndex = self.input.index()
@@ -5394,15 +5464,15 @@ class CParser(Parser):
                 if self.backtracking > 0 and self.alreadyParsedRule(self.input, 47):
                     return 
 
-                # C.g:376:2: ( lvalue assignment_operator assignment_expression | conditional_expression )
+                # C.g:380:2: ( lvalue assignment_operator assignment_expression | conditional_expression )