PageRenderTime 74ms CodeModel.GetById 37ms RepoModel.GetById 0ms app.codeStats 1ms

/opensource.apple.com/source/libstdcxx_SUPanWheat/libstdcxx_SUPanWheat-16/libstdcxx/gcc/c-parse.y

#
Happy | 2080 lines | 1851 code | 229 blank | 0 comment | 0 complexity | 1919cf4ca55745d10137e941199b7176 MD5 | raw file
Possible License(s): GPL-2.0, AGPL-1.0, AGPL-3.0, CC-BY-SA-3.0, MPL-2.0-no-copyleft-exception, MPL-2.0, JSON, 0BSD, LGPL-2.1, Apache-2.0, BSD-3-Clause, ISC, LGPL-2.0, WTFPL, MIT

Large files files are truncated, but you can click here to view the full file

    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    2. 

  2.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    3. 

  3. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    4. 

  4. <head>
    5. 

  5. <title>c-parse.y</title>
    6. 

  6. <style type="text/css">
    7. 

  7. .enscript-comment { font-style: italic; color: rgb(178,34,34); }
    8. 

  8. .enscript-function-name { font-weight: bold; color: rgb(0,0,255); }
    9. 

  9. .enscript-variable-name { font-weight: bold; color: rgb(184,134,11); }
    10. 

  10. .enscript-keyword { font-weight: bold; color: rgb(160,32,240); }
    11. 

  11. .enscript-reference { font-weight: bold; color: rgb(95,158,160); }
    12. 

  12. .enscript-string { font-weight: bold; color: rgb(188,143,143); }
    13. 

  13. .enscript-builtin { font-weight: bold; color: rgb(218,112,214); }
    14. 

  14. .enscript-type { font-weight: bold; color: rgb(34,139,34); }
    15. 

  15. .enscript-highlight { text-decoration: underline; color: 0; }
    16. 

  16. </style>
    17. 

  17. </head>
    18. 

  18. <body id="top">
    19. 

  19. <h1 style="margin:8px;" id="f1">c-parse.y&nbsp;&nbsp;&nbsp;<span style="font-weight: normal; font-size: 0.5em;">[<a href="?txt">plain text</a>]</span></h1>
    20. 

  20. <hr/>
    21. 

  21. <div></div>
    22. 

  22. <pre>
    23. 

  23. /*WARNING: This file is automatically generated!*/
    24. 

  24. /* YACC parser for C syntax and for Objective C.  -*-c-*-
    25. 

  25.    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
    26. 

  26.    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    27. 

    28. 

  28. This file is part of GCC.
    29. 

    30. 

  30. GCC is free software; you can redistribute it and/or modify it under
    31. 

  31. the terms of the GNU General Public License as published by the Free
    32. 

  32. Software Foundation; either version 2, or (at your option) any later
    33. 

  33. version.
    34. 

    35. 

  35. GCC is distributed in the hope that it will be useful, but WITHOUT ANY
    36. 

  36. WARRANTY; without even the implied warranty of MERCHANTABILITY or
    37. 

  37. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    38. 

  38. for more details.
    39. 

    40. 

  40. You should have received a copy of the GNU General Public License
    41. 

  41. along with GCC; see the file COPYING.  If not, write to the Free
    42. 

  42. Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    43. 

  43. 02111-1307, USA.  */
    44. 

  44. 

  45. /* This file defines the grammar of C and that of Objective C.
    46. 

  46.    @@ifobjc ... @@end_ifobjc  conditionals contain code for Objective C only.
    47. 

  47.    @@ifc ... @@end_ifc  conditionals contain code for C only.
    48. 

  48.    Sed commands in Makefile.in are used to convert this file into
    49. 

  49.    c-parse.y and into objc-parse.y.  */
    50. 

  50. 

  51. /* To whomever it may concern: I have heard that such a thing was once
    52. 

  52.    written by AT&amp;T, but I have never seen it.  */
    53. 

  53. 

  54. %expect 13 /* shift/reduce conflicts, and no reduce/reduce conflicts.  */
    55. 

  55. 

  56. %{
    57. 

  57. #include &quot;config.h&quot;
    58. 

  58. #include &quot;system.h&quot;
    59. 

  59. #include &quot;coretypes.h&quot;
    60. 

  60. #include &quot;tm.h&quot;
    61. 

  61. #include &quot;tree.h&quot;
    62. 

  62. #include &quot;langhooks.h&quot;
    63. 

  63. #include &quot;input.h&quot;
    64. 

  64. #include &quot;cpplib.h&quot;
    65. 

  65. #include &quot;intl.h&quot;
    66. 

  66. #include &quot;timevar.h&quot;
    67. 

  67. #include &quot;c-pragma.h&quot;		/* For YYDEBUG definition, and parse_in.  */
    68. 

  68. #include &quot;c-tree.h&quot;
    69. 

  69. #include &quot;flags.h&quot;
    70. 

  70. #include &quot;varray.h&quot;
    71. 

  71. #include &quot;output.h&quot;
    72. 

  72. #include &quot;toplev.h&quot;
    73. 

  73. #include &quot;ggc.h&quot;
    74. 

  74. #include &quot;c-common.h&quot;
    75. 

  75. 

  76. #define YYERROR1 { yyerror (&quot;syntax error&quot;); YYERROR; }
    77. 

  77. 

  78. /* Like the default stack expander, except (1) use realloc when possible,
    79. 

  79.    (2) impose no hard maxiumum on stack size, (3) REALLY do not use alloca.
    80. 

    81. 

  81.    Irritatingly, YYSTYPE is defined after this %{ %} block, so we cannot
    82. 

  82.    give malloced_yyvs its proper type.  This is ok since all we need from
    83. 

  83.    it is to be able to free it.  */
    84. 

  84. 

  85. static short *malloced_yyss;
    86. 

  86. static void *malloced_yyvs;
    87. 

  87. 

  88. #define yyoverflow(MSG, SS, SSSIZE, VS, VSSIZE, YYSSZ)			\
    89. 

  89. do {									\
    90. 

  90.   size_t newsize;							\
    91. 

  91.   short *newss;								\
    92. 

  92.   YYSTYPE *newvs;							\
    93. 

  93.   newsize = *(YYSSZ) *= 2;						\
    94. 

  94.   if (malloced_yyss)							\
    95. 

  95.     {									\
    96. 

  96.       newss = really_call_realloc (*(SS), newsize * sizeof (short));	\
    97. 

  97.       newvs = really_call_realloc (*(VS), newsize * sizeof (YYSTYPE));	\
    98. 

  98.     }									\
    99. 

  99.   else									\
    100. 

  100.     {									\
    101. 

  101.       newss = really_call_malloc (newsize * sizeof (short));		\
    102. 

  102.       newvs = really_call_malloc (newsize * sizeof (YYSTYPE));		\
    103. 

  103.       if (newss)							\
    104. 

  104.         memcpy (newss, *(SS), (SSSIZE));				\
    105. 

  105.       if (newvs)							\
    106. 

  106.         memcpy (newvs, *(VS), (VSSIZE));				\
    107. 

  107.     }									\
    108. 

  108.   if (!newss || !newvs)							\
    109. 

  109.     {									\
    110. 

  110.       yyerror (MSG);							\
    111. 

  111.       return 2;								\
    112. 

  112.     }									\
    113. 

  113.   *(SS) = newss;							\
    114. 

  114.   *(VS) = newvs;							\
    115. 

  115.   malloced_yyss = newss;						\
    116. 

  116.   malloced_yyvs = (void *) newvs;					\
    117. 

  117. } while (0)
    118. 

  118. %}
    119. 

  119. 

  120. %start program
    121. 

  121. 

  122. %union {long itype; tree ttype; void *otype; struct c_expr exprtype;
    123. 

  123. 	struct c_arg_info *arginfotype; struct c_declarator *dtrtype;
    124. 

  124. 	struct c_type_name *typenametype; struct c_parm *parmtype;
    125. 

  125. 	struct c_declspecs *dsptype; struct c_typespec tstype;
    126. 

  126. 	enum tree_code code; location_t location; }
    127. 

  127. 

  128. /* All identifiers that are not reserved words
    129. 

  129.    and are not declared typedefs in the current block */
    130. 

  130. %token IDENTIFIER
    131. 

  131. 

  132. /* All identifiers that are declared typedefs in the current block.
    133. 

  133.    In some contexts, they are treated just like IDENTIFIER,
    134. 

  134.    but they can also serve as typespecs in declarations.  */
    135. 

  135. %token TYPENAME
    136. 

  136. 

  137. /* Reserved words that specify storage class.
    138. 

  138.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
    139. 

  139. %token SCSPEC			/* Storage class other than static.  */
    140. 

  140. %token STATIC			/* Static storage class.  */
    141. 

  141. 

  142. /* Reserved words that specify type.
    143. 

  143.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
    144. 

  144. %token TYPESPEC
    145. 

  145. 

  146. /* Reserved words that qualify type: &quot;const&quot;, &quot;volatile&quot;, or &quot;restrict&quot;.
    147. 

  147.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
    148. 

  148. %token TYPE_QUAL
    149. 

  149. 

  150. /* Objective-C protocol qualifiers.  These acquire their magic powers
    151. 

  151.    only in certain contexts.  */
    152. 

  152. %token OBJC_TYPE_QUAL
    153. 

  153. 

  154. /* Character or numeric constants.
    155. 

  155.    yylval is the node for the constant.  */
    156. 

  156. %token CONSTANT
    157. 

  157. 

  158. /* String constants in raw form.
    159. 

  159.    yylval is a STRING_CST node.  */
    160. 

  160. 

  161. %token STRING
    162. 

  162. 

  163. /* &quot;...&quot;, used for functions with variable arglists.  */
    164. 

  164. %token ELLIPSIS
    165. 

  165. 

  166. /* the reserved words */
    167. 

  167. /* SCO include files test &quot;ASM&quot;, so use something else. */
    168. 

  168. %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
    169. 

  169. %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF
    170. 

  170. %token ATTRIBUTE EXTENSION LABEL
    171. 

  171. %token REALPART IMAGPART VA_ARG CHOOSE_EXPR TYPES_COMPATIBLE_P
    172. 

  172. %token FUNC_NAME OFFSETOF
    173. 

  173. 

  174. /* Add precedence rules to solve dangling else s/r conflict */
    175. 

  175. %nonassoc IF
    176. 

  176. %nonassoc ELSE
    177. 

  177. 

  178. /* Define the operator tokens and their precedences.
    179. 

  179.    The value is an integer because, if used, it is the tree code
    180. 

  180.    to use in the expression made from the operator.  */
    181. 

  181. 

  182. %right &lt;code&gt; ASSIGN '='
    183. 

  183. %right &lt;code&gt; '?' ':'
    184. 

  184. %left &lt;code&gt; OROR
    185. 

  185. %left &lt;code&gt; ANDAND
    186. 

  186. %left &lt;code&gt; '|'
    187. 

  187. %left &lt;code&gt; '^'
    188. 

  188. %left &lt;code&gt; '&amp;'
    189. 

  189. %left &lt;code&gt; EQCOMPARE
    190. 

  190. %left &lt;code&gt; ARITHCOMPARE
    191. 

  191. %left &lt;code&gt; LSHIFT RSHIFT
    192. 

  192. %left &lt;code&gt; '+' '-'
    193. 

  193. %left &lt;code&gt; '*' '/' '%'
    194. 

  194. %right &lt;code&gt; UNARY PLUSPLUS MINUSMINUS
    195. 

  195. %left HYPERUNARY
    196. 

  196. %left &lt;code&gt; POINTSAT '.' '(' '['
    197. 

  197. 

  198. /* The Objective-C keywords.  These are included in C and in
    199. 

  199.    Objective C, so that the token codes are the same in both.  */
    200. 

  200. %token AT_INTERFACE AT_IMPLEMENTATION AT_END AT_SELECTOR AT_DEFS AT_ENCODE
    201. 

  201. %token CLASSNAME AT_PUBLIC AT_PRIVATE AT_PROTECTED AT_PROTOCOL
    202. 

  202. %token AT_CLASS AT_ALIAS
    203. 

  203. %token AT_THROW AT_TRY AT_CATCH AT_FINALLY AT_SYNCHRONIZED
    204. 

  204. %token OBJC_STRING
    205. 

  205. 

  206. %type &lt;code&gt; unop
    207. 

  207. %type &lt;ttype&gt; ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
    208. 

  208. %type &lt;ttype&gt; BREAK CONTINUE RETURN GOTO ASM_KEYWORD SIZEOF TYPEOF ALIGNOF
    209. 

  209. 

  210. %type &lt;ttype&gt; identifier IDENTIFIER TYPENAME CONSTANT STRING FUNC_NAME
    211. 

  211. %type &lt;ttype&gt; nonnull_exprlist exprlist
    212. 

  212. %type &lt;exprtype&gt; expr expr_no_commas cast_expr unary_expr primary
    213. 

  213. %type &lt;dsptype&gt; declspecs_nosc_nots_nosa_noea declspecs_nosc_nots_nosa_ea
    214. 

  214. %type &lt;dsptype&gt; declspecs_nosc_nots_sa_noea declspecs_nosc_nots_sa_ea
    215. 

  215. %type &lt;dsptype&gt; declspecs_nosc_ts_nosa_noea declspecs_nosc_ts_nosa_ea
    216. 

  216. %type &lt;dsptype&gt; declspecs_nosc_ts_sa_noea declspecs_nosc_ts_sa_ea
    217. 

  217. %type &lt;dsptype&gt; declspecs_sc_nots_nosa_noea declspecs_sc_nots_nosa_ea
    218. 

  218. %type &lt;dsptype&gt; declspecs_sc_nots_sa_noea declspecs_sc_nots_sa_ea
    219. 

  219. %type &lt;dsptype&gt; declspecs_sc_ts_nosa_noea declspecs_sc_ts_nosa_ea
    220. 

  220. %type &lt;dsptype&gt; declspecs_sc_ts_sa_noea declspecs_sc_ts_sa_ea
    221. 

  221. %type &lt;dsptype&gt; declspecs_ts declspecs_nots
    222. 

  222. %type &lt;dsptype&gt; declspecs_ts_nosa declspecs_nots_nosa
    223. 

  223. %type &lt;dsptype&gt; declspecs_nosc_ts declspecs_nosc_nots declspecs_nosc declspecs
    224. 

  224. %type &lt;dsptype&gt; maybe_type_quals_attrs
    225. 

  225. %type &lt;tstype&gt; typespec_nonattr typespec_attr
    226. 

  226. %type &lt;tstype&gt; typespec_reserved_nonattr typespec_reserved_attr
    227. 

  227. %type &lt;tstype&gt; typespec_nonreserved_nonattr
    228. 

  228. %type &lt;ttype&gt; offsetof_member_designator
    229. 

  229. 

  230. %type &lt;ttype&gt; scspec SCSPEC STATIC TYPESPEC TYPE_QUAL maybe_volatile
    231. 

  231. %type &lt;ttype&gt; initdecls notype_initdecls initdcl notype_initdcl
    232. 

  232. %type &lt;exprtype&gt; init
    233. 

  233. %type &lt;ttype&gt; simple_asm_expr maybeasm asm_stmt asm_argument asm_string
    234. 

  234. %type &lt;ttype&gt; asm_operands nonnull_asm_operands asm_operand asm_clobbers
    235. 

  235. %type &lt;ttype&gt; maybe_attribute attributes attribute attribute_list attrib
    236. 

  236. %type &lt;ttype&gt; any_word
    237. 

  237. 

  238. %type &lt;ttype&gt; compstmt compstmt_start compstmt_primary_start
    239. 

  239. %type &lt;ttype&gt; stmt label stmt_nocomp start_break start_continue
    240. 

  240. 

  241. %type &lt;ttype&gt; c99_block_start c99_block_lineno_labeled_stmt
    242. 

  242. %type &lt;ttype&gt; if_statement_1 if_statement_2
    243. 

  243. %type &lt;dtrtype&gt; declarator
    244. 

  244. %type &lt;dtrtype&gt; notype_declarator after_type_declarator
    245. 

  245. %type &lt;dtrtype&gt; parm_declarator
    246. 

  246. %type &lt;dtrtype&gt; parm_declarator_starttypename parm_declarator_nostarttypename
    247. 

  247. %type &lt;dtrtype&gt; array_declarator
    248. 

  248. 

  249. %type &lt;tstype&gt; structsp_attr structsp_nonattr
    250. 

  250. %type &lt;ttype&gt; component_decl_list component_decl_list2
    251. 

  251. %type &lt;ttype&gt; component_decl components components_notype component_declarator
    252. 

  252. %type &lt;ttype&gt; component_notype_declarator
    253. 

  253. %type &lt;ttype&gt; enumlist enumerator
    254. 

  254. %type &lt;ttype&gt; struct_head union_head enum_head
    255. 

  255. %type &lt;typenametype&gt; typename
    256. 

  256. %type &lt;dtrtype&gt; absdcl absdcl1 absdcl1_ea absdcl1_noea direct_absdcl1
    257. 

  257. %type &lt;parmtype&gt; absdcl_maybe_attribute
    258. 

  258. %type &lt;ttype&gt; condition xexpr for_cond_expr for_incr_expr
    259. 

  259. %type &lt;parmtype&gt; parm firstparm
    260. 

  260. %type &lt;ttype&gt; identifiers
    261. 

  261. 

  262. %type &lt;arginfotype&gt; parms parmlist parmlist_1 parmlist_2
    263. 

  263. %type &lt;arginfotype&gt; parmlist_or_identifiers parmlist_or_identifiers_1
    264. 

  264. %type &lt;ttype&gt; identifiers_or_typenames
    265. 

  265. 

  266. %type &lt;itype&gt; setspecs setspecs_fp extension
    267. 

  267. 

  268. %type &lt;location&gt; save_location
    269. 

  269. 

  270. %type &lt;otype&gt; save_obstack_position
    271. 

  271. 
    272. 

  272. 
    273. 

  273. %{
    274. 

  274. /* Declaration specifiers of the current declaration.  */
    275. 

  275. static struct c_declspecs *current_declspecs;
    276. 

  276. static GTY(()) tree prefix_attributes;
    277. 

  277. 

  278. /* List of all the attributes applying to the identifier currently being
    279. 

  279.    declared; includes prefix_attributes and possibly some more attributes
    280. 

  280.    just after a comma.  */
    281. 

  281. static GTY(()) tree all_prefix_attributes;
    282. 

  282. 

  283. /* Structure to save declaration specifiers.  */
    284. 

  284. struct c_declspec_stack {
    285. 

  285.   /* Saved value of current_declspecs.  */
    286. 

  286.   struct c_declspecs *current_declspecs;
    287. 

  287.   /* Saved value of prefix_attributes.  */
    288. 

  288.   tree prefix_attributes;
    289. 

  289.   /* Saved value of all_prefix_attributes.  */
    290. 

  290.   tree all_prefix_attributes;
    291. 

  291.   /* Next level of stack.  */
    292. 

  292.   struct c_declspec_stack *next;
    293. 

  293. };
    294. 

  294. 

  295. /* Stack of saved values of current_declspecs, prefix_attributes and
    296. 

  296.    all_prefix_attributes.  */
    297. 

  297. static struct c_declspec_stack *declspec_stack;
    298. 

  298. 

  299. /* INDIRECT_REF with a TREE_TYPE of the type being queried for offsetof.  */
    300. 

  300. static tree offsetof_base;
    301. 

  301. 

  302. /* PUSH_DECLSPEC_STACK is called from setspecs; POP_DECLSPEC_STACK
    303. 

  303.    should be called from the productions making use of setspecs.  */
    304. 

  304. #define PUSH_DECLSPEC_STACK						\
    305. 

  305.   do {									\
    306. 

  306.     struct c_declspec_stack *t = XOBNEW (&amp;parser_obstack,		\
    307. 

  307. 					 struct c_declspec_stack);	\
    308. 

  308.     t-&gt;current_declspecs = current_declspecs;				\
    309. 

  309.     t-&gt;prefix_attributes = prefix_attributes;				\
    310. 

  310.     t-&gt;all_prefix_attributes = all_prefix_attributes;			\
    311. 

  311.     t-&gt;next = declspec_stack;						\
    312. 

  312.     declspec_stack = t;							\
    313. 

  313.   } while (0)
    314. 

  314. 

  315. #define POP_DECLSPEC_STACK						\
    316. 

  316.   do {									\
    317. 

  317.     current_declspecs = declspec_stack-&gt;current_declspecs;		\
    318. 

  318.     prefix_attributes = declspec_stack-&gt;prefix_attributes;		\
    319. 

  319.     all_prefix_attributes = declspec_stack-&gt;all_prefix_attributes;	\
    320. 

  320.     declspec_stack = declspec_stack-&gt;next;				\
    321. 

  321.   } while (0)
    322. 

  322. 

  323. /* For __extension__, save/restore the warning flags which are
    324. 

  324.    controlled by __extension__.  */
    325. 

  325. #define SAVE_EXT_FLAGS()		\
    326. 

  326. 	(pedantic			\
    327. 

  327. 	 | (warn_pointer_arith &lt;&lt; 1)	\
    328. 

  328. 	 | (warn_traditional &lt;&lt; 2)	\
    329. 

  329. 	 | (flag_iso &lt;&lt; 3))
    330. 

  330. 

  331. #define RESTORE_EXT_FLAGS(val)			\
    332. 

  332.   do {						\
    333. 

  333.     pedantic = val &amp; 1;				\
    334. 

  334.     warn_pointer_arith = (val &gt;&gt; 1) &amp; 1;	\
    335. 

  335.     warn_traditional = (val &gt;&gt; 2) &amp; 1;		\
    336. 

  336.     flag_iso = (val &gt;&gt; 3) &amp; 1;			\
    337. 

  337.   } while (0)
    338. 

  338. 

  339. 

  340. #define OBJC_NEED_RAW_IDENTIFIER(VAL)	/* nothing */
    341. 

  341. 

  342. /* Tell yyparse how to print a token's value, if yydebug is set.  */
    343. 

  343. 

  344. #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
    345. 

  345. 

  346. static void yyprint (FILE *, int, YYSTYPE);
    347. 

  347. static void yyerror (const char *);
    348. 

  348. static int yylexname (void);
    349. 

  349. static inline int _yylex (void);
    350. 

  350. static int  yylex (void);
    351. 

  351. static void init_reswords (void);
    352. 

  352. 

  353.   /* Initialization routine for this file.  */
    354. 

  354. void
    355. 

  355. c_parse_init (void)
    356. 

  356. {
    357. 

  357.   init_reswords ();
    358. 

  358. }
    359. 

  359. 

  360. %}
    361. 

  361. 
    362. 

  362. %%
    363. 

  363. program: /* empty */
    364. 

  364. 		{ if (pedantic)
    365. 

  365. 		    pedwarn (&quot;ISO C forbids an empty source file&quot;);
    366. 

  366. 		}
    367. 

  367. 	| extdefs
    368. 

  368. 	;
    369. 

  369. 

  370. /* the reason for the strange actions in this rule
    371. 

  371.  is so that notype_initdecls when reached via datadef
    372. 

  372.  can find valid declaration specifiers in $0. */
    373. 

  373. 

  374. extdefs:
    375. 

  375. 	save_obstack_position { $&lt;dsptype&gt;$ = NULL; } extdef
    376. 

  376. 		{ obstack_free (&amp;parser_obstack, $1); }
    377. 

  377. 	| extdefs save_obstack_position
    378. 

  378. 		{ $&lt;dsptype&gt;$ = NULL; ggc_collect (); } extdef
    379. 

  379. 		{ obstack_free (&amp;parser_obstack, $2); }
    380. 

  380. 	;
    381. 

  381. 

  382. extdef:
    383. 

  383. 	fndef
    384. 

  384. 	| datadef
    385. 

  385. 	| asmdef
    386. 

  386. 	| extension extdef
    387. 

  387. 		{ RESTORE_EXT_FLAGS ($1); }
    388. 

  388. 	;
    389. 

  389. 

  390. /* Record the current position of parser_obstack before a
    391. 

  391.    declaration to restore it afterwards.  */
    392. 

  392. save_obstack_position:
    393. 

  393. 		{ $$ = obstack_alloc (&amp;parser_obstack, 0); }
    394. 

  394. 	;
    395. 

  395. 

  396. datadef:
    397. 

  397. 	  setspecs notype_initdecls ';'
    398. 

  398. 		{ pedwarn (&quot;data definition has no type or storage class&quot;);
    399. 

  399. 		  POP_DECLSPEC_STACK; }
    400. 

  400.         | declspecs_nots setspecs notype_initdecls ';'
    401. 

  401. 		{ POP_DECLSPEC_STACK; }
    402. 

  402. 	| declspecs_ts setspecs initdecls ';'
    403. 

  403. 		{ POP_DECLSPEC_STACK; }
    404. 

  404. 	| declspecs ';'
    405. 

  405. 	  { shadow_tag (finish_declspecs ($1)); }
    406. 

  406. 	| error ';'
    407. 

  407. 	| error '}'
    408. 

  408. 	| ';'
    409. 

  409. 		{ if (pedantic)
    410. 

  410. 		    pedwarn (&quot;ISO C does not allow extra %&lt;;%&gt; outside of a function&quot;); }
    411. 

  411. 	;
    412. 

  412. 
    413. 

  413. fndef:
    414. 

  414. 	  declspecs_ts setspecs declarator
    415. 

  415. 		{ if (!start_function (current_declspecs, $3,
    416. 

  416. 				       all_prefix_attributes))
    417. 

  417. 		    YYERROR1;
    418. 

  418. 		}
    419. 

  419. 	  old_style_parm_decls save_location
    420. 

  420. 		{ DECL_SOURCE_LOCATION (current_function_decl) = $6;
    421. 

  421. 		  store_parm_decls (); }
    422. 

  422. 	  compstmt_or_error
    423. 

  423. 		{ finish_function ();
    424. 

  424. 		  POP_DECLSPEC_STACK; }
    425. 

  425. 	| declspecs_ts setspecs declarator error
    426. 

  426. 		{ POP_DECLSPEC_STACK; }
    427. 

  427. 	| declspecs_nots setspecs notype_declarator
    428. 

  428. 		{ if (!start_function (current_declspecs, $3,
    429. 

  429. 				       all_prefix_attributes))
    430. 

  430. 		    YYERROR1;
    431. 

  431. 		}
    432. 

  432. 	  old_style_parm_decls save_location
    433. 

  433. 		{ DECL_SOURCE_LOCATION (current_function_decl) = $6;
    434. 

  434. 		  store_parm_decls (); }
    435. 

  435. 	  compstmt_or_error
    436. 

  436. 		{ finish_function ();
    437. 

  437. 		  POP_DECLSPEC_STACK; }
    438. 

  438. 	| declspecs_nots setspecs notype_declarator error
    439. 

  439. 		{ POP_DECLSPEC_STACK; }
    440. 

  440. 	| setspecs notype_declarator
    441. 

  441. 		{ if (!start_function (current_declspecs, $2,
    442. 

  442. 				       all_prefix_attributes))
    443. 

  443. 		    YYERROR1;
    444. 

  444. 		}
    445. 

  445. 	  old_style_parm_decls save_location
    446. 

  446. 		{ DECL_SOURCE_LOCATION (current_function_decl) = $5;
    447. 

  447. 		  store_parm_decls (); }
    448. 

  448. 	  compstmt_or_error
    449. 

  449. 		{ finish_function ();
    450. 

  450. 		  POP_DECLSPEC_STACK; }
    451. 

  451. 	| setspecs notype_declarator error
    452. 

  452. 		{ POP_DECLSPEC_STACK; }
    453. 

  453. 	;
    454. 

  454. 

  455. identifier:
    456. 

  456. 	IDENTIFIER
    457. 

  457. 	| TYPENAME
    458. 

  458. 	;
    459. 

  459. 

  460. unop:     '&amp;'
    461. 

  461. 		{ $$ = ADDR_EXPR; }
    462. 

  462. 	| '-'
    463. 

  463. 		{ $$ = NEGATE_EXPR; }
    464. 

  464. 	| '+'
    465. 

  465. 		{ $$ = CONVERT_EXPR;
    466. 

  466.   if (warn_traditional &amp;&amp; !in_system_header)
    467. 

  467.     warning (&quot;traditional C rejects the unary plus operator&quot;);
    468. 

  468. 		}
    469. 

  469. 	| PLUSPLUS
    470. 

  470. 		{ $$ = PREINCREMENT_EXPR; }
    471. 

  471. 	| MINUSMINUS
    472. 

  472. 		{ $$ = PREDECREMENT_EXPR; }
    473. 

  473. 	| '~'
    474. 

  474. 		{ $$ = BIT_NOT_EXPR; }
    475. 

  475. 	| '!'
    476. 

  476. 		{ $$ = TRUTH_NOT_EXPR; }
    477. 

  477. 	;
    478. 

  478. 

  479. expr:	expr_no_commas
    480. 

  480. 	| expr ',' expr_no_commas
    481. 

  481. 		{ $$.value = build_compound_expr ($1.value, $3.value);
    482. 

  482. 		  $$.original_code = COMPOUND_EXPR; }
    483. 

  483. 	;
    484. 

  484. 

  485. exprlist:
    486. 

  486. 	  /* empty */
    487. 

  487. 		{ $$ = NULL_TREE; }
    488. 

  488. 	| nonnull_exprlist
    489. 

  489. 	;
    490. 

  490. 

  491. nonnull_exprlist:
    492. 

  492. 	expr_no_commas
    493. 

  493. 		{ $$ = build_tree_list (NULL_TREE, $1.value); }
    494. 

  494. 	| nonnull_exprlist ',' expr_no_commas
    495. 

  495. 		{ chainon ($1, build_tree_list (NULL_TREE, $3.value)); }
    496. 

  496. 	;
    497. 

  497. 

  498. unary_expr:
    499. 

  499. 	primary
    500. 

  500. 	| '*' cast_expr   %prec UNARY
    501. 

  501. 		{ $$.value = build_indirect_ref ($2.value, &quot;unary *&quot;);
    502. 

  502. 		  $$.original_code = ERROR_MARK; }
    503. 

  503. 	/* __extension__ turns off -pedantic for following primary.  */
    504. 

  504. 	| extension cast_expr	  %prec UNARY
    505. 

  505. 		{ $$ = $2;
    506. 

  506. 		  RESTORE_EXT_FLAGS ($1); }
    507. 

  507. 	| unop cast_expr  %prec UNARY
    508. 

  508. 		{ $$.value = build_unary_op ($1, $2.value, 0);
    509. 

  509. 		  overflow_warning ($$.value);
    510. 

  510. 		  $$.original_code = ERROR_MARK; }
    511. 

  511. 	/* Refer to the address of a label as a pointer.  */
    512. 

  512. 	| ANDAND identifier
    513. 

  513. 		{ $$.value = finish_label_address_expr ($2);
    514. 

  514. 		  $$.original_code = ERROR_MARK; }
    515. 

  515. 	| sizeof unary_expr  %prec UNARY
    516. 

  516. 		{ skip_evaluation--;
    517. 

  517. 		  in_sizeof--;
    518. 

  518. 		  if (TREE_CODE ($2.value) == COMPONENT_REF
    519. 

  519. 		      &amp;&amp; DECL_C_BIT_FIELD (TREE_OPERAND ($2.value, 1)))
    520. 

  520. 		    error (&quot;%&lt;sizeof%&gt; applied to a bit-field&quot;);
    521. 

  521. 		  $$ = c_expr_sizeof_expr ($2); }
    522. 

  522. 	| sizeof '(' typename ')'  %prec HYPERUNARY
    523. 

  523. 		{ skip_evaluation--;
    524. 

  524. 		  in_sizeof--;
    525. 

  525. 		  $$ = c_expr_sizeof_type ($3); }
    526. 

  526. 	| alignof unary_expr  %prec UNARY
    527. 

  527. 		{ skip_evaluation--;
    528. 

  528. 		  in_alignof--;
    529. 

  529. 		  $$.value = c_alignof_expr ($2.value);
    530. 

  530. 		  $$.original_code = ERROR_MARK; }
    531. 

  531. 	| alignof '(' typename ')'  %prec HYPERUNARY
    532. 

  532. 		{ skip_evaluation--;
    533. 

  533. 		  in_alignof--;
    534. 

  534. 		  $$.value = c_alignof (groktypename ($3));
    535. 

  535. 		  $$.original_code = ERROR_MARK; }
    536. 

  536. 	| REALPART cast_expr %prec UNARY
    537. 

  537. 		{ $$.value = build_unary_op (REALPART_EXPR, $2.value, 0);
    538. 

  538. 		  $$.original_code = ERROR_MARK; }
    539. 

  539. 	| IMAGPART cast_expr %prec UNARY
    540. 

  540. 		{ $$.value = build_unary_op (IMAGPART_EXPR, $2.value, 0);
    541. 

  541. 		  $$.original_code = ERROR_MARK; }
    542. 

  542. 	;
    543. 

  543. 

  544. sizeof:
    545. 

  545. 	SIZEOF { skip_evaluation++; in_sizeof++; }
    546. 

  546. 	;
    547. 

  547. 

  548. alignof:
    549. 

  549. 	ALIGNOF { skip_evaluation++; in_alignof++; }
    550. 

  550. 	;
    551. 

  551. 

  552. typeof:
    553. 

  553. 	TYPEOF { skip_evaluation++; in_typeof++; }
    554. 

  554. 	;
    555. 

  555. 

  556. cast_expr:
    557. 

  557. 	unary_expr
    558. 

  558. 	| '(' typename ')' cast_expr  %prec UNARY
    559. 

  559. 		{ $$.value = c_cast_expr ($2, $4.value);
    560. 

  560. 		  $$.original_code = ERROR_MARK; }
    561. 

  561. 	;
    562. 

  562. 

  563. expr_no_commas:
    564. 

  564. 	  cast_expr
    565. 

  565. 	| expr_no_commas '+' expr_no_commas
    566. 

  566. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    567. 

  567. 	| expr_no_commas '-' expr_no_commas
    568. 

  568. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    569. 

  569. 	| expr_no_commas '*' expr_no_commas
    570. 

  570. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    571. 

  571. 	| expr_no_commas '/' expr_no_commas
    572. 

  572. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    573. 

  573. 	| expr_no_commas '%' expr_no_commas
    574. 

  574. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    575. 

  575. 	| expr_no_commas LSHIFT expr_no_commas
    576. 

  576. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    577. 

  577. 	| expr_no_commas RSHIFT expr_no_commas
    578. 

  578. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    579. 

  579. 	| expr_no_commas ARITHCOMPARE expr_no_commas
    580. 

  580. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    581. 

  581. 	| expr_no_commas EQCOMPARE expr_no_commas
    582. 

  582. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    583. 

  583. 	| expr_no_commas '&amp;' expr_no_commas
    584. 

  584. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    585. 

  585. 	| expr_no_commas '|' expr_no_commas
    586. 

  586. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    587. 

  587. 	| expr_no_commas '^' expr_no_commas
    588. 

  588. 		{ $$ = parser_build_binary_op ($2, $1, $3); }
    589. 

  589. 	| expr_no_commas ANDAND
    590. 

  590. 		{ $1.value = lang_hooks.truthvalue_conversion
    591. 

  591. 		    (default_conversion ($1.value));
    592. 

  592. 		  skip_evaluation += $1.value == truthvalue_false_node; }
    593. 

  593. 	  expr_no_commas
    594. 

  594. 		{ skip_evaluation -= $1.value == truthvalue_false_node;
    595. 

  595. 		  $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $4); }
    596. 

  596. 	| expr_no_commas OROR
    597. 

  597. 		{ $1.value = lang_hooks.truthvalue_conversion
    598. 

  598. 		    (default_conversion ($1.value));
    599. 

  599. 		  skip_evaluation += $1.value == truthvalue_true_node; }
    600. 

  600. 	  expr_no_commas
    601. 

  601. 		{ skip_evaluation -= $1.value == truthvalue_true_node;
    602. 

  602. 		  $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $4); }
    603. 

  603. 	| expr_no_commas '?'
    604. 

  604. 		{ $1.value = lang_hooks.truthvalue_conversion
    605. 

  605. 		    (default_conversion ($1.value));
    606. 

  606. 		  skip_evaluation += $1.value == truthvalue_false_node; }
    607. 

  607.           expr ':'
    608. 

  608. 		{ skip_evaluation += (($1.value == truthvalue_true_node)
    609. 

  609. 				      - ($1.value == truthvalue_false_node)); }
    610. 

  610. 	  expr_no_commas
    611. 

  611. 		{ skip_evaluation -= $1.value == truthvalue_true_node;
    612. 

  612. 		  $$.value = build_conditional_expr ($1.value, $4.value,
    613. 

  613. 						     $7.value);
    614. 

  614. 		  $$.original_code = ERROR_MARK; }
    615. 

  615. 	| expr_no_commas '?'
    616. 

  616. 		{ if (pedantic)
    617. 

  617. 		    pedwarn (&quot;ISO C forbids omitting the middle term of a ?: expression&quot;);
    618. 

  618. 		  /* Make sure first operand is calculated only once.  */
    619. 

  619. 		  $&lt;ttype&gt;2 = save_expr (default_conversion ($1.value));
    620. 

  620. 		  $1.value = lang_hooks.truthvalue_conversion ($&lt;ttype&gt;2);
    621. 

  621. 		  skip_evaluation += $1.value == truthvalue_true_node; }
    622. 

  622. 	  ':' expr_no_commas
    623. 

  623. 		{ skip_evaluation -= $1.value == truthvalue_true_node;
    624. 

  624. 		  $$.value = build_conditional_expr ($1.value, $&lt;ttype&gt;2,
    625. 

  625. 						     $5.value);
    626. 

  626. 		  $$.original_code = ERROR_MARK; }
    627. 

  627. 	| expr_no_commas '=' expr_no_commas
    628. 

  628. 		{ $$.value = build_modify_expr ($1.value, NOP_EXPR, $3.value);
    629. 

  629. 		  $$.original_code = MODIFY_EXPR;
    630. 

  630. 		}
    631. 

  631. 	| expr_no_commas ASSIGN expr_no_commas
    632. 

  632. 		{ $$.value = build_modify_expr ($1.value, $2, $3.value);
    633. 

  633. 		  TREE_NO_WARNING ($$.value) = 1;
    634. 

  634. 		  $$.original_code = ERROR_MARK;
    635. 

  635. 		}
    636. 

  636. 	;
    637. 

  637. 

  638. primary:
    639. 

  639. 	IDENTIFIER
    640. 

  640. 		{
    641. 

  641. 		  if (yychar == YYEMPTY)
    642. 

  642. 		    yychar = YYLEX;
    643. 

  643. 		  $$.value = build_external_ref ($1, yychar == '(');
    644. 

  644. 		  $$.original_code = ERROR_MARK;
    645. 

  645. 		}
    646. 

  646. 	| CONSTANT
    647. 

  647. 		{ $$.value = $1; $$.original_code = ERROR_MARK; }
    648. 

  648. 	| STRING
    649. 

  649. 		{ $$.value = $1; $$.original_code = STRING_CST; }
    650. 

  650. 	| FUNC_NAME
    651. 

  651. 		{ $$.value = fname_decl (C_RID_CODE ($1), $1);
    652. 

  652. 		  $$.original_code = ERROR_MARK; }
    653. 

  653. 	| '(' typename ')' '{'
    654. 

  654. 		{ start_init (NULL_TREE, NULL, 0);
    655. 

  655. 		  $&lt;ttype&gt;$ = groktypename ($2);
    656. 

  656. 		  if (C_TYPE_VARIABLE_SIZE ($&lt;ttype&gt;$))
    657. 

  657. 		    {
    658. 

  658. 		      error (&quot;compound literal has variable size&quot;);
    659. 

  659. 		      $&lt;ttype&gt;$ = error_mark_node;
    660. 

  660. 		    }
    661. 

  661. 		  really_start_incremental_init ($&lt;ttype&gt;$); }
    662. 

  662. 	  initlist_maybe_comma '}'  %prec UNARY
    663. 

  663. 		{ struct c_expr init = pop_init_level (0);
    664. 

  664. 		  tree constructor = init.value;
    665. 

  665. 		  tree type = $&lt;ttype&gt;5;
    666. 

  666. 		  finish_init ();
    667. 

  667. 		  maybe_warn_string_init (type, init);
    668. 

  668. 

  669. 		  if (pedantic &amp;&amp; !flag_isoc99)
    670. 

  670. 		    pedwarn (&quot;ISO C90 forbids compound literals&quot;);
    671. 

  671. 		  $$.value = build_compound_literal (type, constructor);
    672. 

  672. 		  $$.original_code = ERROR_MARK;
    673. 

  673. 		}
    674. 

  674. 	| '(' expr ')'
    675. 

  675. 		{ $$.value = $2.value;
    676. 

  676. 		  if (TREE_CODE ($$.value) == MODIFY_EXPR)
    677. 

  677. 		    TREE_NO_WARNING ($$.value) = 1;
    678. 

  678. 		  $$.original_code = ERROR_MARK; }
    679. 

  679. 	| '(' error ')'
    680. 

  680. 		{ $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
    681. 

  681. 	| compstmt_primary_start compstmt_nostart ')'
    682. 

  682.                 { if (pedantic)
    683. 

  683. 		    pedwarn (&quot;ISO C forbids braced-groups within expressions&quot;);
    684. 

  684. 		  $$.value = c_finish_stmt_expr ($1);
    685. 

  685. 		  $$.original_code = ERROR_MARK;
    686. 

  686. 		}
    687. 

  687. 	| compstmt_primary_start error ')'
    688. 

  688. 		{ c_finish_stmt_expr ($1);
    689. 

  689. 		  $$.value = error_mark_node;
    690. 

  690. 		  $$.original_code = ERROR_MARK;
    691. 

  691. 		}
    692. 

  692. 	| primary '(' exprlist ')'   %prec '.'
    693. 

  693. 		{ $$.value = build_function_call ($1.value, $3);
    694. 

  694. 		  $$.original_code = ERROR_MARK; }
    695. 

  695. 	| VA_ARG '(' expr_no_commas ',' typename ')'
    696. 

  696. 		{ $$.value = build_va_arg ($3.value, groktypename ($5));
    697. 

  697. 		  $$.original_code = ERROR_MARK; }
    698. 

  698. 

  699. 	| OFFSETOF '(' typename ','
    700. 

  700. 		{ tree type = groktypename ($3);
    701. 

  701. 		  if (type == error_mark_node)
    702. 

  702. 		    offsetof_base = error_mark_node;
    703. 

  703. 		  else
    704. 

  704. 		    offsetof_base = build1 (INDIRECT_REF, type, NULL);
    705. 

  705. 		}
    706. 

  706. 	  offsetof_member_designator ')'
    707. 

  707. 		{ $$.value = fold_offsetof ($6);
    708. 

  708. 		  $$.original_code = ERROR_MARK; }
    709. 

  709. 	| OFFSETOF '(' error ')'
    710. 

  710. 		{ $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
    711. 

  711. 	| CHOOSE_EXPR '(' expr_no_commas ',' expr_no_commas ','
    712. 

  712. 			  expr_no_commas ')'
    713. 

  713. 		{
    714. 

  714.                   tree c;
    715. 

  715. 

  716.                   c = fold ($3.value);
    717. 

  717.                   STRIP_NOPS (c);
    718. 

  718.                   if (TREE_CODE (c) != INTEGER_CST)
    719. 

  719.                     error (&quot;first argument to %&lt;__builtin_choose_expr%&gt; not&quot;
    720. 

  720. 			   &quot; a constant&quot;);
    721. 

  721.                   $$ = integer_zerop (c) ? $7 : $5;
    722. 

  722. 		}
    723. 

  723. 	| CHOOSE_EXPR '(' error ')'
    724. 

  724. 		{ $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
    725. 

  725. 	| TYPES_COMPATIBLE_P '(' typename ',' typename ')'
    726. 

  726. 		{
    727. 

  727. 		  tree e1, e2;
    728. 

  728. 

  729. 		  e1 = TYPE_MAIN_VARIANT (groktypename ($3));
    730. 

  730. 		  e2 = TYPE_MAIN_VARIANT (groktypename ($5));
    731. 

  731. 

  732. 		  $$.value = comptypes (e1, e2)
    733. 

  733. 		    ? build_int_cst (NULL_TREE, 1)
    734. 

  734. 		    : build_int_cst (NULL_TREE, 0);
    735. 

  735. 		  $$.original_code = ERROR_MARK;
    736. 

  736. 		}
    737. 

  737. 	| TYPES_COMPATIBLE_P '(' error ')'
    738. 

  738. 		{ $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
    739. 

  739. 	| primary '[' expr ']'   %prec '.'
    740. 

  740. 		{ $$.value = build_array_ref ($1.value, $3.value);
    741. 

  741. 		  $$.original_code = ERROR_MARK; }
    742. 

  742. 	| primary '.' identifier
    743. 

  743. 		{ $$.value = build_component_ref ($1.value, $3);
    744. 

  744. 		  $$.original_code = ERROR_MARK; }
    745. 

  745. 	| primary POINTSAT identifier
    746. 

  746. 		{
    747. 

  747.                   tree expr = build_indirect_ref ($1.value, &quot;-&gt;&quot;);
    748. 

  748. 		  $$.value = build_component_ref (expr, $3);
    749. 

  749. 		  $$.original_code = ERROR_MARK;
    750. 

  750. 		}
    751. 

  751. 	| primary PLUSPLUS
    752. 

  752. 		{ $$.value = build_unary_op (POSTINCREMENT_EXPR, $1.value, 0);
    753. 

  753. 		  $$.original_code = ERROR_MARK; }
    754. 

  754. 	| primary MINUSMINUS
    755. 

  755. 		{ $$.value = build_unary_op (POSTDECREMENT_EXPR, $1.value, 0);
    756. 

  756. 		  $$.original_code = ERROR_MARK; }
    757. 

  757. 	;
    758. 

  758. 

  759. /* This is the second argument to __builtin_offsetof.  We must have one
    760. 

  760.    identifier, and beyond that we want to accept sub structure and sub
    761. 

  761.    array references.  */
    762. 

  762. 

  763. offsetof_member_designator:
    764. 

  764. 	  identifier
    765. 

  765. 		{ $$ = build_component_ref (offsetof_base, $1); }
    766. 

  766. 	| offsetof_member_designator '.' identifier
    767. 

  767. 		{ $$ = build_component_ref ($1, $3); }
    768. 

  768. 	| offsetof_member_designator '[' expr ']'
    769. 

  769. 		{ $$ = build_array_ref ($1, $3.value); }
    770. 

  770. 	;
    771. 

  771. 

  772. old_style_parm_decls:
    773. 

  773. 	/* empty */
    774. 

  774. 	| datadecls
    775. 

  775. 	;
    776. 

  776. 

  777. /* The following are analogous to lineno_decl, decls and decl
    778. 

  778.    except that they do not allow nested functions.
    779. 

  779.    They are used for old-style parm decls.  */
    780. 

  780. lineno_datadecl:
    781. 

  781. 	  save_location datadecl
    782. 

  782. 		{ }
    783. 

  783. 	;
    784. 

  784. 

  785. datadecls:
    786. 

  786. 	lineno_datadecl
    787. 

  787. 	| errstmt
    788. 

  788. 	| datadecls lineno_datadecl
    789. 

  789. 	| lineno_datadecl errstmt
    790. 

  790. 	;
    791. 

  791. 

  792. /* We don't allow prefix attributes here because they cause reduce/reduce
    793. 

  793.    conflicts: we can't know whether we're parsing a function decl with
    794. 

  794.    attribute suffix, or function defn with attribute prefix on first old
    795. 

  795.    style parm.  */
    796. 

  796. datadecl:
    797. 

  797. 	declspecs_ts_nosa setspecs initdecls ';'
    798. 

  798. 		{ POP_DECLSPEC_STACK; }
    799. 

  799. 	| declspecs_nots_nosa setspecs notype_initdecls ';'
    800. 

  800. 		{ POP_DECLSPEC_STACK; }
    801. 

  801. 	| declspecs_ts_nosa ';'
    802. 

  802. 		{ shadow_tag_warned (finish_declspecs ($1), 1);
    803. 

  803. 		  pedwarn (&quot;empty declaration&quot;); }
    804. 

  804. 	| declspecs_nots_nosa ';'
    805. 

  805. 		{ pedwarn (&quot;empty declaration&quot;); }
    806. 

  806. 	;
    807. 

  807. 

  808. /* This combination which saves a lineno before a decl
    809. 

  809.    is the normal thing to use, rather than decl itself.
    810. 

  810.    This is to avoid shift/reduce conflicts in contexts
    811. 

  811.    where statement labels are allowed.  */
    812. 

  812. lineno_decl:
    813. 

  813. 	  save_location decl
    814. 

  814. 		{ }
    815. 

  815. 	;
    816. 

  816. 

  817. /* records the type and storage class specs to use for processing
    818. 

  818.    the declarators that follow.
    819. 

  819.    Maintains a stack of outer-level values of current_declspecs,
    820. 

  820.    for the sake of parm declarations nested in function declarators.  */
    821. 

  821. setspecs: /* empty */
    822. 

  822. 		{ pending_xref_error ();
    823. 

  823. 		  PUSH_DECLSPEC_STACK;
    824. 

  824. 		  if ($&lt;dsptype&gt;0)
    825. 

  825. 		    {
    826. 

  826. 		      prefix_attributes = $&lt;dsptype&gt;0-&gt;attrs;
    827. 

  827. 		      $&lt;dsptype&gt;0-&gt;attrs = NULL_TREE;
    828. 

  828. 		      current_declspecs = $&lt;dsptype&gt;0;
    829. 

  829. 		    }
    830. 

  830. 		  else
    831. 

  831. 		    {
    832. 

  832. 		      prefix_attributes = NULL_TREE;
    833. 

  833. 		      current_declspecs = build_null_declspecs ();
    834. 

  834. 		    }
    835. 

  835. 		  current_declspecs = finish_declspecs (current_declspecs);
    836. 

  836. 		  all_prefix_attributes = prefix_attributes; }
    837. 

  837. 	;
    838. 

  838. 

  839. /* Possibly attributes after a comma, which should reset all_prefix_attributes
    840. 

  840.    to prefix_attributes with these ones chained on the front.  */
    841. 

  841. maybe_resetattrs:
    842. 

  842. 	  maybe_attribute
    843. 

  843. 		{ all_prefix_attributes = chainon ($1, prefix_attributes); }
    844. 

  844. 	;
    845. 

  845. 

  846. decl:
    847. 

  847. 	declspecs_ts setspecs initdecls ';'
    848. 

  848. 		{ POP_DECLSPEC_STACK; }
    849. 

  849. 	| declspecs_nots setspecs notype_initdecls ';'
    850. 

  850. 		{ POP_DECLSPEC_STACK; }
    851. 

  851. 	| declspecs_ts setspecs nested_function
    852. 

  852. 		{ POP_DECLSPEC_STACK; }
    853. 

  853. 	| declspecs_nots setspecs notype_nested_function
    854. 

  854. 		{ POP_DECLSPEC_STACK; }
    855. 

  855. 	| declspecs ';'
    856. 

  856. 		{ shadow_tag (finish_declspecs ($1)); }
    857. 

  857. 	| extension decl
    858. 

  858. 		{ RESTORE_EXT_FLAGS ($1); }
    859. 

  859. 	;
    860. 

  860. 

  861. /* A list of declaration specifiers.  These are:
    862. 

    863. 

  863.    - Storage class specifiers (scspec), which for GCC currently includes
    864. 

  864.    function specifiers (&quot;inline&quot;).
    865. 

    866. 

  866.    - Type specifiers (typespec_*).
    867. 

    868. 

  868.    - Type qualifiers (TYPE_QUAL).
    869. 

    870. 

  870.    - Attribute specifier lists (attributes).
    871. 

    872. 

  872.    The various cases below are classified according to:
    873. 

    874. 

  874.    (a) Whether a storage class specifier is included or not; some
    875. 

  875.    places in the grammar disallow storage class specifiers (_sc or _nosc).
    876. 

    877. 

  877.    (b) Whether a type specifier has been seen; after a type specifier,
    878. 

  878.    a typedef name is an identifier to redeclare (_ts or _nots).
    879. 

    880. 

  880.    (c) Whether the list starts with an attribute; in certain places,
    881. 

  881.    the grammar requires specifiers that don't start with an attribute
    882. 

  882.    (_sa or _nosa).
    883. 

    884. 

  884.    (d) Whether the list ends with an attribute (or a specifier such that
    885. 

  885.    any following attribute would have been parsed as part of that specifier);
    886. 

  886.    this avoids shift-reduce conflicts in the parsing of attributes
    887. 

  887.    (_ea or _noea).
    888. 

    889. 

  889.    TODO:
    890. 

    891. 

  891.    (i) Distinguish between function specifiers and storage class specifiers,
    892. 

  892.    at least for the purpose of warnings about obsolescent usage.
    893. 

    894. 

  894.    (ii) Halve the number of productions here by eliminating the _sc/_nosc
    895. 

  895.    distinction and instead checking where required that storage class
    896. 

  896.    specifiers aren't present.  */
    897. 

  897. 

  898. /* Declspecs which contain at least one type specifier or typedef name.
    899. 

  899.    (Just `const' or `volatile' is not enough.)
    900. 

  900.    A typedef'd name following these is taken as a name to be declared.  */
    901. 

  901. 

  902. declspecs_nosc_nots_nosa_noea:
    903. 

  903. 	  TYPE_QUAL
    904. 

  904. 		{ $$ = declspecs_add_qual (build_null_declspecs (), $1); }
    905. 

  905. 	| declspecs_nosc_nots_nosa_noea TYPE_QUAL
    906. 

  906. 		{ $$ = declspecs_add_qual ($1, $2); }
    907. 

  907. 	| declspecs_nosc_nots_nosa_ea TYPE_QUAL
    908. 

  908. 		{ $$ = declspecs_add_qual ($1, $2); }
    909. 

  909. 	;
    910. 

  910. 

  911. declspecs_nosc_nots_nosa_ea:
    912. 

  912. 	  declspecs_nosc_nots_nosa_noea attributes
    913. 

  913. 		{ $$ = declspecs_add_attrs ($1, $2); }
    914. 

  914. 	;
    915. 

  915. 

  916. declspecs_nosc_nots_sa_noea:
    917. 

  917. 	  declspecs_nosc_nots_sa_noea TYPE_QUAL
    918. 

  918. 		{ $$ = declspecs_add_qual ($1, $2); }
    919. 

  919. 	| declspecs_nosc_nots_sa_ea TYPE_QUAL
    920. 

  920. 		{ $$ = declspecs_add_qual ($1, $2); }
    921. 

  921. 	;
    922. 

  922. 

  923. declspecs_nosc_nots_sa_ea:
    924. 

  924. 	  attributes
    925. 

  925. 		{ $$ = declspecs_add_attrs (build_null_declspecs (), $1); }
    926. 

  926. 	| declspecs_nosc_nots_sa_noea attributes
    927. 

  927. 		{ $$ = declspecs_add_attrs ($1, $2); }
    928. 

  928. 	;
    929. 

  929. 

  930. declspecs_nosc_ts_nosa_noea:
    931. 

  931. 	  typespec_nonattr
    932. 

  932. 		{ $$ = declspecs_add_type (build_null_declspecs (), $1); }
    933. 

  933. 	| declspecs_nosc_ts_nosa_noea TYPE_QUAL
    934. 

  934. 		{ $$ = declspecs_add_qual ($1, $2); }
    935. 

  935. 	| declspecs_nosc_ts_nosa_ea TYPE_QUAL
    936. 

  936. 		{ $$ = declspecs_add_qual ($1, $2); }
    937. 

  937. 	| declspecs_nosc_ts_nosa_noea typespec_reserved_nonattr
    938. 

  938. 		{ $$ = declspecs_add_type ($1, $2); }
    939. 

  939. 	| declspecs_nosc_ts_nosa_ea typespec_reserved_nonattr
    940. 

  940. 		{ $$ = declspecs_add_type ($1, $2); }
    941. 

  941. 	| declspecs_nosc_nots_nosa_noea typespec_nonattr
    942. 

  942. 		{ $$ = declspecs_add_type ($1, $2); }
    943. 

  943. 	| declspecs_nosc_nots_nosa_ea typespec_nonattr
    944. 

  944. 		{ $$ = declspecs_add_type ($1, $2); }
    945. 

  945. 	;
    946. 

  946. 

  947. declspecs_nosc_ts_nosa_ea:
    948. 

  948. 	  typespec_attr
    949. 

  949. 		{ $$ = declspecs_add_type (build_null_declspecs (), $1); }
    950. 

  950. 	| declspecs_nosc_ts_nosa_noea attributes
    951. 

  951. 		{ $$ = declspecs_add_attrs ($1, $2); }
    952. 

  952. 	| declspecs_nosc_ts_nosa_noea typespec_reserved_attr
    953. 

  953. 		{ $$ = declspecs_add_type ($1, $2); }
    954. 

  954. 	| declspecs_nosc_ts_nosa_ea typespec_reserved_attr
    955. 

  955. 		{ $$ = declspecs_add_type ($1, $2); }
    956. 

  956. 	| declspecs_nosc_nots_nosa_noea typespec_attr
    957. 

  957. 		{ $$ = declspecs_add_type ($1, $2); }
    958. 

  958. 	| declspecs_nosc_nots_nosa_ea typespec_attr
    959. 

  959. 		{ $$ = declspecs_add_type ($1, $2); }
    960. 

  960. 	;
    961. 

  961. 

  962. declspecs_nosc_ts_sa_noea:
    963. 

  963. 	  declspecs_nosc_ts_sa_noea TYPE_QUAL
    964. 

  964. 		{ $$ = declspecs_add_qual ($1, $2); }
    965. 

  965. 	| declspecs_nosc_ts_sa_ea TYPE_QUAL
    966. 

  966. 		{ $$ = declspecs_add_qual ($1, $2); }
    967. 

  967. 	| declspecs_nosc_ts_sa_noea typespec_reserved_nonattr
    968. 

  968. 		{ $$ = declspecs_add_type ($1, $2); }
    969. 

  969. 	| declspecs_nosc_ts_sa_ea typespec_reserved_nonattr
    970. 

  970. 		{ $$ = declspecs_add_type ($1, $2); }
    971. 

  971. 	| declspecs_nosc_nots_sa_noea typespec_nonattr
    972. 

  972. 		{ $$ = declspecs_add_type ($1, $2); }
    973. 

  973. 	| declspecs_nosc_nots_sa_ea typespec_nonattr
    974. 

  974. 		{ $$ = declspecs_add_type ($1, $2); }
    975. 

  975. 	;
    976. 

  976. 

  977. declspecs_nosc_ts_sa_ea:
    978. 

  978. 	  declspecs_nosc_ts_sa_noea attributes
    979. 

  979. 		{ $$ = declspecs_add_attrs ($1, $2); }
    980. 

  980. 	| declspecs_nosc_ts_sa_noea typespec_reserved_attr
    981. 

  981. 		{ $$ = declspecs_add_type ($1, $2); }
    982. 

  982. 	| declspecs_nosc_ts_sa_ea typespec_reserved_attr
    983. 

  983. 		{ $$ = declspecs_add_type ($1, $2); }
    984. 

  984. 	| declspecs_nosc_nots_sa_noea typespec_attr
    985. 

  985. 		{ $$ = declspecs_add_type ($1, $2); }
    986. 

  986. 	| declspecs_nosc_nots_sa_ea typespec_attr
    987. 

  987. 		{ $$ = declspecs_add_type ($1, $2); }
    988. 

  988. 	;
    989. 

  989. 

  990. declspecs_sc_nots_nosa_noea:
    991. 

  991. 	  scspec
    992. 

  992. 		{ $$ = declspecs_add_scspec (build_null_declspecs (), $1); }
    993. 

  993. 	| declspecs_sc_nots_nosa_noea TYPE_QUAL
    994. 

  994. 		{ $$ = declspecs_add_qual ($1, $2); }
    995. 

  995. 	| declspecs_sc_nots_nosa_ea TYPE_QUAL
    996. 

  996. 		{ $$ = declspecs_add_qual ($1, $2); }
    997. 

  997. 	| declspecs_nosc_nots_nosa_noea scspec
    998. 

  998. 		{ $$ = declspecs_add_scspec ($1, $2); }
    999. 

  999. 	| declspecs_nosc_nots_nosa_ea scspec
    1000. 

  1000. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1001. 

  1001. 	| declspecs_sc_nots_nosa_noea scspec
    1002. 

  1002. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1003. 

  1003. 	| declspecs_sc_nots_nosa_ea scspec
    1004. 

  1004. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1005. 

  1005. 	;
    1006. 

  1006. 

  1007. declspecs_sc_nots_nosa_ea:
    1008. 

  1008. 	  declspecs_sc_nots_nosa_noea attributes
    1009. 

  1009. 		{ $$ = declspecs_add_attrs ($1, $2); }
    1010. 

  1010. 	;
    1011. 

  1011. 

  1012. declspecs_sc_nots_sa_noea:
    1013. 

  1013. 	  declspecs_sc_nots_sa_noea TYPE_QUAL
    1014. 

  1014. 		{ $$ = declspecs_add_qual ($1, $2); }
    1015. 

  1015. 	| declspecs_sc_nots_sa_ea TYPE_QUAL
    1016. 

  1016. 		{ $$ = declspecs_add_qual ($1, $2); }
    1017. 

  1017. 	| declspecs_nosc_nots_sa_noea scspec
    1018. 

  1018. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1019. 

  1019. 	| declspecs_nosc_nots_sa_ea scspec
    1020. 

  1020. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1021. 

  1021. 	| declspecs_sc_nots_sa_noea scspec
    1022. 

  1022. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1023. 

  1023. 	| declspecs_sc_nots_sa_ea scspec
    1024. 

  1024. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1025. 

  1025. 	;
    1026. 

  1026. 

  1027. declspecs_sc_nots_sa_ea:
    1028. 

  1028. 	  declspecs_sc_nots_sa_noea attributes
    1029. 

  1029. 		{ $$ = declspecs_add_attrs ($1, $2); }
    1030. 

  1030. 	;
    1031. 

  1031. 

  1032. declspecs_sc_ts_nosa_noea:
    1033. 

  1033. 	  declspecs_sc_ts_nosa_noea TYPE_QUAL
    1034. 

  1034. 		{ $$ = declspecs_add_qual ($1, $2); }
    1035. 

  1035. 	| declspecs_sc_ts_nosa_ea TYPE_QUAL
    1036. 

  1036. 		{ $$ = declspecs_add_qual ($1, $2); }
    1037. 

  1037. 	| declspecs_sc_ts_nosa_noea typespec_reserved_nonattr
    1038. 

  1038. 		{ $$ = declspecs_add_type ($1, $2); }
    1039. 

  1039. 	| declspecs_sc_ts_nosa_ea typespec_reserved_nonattr
    1040. 

  1040. 		{ $$ = declspecs_add_type ($1, $2); }
    1041. 

  1041. 	| declspecs_sc_nots_nosa_noea typespec_nonattr
    1042. 

  1042. 		{ $$ = declspecs_add_type ($1, $2); }
    1043. 

  1043. 	| declspecs_sc_nots_nosa_ea typespec_nonattr
    1044. 

  1044. 		{ $$ = declspecs_add_type ($1, $2); }
    1045. 

  1045. 	| declspecs_nosc_ts_nosa_noea scspec
    1046. 

  1046. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1047. 

  1047. 	| declspecs_nosc_ts_nosa_ea scspec
    1048. 

  1048. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1049. 

  1049. 	| declspecs_sc_ts_nosa_noea scspec
    1050. 

  1050. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1051. 

  1051. 	| declspecs_sc_ts_nosa_ea scspec
    1052. 

  1052. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1053. 

  1053. 	;
    1054. 

  1054. 

  1055. declspecs_sc_ts_nosa_ea:
    1056. 

  1056. 	  declspecs_sc_ts_nosa_noea attributes
    1057. 

  1057. 		{ $$ = declspecs_add_attrs ($1, $2); }
    1058. 

  1058. 	| declspecs_sc_ts_nosa_noea typespec_reserved_attr
    1059. 

  1059. 		{ $$ = declspecs_add_type ($1, $2); }
    1060. 

  1060. 	| declspecs_sc_ts_nosa_ea typespec_reserved_attr
    1061. 

  1061. 		{ $$ = declspecs_add_type ($1, $2); }
    1062. 

  1062. 	| declspecs_sc_nots_nosa_noea typespec_attr
    1063. 

  1063. 		{ $$ = declspecs_add_type ($1, $2); }
    1064. 

  1064. 	| declspecs_sc_nots_nosa_ea typespec_attr
    1065. 

  1065. 		{ $$ = declspecs_add_type ($1, $2); }
    1066. 

  1066. 	;
    1067. 

  1067. 

  1068. declspecs_sc_ts_sa_noea:
    1069. 

  1069. 	  declspecs_sc_ts_sa_noea TYPE_QUAL
    1070. 

  1070. 		{ $$ = declspecs_add_qual ($1, $2); }
    1071. 

  1071. 	| declspecs_sc_ts_sa_ea TYPE_QUAL
    1072. 

  1072. 		{ $$ = declspecs_add_qual ($1, $2); }
    1073. 

  1073. 	| declspecs_sc_ts_sa_noea typespec_reserved_nonattr
    1074. 

  1074. 		{ $$ = declspecs_add_type ($1, $2); }
    1075. 

  1075. 	| declspecs_sc_ts_sa_ea typespec_reserved_nonattr
    1076. 

  1076. 		{ $$ = declspecs_add_type ($1, $2); }
    1077. 

  1077. 	| declspecs_sc_nots_sa_noea typespec_nonattr
    1078. 

  1078. 		{ $$ = declspecs_add_type ($1, $2); }
    1079. 

  1079. 	| declspecs_sc_nots_sa_ea typespec_nonattr
    1080. 

  1080. 		{ $$ = declspecs_add_type ($1, $2); }
    1081. 

  1081. 	| declspecs_nosc_ts_sa_noea scspec
    1082. 

  1082. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1083. 

  1083. 	| declspecs_nosc_ts_sa_ea scspec
    1084. 

  1084. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1085. 

  1085. 	| declspecs_sc_ts_sa_noea scspec
    1086. 

  1086. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1087. 

  1087. 	| declspecs_sc_ts_sa_ea scspec
    1088. 

  1088. 		{ $$ = declspecs_add_scspec ($1, $2); }
    1089. 

  1089. 	;
    1090. 

  1090. 

  1091. declspecs_sc_ts_sa_ea:
    1092. 

  1092. 	  declspecs_sc_ts_sa_noea attributes
    1093. 

  1093. 		{ $$ = declspecs_add_attrs ($1, $2); }
    1094. 

  1094. 	| declspecs_sc_ts_sa_noea typespec_reserved_attr
    1095. 

  1095. 		{ $$ = declspecs_add_type ($1, $2); }
    1096. 

  1096. 	| declspecs_sc_ts_sa_ea typespec_reserved_attr
    1097. 

  1097. 		{ $$ = declspecs_add_type ($1, $2); }
    1098. 

  1098. 	| declspecs_sc_nots_sa_noea typespec_attr
    1099. 

  1099. 		{ $$ = declspecs_add_type ($1, $2); }
    1100. 

  1100. 	| declspecs_sc_nots_sa_ea typespec_attr
    1101. 

  1101. 		{ $$ = declspecs_add_type ($1, $2); }
    1102. 

  1102. 	;
    1103. 

  1103. 

  1104. /* Particular useful classes of declspecs.  */
    1105. 

  1105. declspecs_ts:
    1106. 

  1106. 	  declspecs_nosc_ts_nosa_noea
    1107. 

  1107. 	| declspecs_nosc_ts_nosa_ea
    1108. 

  1108. 	| declspecs_nosc_ts_sa_noea
    1109. 

  1109. 	| declspecs_nosc_ts_sa_ea
    1110. 

  1110. 	| declspecs_sc_ts_nosa_noea
    1111. 

  1111. 	| declspecs_sc_ts_nosa_ea
    1112. 

  1112. 	| declspecs_sc_ts_sa_noea
    1113. 

  1113. 	| declspecs_sc_ts_sa_ea
    1114. 

  1114. 	;
    1115. 

  1115. 

  1116. declspecs_nots:
    1117. 

  1117. 	  declspecs_nosc_nots_nosa_noea
    1118. 

  1118. 	| declspecs_nosc_nots_nosa_ea
    1119. 

  1119. 	| declspecs_nosc_nots_sa_noea
    1120. 

  1120. 	| declspecs_nosc_nots_sa_ea
    1121. 

  1121. 	| declspecs_sc_nots_nosa_noea
    1122. 

  1122. 	| declspecs_sc_nots_nosa_ea
    1123. 

  1123. 	| declspecs_sc_nots_sa_noea
    1124. 

  1124. 	| declspecs_sc_nots_sa_ea
    1125. 

  1125. 	;
    1126. 

  1126. 

  1127. declspecs_ts_nosa:
    1128. 

  1128. 	  declspecs_nosc_ts_nosa_noea
    1129. 

  1129. 	| declspecs_nosc_ts_nosa_ea
    1130. 

  1130. 	| declspecs_sc_ts_nosa_noea
    1131. 

  1131. 	| declspecs_sc_ts_nosa_ea
    1132. 

  1132. 	;
    1133. 

  1133. 

  1134. declspecs_nots_nosa:
    1135. 

  1135. 	  declspecs_nosc_nots_nosa_noea
    1136. 

  1136. 	| declspecs_nosc_nots_nosa_ea
    1137. 

  1137. 	| declspecs_sc_nots_nosa_noea
    1138. 

  1138. 	| declspecs_sc_nots_nosa_ea
    1139. 

  1139. 	;
    1140. 

  1140. 

  1141. declspecs_nosc_ts:
    1142. 

  1142. 	  declspecs_nosc_ts_nosa_noea
    1143. 

  1143. 	| declspecs_nosc_ts_nosa_ea
    1144. 

  1144. 	| declspecs_nosc_ts_sa_noea
    1145. 

  1145. 	| declspecs_nosc_ts_sa_ea
    1146. 

  1146. 	;
    1147. 

  1147. 

  1148. declspecs_nosc_nots:
    1149. 

  1149. 	  declspecs_nosc_nots_nosa_noea
    1150. 

  1150. 	| declspecs_nosc_nots_nosa_ea
    1151. 

  1151. 	| declspecs_nosc_nots_sa_noea
    1152. 

  1152. 	| declspecs_nosc_nots_sa_ea
    1153. 

  1153. 	;
    1154. 

  1154. 

  1155. declspecs_nosc:
    1156. 

  1156. 	  declspecs_nosc_ts_nosa_noea
    1157. 

  1157. 	| declspecs_nosc_ts_nosa_ea
    1158. 

  1158. 	| declspecs_nosc_ts_sa_noea
    1159. 

  1159. 	| declspecs_nosc_ts_sa_ea
    1160. 

  1160. 	| declspecs_nosc_nots_nosa_noea
    1161. 

  1161. 	| declspecs_nosc_nots_nosa_ea
    1162. 

  1162. 	| declspecs_nosc_nots_sa_noea
    1163. 

  1163. 	| declspecs_nosc_nots_sa_ea
    1164. 

  1164. 	;
    1165. 

  1165. 

  1166. declspecs:
    1167. 

  1167. 	  declspecs_nosc_nots_nosa_noea
    1168. 

  1168. 	| declspecs_nosc_nots_nosa_ea
    1169. 

  1169. 	| declspecs_nosc_nots_sa_noea
    1170. 

  1170. 	| declspecs_nosc_nots_sa_ea
    1171. 

  1171. 	| declspecs_nosc_ts_nosa_noea
    1172. 

  1172. 	| declspecs_nosc_ts_nosa_ea
    1173. 

  1173. 	| declspecs_nosc_ts_sa_noea
    1174. 

  1174. 	| declspecs_nosc_ts_sa_ea
    1175. 

  1175. 	| declspecs_sc_nots_nosa_noea
    1176. 

  1176. 	| declspecs_sc_nots_nosa_ea
    1177. 

  1177. 	| declspecs_sc_nots_sa_noea
    1178. 

  1178. 	| declspecs_sc_nots_sa_ea
    1179. 

  1179. 	| declspecs_sc_ts_nosa_noea
    1180. 

  1180. 	| declspecs_sc_ts_nosa_ea
    1181. 

  1181. 	| declspecs_sc_ts_sa_noea
    1182. 

  1182. 	| declspecs_sc_ts_sa_ea
    1183. 

  1183. 	;
    1184. 

  1184. 

  1185. /* A (possibly empty) sequence of type qualifiers and attributes.  */
    1186. 

  1186. maybe_type_quals_attrs:
    1187. 

  1187. 	  /* empty */
    1188. 

  1188. 		{ $$ = NULL; }
    1189. 

  1189. 	| declspecs_nosc_nots
    1190. 

  1190. 		{ $$ = $1; }
    1191. 

  1191. 	;
    1192. 

  1192. 

  1193. /* A type specifier (but not a type qualifier).
    1194. 

  1194.    Once we have seen one of these in a declaration,
    1195. 

  1195.    if a typedef name appears then it is being redeclared.
    1196. 

    1197. 

  1197.    The _reserved versions start with a reserved word and may appear anywhere
    1198. 

  1198.    in the declaration specifiers; the _nonreserved versions may only
    1199. 

  1199.    appear before any other type specifiers, and after that are (if names)
    1200. 

  1200.    being redeclared.
    1201. 

    1202. 

  1202.    FIXME: should the _nonreserved version be restricted to names being
    1203. 

  1203.    redeclared only?  The other entries there relate only the GNU extensions
    1204. 

  1204.    and Objective C, and are historically parsed thus, and don't make sense
    1205. 

  1205.    after other type specifiers, but it might be cleaner to count them as
    1206. 

  1206.    _reserved.
    1207. 

    1208. 

  1208.    _attr means: specifiers that either end with attributes,
    1209. 

  1209.    or are such that any following attributes would
    1210. 

  1210.    be parsed as part of the specifier.
    1211. 

    1212. 

  1212.    _nonattr: other specifiers not ending with attributes.  */
    1213. 

  1213. 

  1214. typespec_nonattr:
    1215. 

  1215. 	  typespec_reserved_nonattr
    1216. 

  1216. 	| typespec_nonreserved_nonattr
    1217. 

  1217. 	;
    1218. 

  1218. 

  1219. typespec_attr:
    1220. 

  1220. 	  typespec_reserved_attr
    1221. 

  1221. 	;
    1222. 

  1222. 

  1223. typespec_reserved_nonattr:
    1224. 

  1224. 	  TYPESPEC
    1225. 

  1225. 		{ OBJC_NEED_RAW_IDENTIFIER (1);
    1226. 

  1226. 		  $$.kind = ctsk_resword;
    1227. 

  1227. 		  $$.spec = $1; }
    1228. 

  1228. 	| structsp_nonattr
    1229. 

  1229. 	;
    1230. 

  1230. 

  1231. typespec_reserved_attr:
    1232. 

  1232. 	  structsp_attr
    1233. 

  1233. 	;
    1234. 

  1234. 

  1235. typespec_nonreserved_nonattr:
    1236. 

  1236. 	  TYPENAME
    1237. 

  1237. 		{ /* For a typedef name, record the meaning, not the name.
    1238. 

  1238. 		     In case of `foo foo, bar;'.  */
    1239. 

  1239. 		  $$.kind = ctsk_typedef;
    1240. 

  1240. 		  $$.spec = lookup_name ($1); }
    1241. 

  1241. 	| typeof '(' expr ')'
    1242. 

  1242. 		{ skip_evaluation--;
    1243. 

  1243. 		  in_typeof--;
    1244. 

  1244. 		  if (TREE_CODE ($3.value) == COMPONENT_REF
    1245. 

  1245. 		      &amp;&amp; DECL_C_BIT_FIELD (TREE_OPERAND ($3.value, 1)))
    1246. 

  1246. 		    error (&quot;%&lt;typeof%&gt; applied to a bit-field&quot;);
    1247. 

  1247. 		  $$.kind = ctsk_typeof;
    1248. 

  1248. 		  $$.spec = TREE_TYPE ($3.value);
    1249. 

  1249. 		  pop_maybe_used (variably_modified_type_p ($$.spec,
    1250. 

  1250. 							    NULL_TREE)); }
    1251. 

  1251. 	| typeof '(' typename ')'
    1252. 

  1252. 		{ skip_evaluation--;
    1253. 

  1253. 		  in_typeof--;
    1254. 

  1254. 		  $$.kind = ctsk_typeof;
    1255. 

  1255. 		  $$.spec = groktypename ($3);
    1256. 

  1256. 		  pop_maybe_used (variably_modified_type_p ($$.spec,
    1257. 

  1257. 							    NULL_TREE)); }
    1258. 

  1258. 	;
    1259. 

  1259. 

  1260. /* typespec_nonreserved_attr does not exist.  */
    1261. 

  1261. 

  1262. initdecls:
    1263. 

  1263. 	initdcl
    1264. 

  1264. 	| initdecls ',' maybe_resetattrs initdcl
    1265. 

  1265. 	;
    1266. 

  1266. 

  1267. notype_initdecls:
    1268. 

  1268. 	notype_initdcl
    1269. 

  1269. 	| notype_initdecls ',' maybe_resetattrs notype_initdcl
    1270. 

  1270. 	;
    1271. 

  1271. 

  1272. initdcl:
    1273. 

  1273. 	  declarator maybeasm maybe_attribute '='
    1274. 

  1274. 		{ $&lt;ttype&gt;$ = start_decl ($1, current_declspecs, true,
    1275. 

  1275. 					  chainon ($3, all_prefix_attributes));
    1276. 

  1276. 		  if (!$&lt;ttype&gt;$)
    1277. 

  1277. 		    $&lt;ttype&gt;$ = error_mark_node;
    1278. 

  1278. 		  start_init ($&lt;ttype&gt;$, $2, global_bindings_p ()); }
    1279. 

  1279. 	  init
    1280. 

  1280. /* Note how the declaration of the variable is in effect while its init is parsed! */
    1281. 

  1281. 		{ finish_init ();
    1282. 

  1282. 		  if ($&lt;ttype&gt;5 != error_mark_node)
    1283. 

  1283. 		    {
    1284. 

  1284. 		      maybe_warn_string_init (TREE_TYPE ($&lt;ttype&gt;5), $6);
    1285. 

  1285. 		      finish_decl ($&lt;ttype&gt;5, $6.value, $2);
    1286. 

  1286. 		    }
    1287. 

  1287. 		}
    1288. 

  1288. 	| declarator maybeasm maybe_attribute
    1289. 

  1289. 		{ tree d = start_decl ($1, current_declspecs, false,
    1290. 

  1290. 				       chainon ($3, all_prefix_attributes));
    1291. 

  1291. 		  if (d)
    1292. 

  1292. 		    finish_decl (d, NULL_TREE, $2);
    1293. 

  1293.                 }
    1294. 

  1294. 	;
    1295. 

  1295. 

  1296. notype_initdcl:
    1297. 

  1297. 	  notype_declarator maybeasm maybe_attribute '='
    1298. 

  1298. 		{ $&lt;ttype&gt;$ = start_decl ($1, current_declspecs, true,
    1299. 

  1299. 					  chainon ($3, all_prefix_attributes));
    1300. 

  1300. 		  if (!$&lt;ttype&gt;$)
    1301. 

  1301. 		    $&lt;ttype&gt;$ = error_mark_node;
    1302. 

  1302. 		  start_init ($&lt;ttype&gt;$, $2, global_bindings_p ()); }
    1303. 

  1303. 	  init
    1304. 

  1304. /* Note how the declaration of the variable is in effect while its init is parsed! */
    1305. 

  1305. 		{ finish_init ();
    1306. 

  1306. 		  if ($&lt;ttype&gt;5 != error_mark_node)
    1307. 

  1307. 		    {
    1308. 

  1308. 		      maybe_warn_string_init (TREE_TYPE ($&lt;ttype&gt;5), $6);
    1309. 

  1309. 		      finish_decl ($&lt;ttype&gt;5, $6.value, $2);
    1310. 

  1310. 		    }
    1311. 

  1311. 		}
    1312. 

  1312. 	| notype_declarator maybeasm maybe_attribute
    1313. 

  1313. 		{ tree d = start_decl ($1, current_declspecs, false,
    1314. 

  1314. 				       chainon ($3, all_prefix_attributes));
    1315. 

  1315. 		  if (d)
    1316. 

  1316.                     finish_decl (d, NULL_TREE, $2); }
    1317. 

  1317. 	;
    1318. 

  1318. /* the * rules are dummies to accept the Apollo extended syntax
    1319. 

  1319.    so that the header files compile. */
    1320. 

  1320. maybe_attribute:
    1321. 

  1321.       /* empty */
    1322. 

  1322. 		{ $$ = NULL_TREE; }
    1323. 

  1323. 	| attributes
    1324. 

  1324. 		{ $$ = $1; }
    1325. 

  1325. 	;
    1326. 

  1326. 

  1327. attributes:
    1328. 

  1328.       attribute
    1329. 

  1329. 		{ $$ = $1; }
    1330. 

  1330. 	| attributes attribute
    1331. 

  1331. 		{ $$ = chainon ($1, $2); }
    1332. 

  1332. 	;
    1333. 

  1333. 

  1334. attribute:
    1335. 

  1335.       ATTRIBUTE stop_string_translation
    1336. 

  1336.                 '(' '(' attribute_list ')' ')' start_string_translation
    1337. 

  1337. 		{ $$ = $5; }
    1338. 

  1338.       | ATTRIBUTE error start_string_translation
    1339. 

  1339.                 { $$ = NULL_TREE; }
    1340. 

  1340. 	;
    1341. 

  1341. 

  1342. attribute_list:
    1343. 

  1343.       attrib
    1344. 

  1344. 		{ $$ = $1; }
    1345. 

  1345. 	| attribute_list ',' attrib
    1346. 

  1346. 		{ $$ = chainon ($1, $3); }
    1347. 

  1347. 	;
    1348. 

  1348. 

  1349. attrib:
    1350. 

  1350.     /* empty */
    1351. 

  1351. 		{ $$ = NULL_TREE; }
    1352. 

  1352. 	| any_word
    1353. 

  1353. 		{ $$ = build_tree_list ($1, NULL_TREE); }
    1354. 

  1354. 	| any_word '(' IDENTIFIER ')'
    1355. 

  1355. 		{ $$ = build_tree_list ($1, build_tree_list (NULL_TREE, $3)); }
    1356. 

  1356. 	| any_word '(' IDENTIFIER ',' nonnull_exprlist ')'
    1357. 

  1357. 		{ $$ = build_tree_list ($1, tree_cons (NULL_TREE, $3, $5)); }
    1358. 

  1358. 	| any_word '(' exprlist ')'
    1359. 

  1359. 		{ $$ = build_tree_list ($1, $3); }
    1360. 

  1360. 	;
    1361. 

  1361. 

  1362. /* This still leaves out most reserved keywords,
    1363. 

  1363.    shouldn't we include them?  */
    1364. 

  1364. 

  1365. any_word:
    1366. 

  1366. 	  identifier
    1367. 

  1367. 	| scspec
    1368. 

  1368. 	| TYPESPEC
    1369. 

  1369. 	| TYPE_QUAL
    1370. 

  1370. 	;
    1371. 

  1371. 

  1372. scspec:
    1373. 

  1373. 	  STATIC
    1374. 

  1374. 	| SCSPEC
    1375. 

  1375. 	;
    1376. 

  1376. 
    1377. 

  1377. /* Initializers.  `init' is the entry point.  */
    1378. 

  1378. 

  1379. init:
    1380. 

  1380. 	expr_no_commas
    1381. 

  1381. 		{ $$ = $1; }
    1382. 

  1382. 	| '{'
    1383. 

  1383. 		{ really_start_incremental_init (NULL_TREE); }
    1384. 

  1384. 	  initlist_maybe_comma '}'
    1385. 

  1385. 		{ $$ = pop_init_level (0); }
    1386. 

  1386. 	| error
    1387. 

  1387. 		{ $$.value = error_mark_node; $$.original_code = ERROR_MARK; }
    1388. 

  1388. 	;
    1389. 

  1389. 

  1390. /* `initlist_maybe_comma' is the guts of an initializer in braces.  */
    1391. 

  1391. initlist_maybe_comma:
    1392. 

  1392. 	  /* empty */
    1393. 

  1393. 		{ if (pedantic)
    1394. 

  1394. 		    pedwarn (&quot;ISO C forbids empty initializer braces&quot;); }
    1395. 

  1395. 	| initlist1 maybecomma
    1396. 

  1396. 	;
    1397. 

  1397. 

  1398. initlist1:
    1399. 

  1399. 	  initelt
    1400. 

  1400. 	| initlist1 ',' initelt
    1401. 

  1401. 	;
    1402. 

  1402. 

  1403. /* `initelt' is a single element of an initializer.
    1404. 

  1404.    It may use braces.  */
    1405. 

  1405. initelt:
    1406. 

  1406. 	  designator_list '=' initval
    1407. 

  1407. 		{ if (pedantic &amp;&amp; !flag_isoc99)
    1408. 

  1408. 		    pedwarn (&quot;ISO C90 forbids specifying subobject to initialize&quot;); }
    1409. 

  1409. 	| array_designator initval
    1410. 

  1410. 		{ if (pedantic)
    1411. 

  1411. 		    pedwarn (&quot;obsolete use of designated initializer without %&lt;=%&gt;&quot;); }
    1412. 

  1412. 	| identifier ':'
    1413. 

  1413. 		{ set_init_label ($1);
    1414. 

  1414. 		  if (pedantic)
    1415. 

  1415. 		    pedwarn (&quot;obsolete use of designated initializer with %&lt;:%&gt;&quot;); }
    1416. 

  1416. 	  initval
    1417. 

  1417. 		{}
    1418. 

  1418. 	| initval
    1419. 

  1419. 	;
    1420. 

  1420. 

  1421. initval:
    1422. 

  1422. 	  '{'
    1423. 

  1423. 		{ push_init_level (0); }
    1424. 

  1424. 	  initlist_maybe_comma '}'
    1425. 

  1425. 		{ process_init_element (pop_init_level (0)); }
    1426. 

  1426. 	| expr_no_commas
    1427. 

  1427. 		{ process_init_element ($1); }
    1428. 

  1428. 	| error
    1429. 

  1429. 	;
    1430. 

  1430. 

  1431. designator_list:
    1432. 

  1432. 	  designator
    1433. 

  1433. 	| designator_list designator
    1434. 

  1434. 	;
    1435. 

  1435. 

  1436. designator:
    1437. 

  1437. 	  '.' identifier
    1438. 

  1438. 		{ set_init_label ($2); }
    1439. 

  1439. 	| array_designator
    1440. 

  1440. 	;
    1441. 

  1441. 

  1442. array_designator:
    1443. 

  1443. 	  '[' expr_no_commas ELLIPSIS expr_no_commas ']'
    1444. 

  1444. 		{ set_init_index ($2.value, $4.value);
    1445. 

  1445. 		  if (pedantic)
    1446. 

  1446. 		    pedwarn (&quot;ISO C forbids specifying range of elements to initialize&quot;); }
    1447. 

  1447. 	| '[' expr_no_commas ']'
    1448. 

  1448. 		{ set_init_index ($2.value, NULL_TREE); }
    1449. 

  1449. 	;
    1450. 

  1450. 
    1451. 

  1451. nested_function:
    1452. 

  1452. 	declarator
    1453. 

  1453. 		{ if (pedantic)
    1454. 

  1454. 		    pedwarn (&quot;ISO C forbids nested functions&quot;);
    1455. 

  1455. 

  1456. 		  push_function_context ();
    1457. 

  1457. 		  if (!start_function (current_declspecs, $1,
    1458. 

  1458. 				       all_prefix_attributes))
    1459. 

  1459. 		    {
    1460. 

  1460. 		      pop_function_context ();
    1461. 

  1461. 		      YYERROR1;
    1462. 

  1462. 		    }
    1463. 

  1463. 		}
    1464. 

  1464. 	old_style_parm_decls save_location
    1465. 

  1465. 		{ tree decl = current_function_decl;
    1466. 

  1466. 		  DECL_SOURCE_LOCATION (decl) = $4;
    1467. 

  1467. 		  store_parm_decls (); }
    1468. 

  1468. 	/* This used to use compstmt_or_error.  That caused a bug with
    1469. 

  1469. 	   input `f(g) int g {}', where the use of YYERROR1 above caused
    1470. 

  1470. 	   an error which then was handled by compstmt_or_error.  There
    1471. 

  1471. 	   followed a repeated execution of that same rule, which called
    1472. 

  1472. 	   YYERROR1 again, and so on.  */
    1473. 

  1473. 	compstmt
    1474. 

  1474. 		{ tree decl = current_function_decl;
    1475. 

  1475. 		  add_stmt ($6);
    1476. 

  1476. 		  finish_function ();
    1477. 

  1477. 		  pop_function_context ();
    1478. 

  1478. 		  add_stmt (build_stmt (DECL_EXPR, decl)); }
    1479. 

  1479. 	;
    1480. 

  1480. 

  1481. notype_nested_function:
    1482. 

  1482. 	notype_declarator
    1483. 

  1483. 		{ if (pedantic)
    1484. 

  1484. 		    pedwarn (&quot;ISO C forbids nested functions&quot;);
    1485. 

  1485. 

  1486. 		  push_function_context ();
    1487. 

  1487. 		  if (!start_function (current_declspecs, $1,
    1488. 

  1488. 				       all_prefix_attributes))
    1489. 

  1489. 		    {
    1490. 

  1490. 		      pop_function_context ();
    1491. 

  1491. 		      YYERROR1;
    1492. 

  1492. 		    }
    1493. 

  1493. 		}
    1494. 

  1494. 	old_style_parm_decls save_location
    1495. 

  1495. 		{ tree decl = current_function_decl;
    1496. 

  1496. 		  DECL_SOURCE_LOCATION (decl) = $4;
    1497. 

  1497. 		  store_parm_decls (); }
    1498. 

  1498. 	/* This used to use compstmt_or_error.  That caused a bug with
    1499. 

  1499. 	   input `f(g) int g {}', where the use of YYERROR1 above caused
    1500. 

  1500. 	   an error which then was handled by compstmt_or_error.  There
    1501. 

  1501. 	   followed a repeated execution of that same rule, which called
    1502. 

  1502. 	   YYERROR1 again, and so on.  */
    1503. 

  1503. 	compstmt
    1504. 

  1504. 		{ tree decl = current_function_decl;
    1505. 

  1505. 		  add_stmt ($6);
    1506. 

  1506. 		  finish_function ();
    1507. 

  1507. 		  pop_function_context ();
    1508. 

  1508. 		  add_stmt (build_stmt (DECL_EXPR, decl)); }
    1509. 

  1509. 	;
    1510. 

  1510. 

  1511. /* Any kind of declarator (thus, all declarators allowed
    1512. 

  1512.    after an explicit typespec).  */
    1513. 

  1513. 

  1514. declarator:
    1515. 

  1515. 	  after_type_declarator
    1516. 

  1516. 	| notype_declarator
    1517. 

  1517. 	;
    1518. 

  1518. 

  1519. /* A declarator that is allowed only after an explicit typespec.  */
    1520. 

  1520. 

  1521. after_type_declarator:
    1522. 

  1522. 	  '(' maybe_attribute after_type_declarator ')'
    1523. 

  1523. 		{ $$ = $2 ? build_attrs_declarator ($2, $3) : $3; }
    1524. 

  1524. 	| after_type_declarator '(' parmlist_or_identifiers  %prec '.'
    1525. 

  1525. 		{ $$ = build_function_declarator ($3, $1); }
    1526. 

  1526. 	| after_type_declarator array_declarator  %prec '.'
    1527. 

  1527. 		{ $$ = set_array_declarator_inner ($2, $1, false); }
    1528. 

  1528. 	| '*' maybe_type_quals_attrs after_type_declarator  %prec UNARY
    1529. 

  1529. 		{ $$ = make_pointer_declarator ($2, $3); }
    1530. 

  1530. 	| TYPENAME
    1531. 

  1531. 		{ $$ = build_id_declarator ($1); }
    1532. 

  1532. 	;
    1533. 

  1533. 

  1534. /* Kinds of declarator that can appear in a parameter list
    1535. 

  1535.    in addition to notype_declarator.  This is like after_type_declarator
    1536. 

  1536.    but does not allow a typedef name in parentheses as an identifier
    1537. 

  1537.    (because it would conflict with a function with that typedef as arg).  */
    1538. 

  1538. parm_declarator:
    1539. 

  1539. 	  parm_declarator_starttypename
    1540. 

  1540. 	| parm_declarator_nostarttypename
    1541. 

  1541. 	;
    1542. 

  1542. 

  1543. parm_declarator_starttypename:
    1544. 

  1544. 	  parm_declarator_starttypename '(' parmlist_or_identifiers  %prec '.'
    1545. 

  1545. 		{ $$ = build_function_declarator ($3, $1); }
    1546. 

  1546. 	| parm_declarator_starttypename array_declarator  %prec '.'
    1547. 

  1547. 		{ $$ = set_array_declarator_inner ($2, $1, false); }
    1548. 

  1548. 	| TYPENAME
    1549. 

  1549. 		{ $$ = build_id_declarator ($1); }
    1550. 

  1550. 	;
    1551. 

  1551. 

  1552. parm_declarator_nostarttypename:
    1553. 

  1553. 	  parm_declarator_nostarttypename '(' parmlist_or_identifiers  %prec '.'
    1554. 

  1554. 		{ $$ = build_function_declarator ($3, $1); }
    1555. 

  1555. 	| parm_declarator_nostarttypename array_declarator  %prec '.'
    1556. 

  1556. 		{ $$ = set_array_declarator_inner ($2, $1, false); }
    1557. 

  1557. 	| '*' maybe_type_quals_attrs parm_declarator_starttypename  %prec UNARY
    1558. 

  1558. 		{ $$ = make_pointer_declarator ($2, $3)…
    1559.

Large files files are truncated, but you can click here to view the full file