PageRenderTime 65ms CodeModel.GetById 27ms RepoModel.GetById 0ms app.codeStats 1ms

/opensource.apple.com/source/gcc_legacy/gcc_legacy-938/gcc/obcp/parse.y

#
Happy | 2042 lines | 1844 code | 198 blank | 0 comment | 0 complexity | 8c98f23d63dfb872a6c76e1023ec4bfa MD5 | raw file
Possible License(s): LGPL-2.0, MPL-2.0, GPL-2.0, ISC, LGPL-2.1, Apache-2.0, MPL-2.0-no-copyleft-exception, BSD-3-Clause, WTFPL, MIT, AGPL-1.0, AGPL-3.0

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>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">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. /* YACC parser for Objective-C++ syntax.
    24. 

  24.    Copyright (C) 1988, 89, 93-98, 1999 Free Software Foundation, Inc.
    25. 

  25.    Hacked by Michael Tiemann (<a href="mailto:tiemann@cygnus.com">tiemann@cygnus.com</a>)
    26. 

    27. 

  27. This file is part of GNU CC.
    28. 

    29. 

  29. GNU CC is free software; you can redistribute it and/or modify
    30. 

  30. it under the terms of the GNU General Public License as published by
    31. 

  31. the Free Software Foundation; either version 2, or (at your option)
    32. 

  32. any later version.
    33. 

    34. 

  34. GNU CC is distributed in the hope that it will be useful,
    35. 

  35. but WITHOUT ANY WARRANTY; without even the implied warranty of
    36. 

  36. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    37. 

  37. GNU General Public License for more details.
    38. 

    39. 

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

  40. along with GNU CC; see the file COPYING.  If not, write to
    41. 

  41. the Free Software Foundation, 59 Temple Place - Suite 330,
    42. 

  42. Boston, MA 02111-1307, USA.  */
    43. 

  43. 

  44. 

  45. /* This grammar is based on the GNU CC grammar.  */
    46. 

  46. 

  47. /* Note: Bison automatically applies a default action of &quot;$$ = $1&quot; for
    48. 

  48.    all derivations; this is applied before the explicit action, if one
    49. 

  49.    is given.  Keep this in mind when reading the actions.  */
    50. 

  50. 

  51. %{
    52. 

  52. /* Cause the `yydebug' variable to be defined.  */
    53. 

  53. #define YYDEBUG 1
    54. 

  54. 

  55. #include &quot;config.h&quot;
    56. 

  56. 

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

  58. 

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

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

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

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

  63. #include &quot;cp-tree.h&quot;
    64. 

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

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

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

  67. 

  68. #ifdef OBJCPLUS
    69. 

  69. #include &quot;objc-act.h&quot;
    70. 

  70. 

  71. /* the `decl' list operators optimization is not appropriate for Objective-C */
    72. 

  72. #define build_decl_list 	build_tree_list
    73. 

  73. #define decl_tree_cons 		tree_cons
    74. 

  74. #endif
    75. 

  75. 

  76. /* Since parsers are distinct for each language, put the language string
    77. 

  77.    definition here.  (fnf) */
    78. 

  78. #ifdef OBJCPLUS
    79. 

  79. char *language_string = &quot;GNU Obj-C++&quot;;
    80. 

  80. #else   
    81. 

  81. char *language_string = &quot;GNU C++&quot;;
    82. 

  82. #endif
    83. 

  83. 

  84. extern tree void_list_node;
    85. 

  85. extern struct obstack permanent_obstack;
    86. 

  86. 

  87. extern int end_of_file;
    88. 

  88. extern int flag_new_for_scope;
    89. 

  89. 

  90. /* Like YYERROR but do call yyerror.  */
    91. 

  91. #define YYERROR1 { yyerror (&quot;syntax error&quot;); YYERROR; }
    92. 

  92. 

  93. #define OP0(NODE) (TREE_OPERAND (NODE, 0))
    94. 

  94. #define OP1(NODE) (TREE_OPERAND (NODE, 1))
    95. 

  95. 

  96. /* Contains the statement keyword (if/while/do) to include in an
    97. 

  97.    error message if the user supplies an empty conditional expression.  */
    98. 

  98. static const char *cond_stmt_keyword;
    99. 

  99. 

  100. static tree empty_parms PROTO((void));
    101. 

  101. static int parse_decl PROTO((tree, tree, tree, int, tree *));
    102. 

  102. 

  103. /* Nonzero if we have an `extern &quot;C&quot;' acting as an extern specifier.  */
    104. 

  104. int have_extern_spec;
    105. 

  105. int used_extern_spec;
    106. 

  106. 

  107. /* Cons up an empty parameter list.  */
    108. 

  108. #ifdef __GNUC__
    109. 

  109. __inline
    110. 

  110. #endif
    111. 

  111. static tree
    112. 

  112. empty_parms ()
    113. 

  113. {
    114. 

  114.   tree parms;
    115. 

  115. 

  116.   if (strict_prototype
    117. 

  117.       || current_class_type != NULL)
    118. 

  118.     parms = void_list_node;
    119. 

  119.   else
    120. 

  120.     parms = NULL_TREE;
    121. 

  121.   return parms;
    122. 

  122. }
    123. 

  123. 

  124. %}
    125. 

  125. 

  126. %start program
    127. 

  127. 

  128. %union {long itype; tree ttype; char *strtype; enum tree_code code; flagged_type_tree ftype; }
    129. 

  129. 

  130. /* All identifiers that are not reserved words
    131. 

  131.    and are not declared typedefs in the current block */
    132. 

  132. %token IDENTIFIER
    133. 

  133. 

  134. /* All identifiers that are declared typedefs in the current block.
    135. 

  135.    In some contexts, they are treated just like IDENTIFIER,
    136. 

  136.    but they can also serve as typespecs in declarations.  */
    137. 

  137. %token TYPENAME
    138. 

  138. %token SELFNAME
    139. 

  139. /* Objective-C */
    140. 

  140. %token CLASSNAME
    141. 

  141. %token OBJECTNAME
    142. 

  142. 

  143. /* A template function.  */
    144. 

  144. %token PFUNCNAME
    145. 

  145. 

  146. /* Reserved words that specify storage class.
    147. 

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

  148. %token SCSPEC
    149. 

  149. 

  150. /* Reserved words that specify type.
    151. 

  151.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
    152. 

  152. %token TYPESPEC
    153. 

  153. 

  154. /* Reserved words that qualify type: &quot;const&quot; or &quot;volatile&quot;.
    155. 

  155.    yylval contains an IDENTIFIER_NODE which indicates which one.  */
    156. 

  156. %token CV_QUALIFIER
    157. 

  157. 

  158. /* Character or numeric constants.
    159. 

  159.    yylval is the node for the constant.  */
    160. 

  160. %token CONSTANT
    161. 

  161. 

  162. /* String constants in raw form.
    163. 

  163.    yylval is a STRING_CST node.  */
    164. 

  164. %token STRING
    165. 

  165. 

  166. /* &quot;...&quot;, used for functions with variable arglists.  */
    167. 

  167. %token ELLIPSIS
    168. 

  168. 

  169. /* the reserved words */
    170. 

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

  171. %token SIZEOF ENUM /* STRUCT UNION */ IF ELSE WHILE DO FOR SWITCH CASE DEFAULT
    172. 

  172. %token BREAK CONTINUE RETURN_KEYWORD GOTO ASM_KEYWORD TYPEOF ALIGNOF
    173. 

  173. %token SIGOF
    174. 

  174. %token ATTRIBUTE EXTENSION LABEL
    175. 

  175. %token REALPART IMAGPART
    176. 

  176. 

  177. %token VEC_STEP
    178. 

  178. 

  179. /* the reserved words... C++ extensions */
    180. 

  180. %token &lt;ttype&gt; AGGR
    181. 

  181. %token &lt;ttype&gt; VISSPEC
    182. 

  182. %token DELETE NEW THIS OPERATOR CXX_TRUE CXX_FALSE
    183. 

  183. %token NAMESPACE TYPENAME_KEYWORD USING
    184. 

  184. %token LEFT_RIGHT TEMPLATE
    185. 

  185. %token TYPEID DYNAMIC_CAST STATIC_CAST REINTERPRET_CAST CONST_CAST
    186. 

  186. %token &lt;itype&gt; SCOPE
    187. 

  187. 

  188. /* The Objective-C keywords.   */
    189. 

  189. %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE
    190. 

  190. %token PUBLIC PRIVATE PROTECTED PROTOCOL CLASS ALIAS
    191. 

  191. 

  192. /* Objective-C string constants in raw form.
    193. 

  193.    yylval is an OBJC_STRING_CST node.  */
    194. 

  194. %token OBJC_STRING
    195. 

  195. 

  196. /* Define the operator tokens and their precedences.
    197. 

  197.    The value is an integer because, if used, it is the tree code
    198. 

  198.    to use in the expression made from the operator.  */
    199. 

  199. 

  200. %left EMPTY			/* used to resolve s/r with epsilon */
    201. 

  201. 

  202. %left error
    203. 

  203. 

  204. /* Add precedence rules to solve dangling else s/r conflict */
    205. 

  205. %nonassoc IF
    206. 

  206. %nonassoc ELSE
    207. 

  207. 

  208. %left IDENTIFIER PFUNCNAME TYPENAME SELFNAME PTYPENAME SCSPEC TYPESPEC CV_QUALIFIER ENUM AGGR ELLIPSIS TYPEOF SIGOF OPERATOR NSNAME TYPENAME_KEYWORD CLASSNAME OBJECTNAME
    209. 

  209. 

  210. %left '{' ',' ';'
    211. 

  211. 

  212. %nonassoc THROW
    213. 

  213. %right &lt;code&gt; ':'
    214. 

  214. %right &lt;code&gt; ASSIGN '='
    215. 

  215. %right &lt;code&gt; '?'
    216. 

  216. %left &lt;code&gt; OROR
    217. 

  217. %left &lt;code&gt; ANDAND
    218. 

  218. %left &lt;code&gt; '|'
    219. 

  219. %left &lt;code&gt; '^'
    220. 

  220. %left &lt;code&gt; '&amp;'
    221. 

  221. %left &lt;code&gt; MIN_MAX
    222. 

  222. %left &lt;code&gt; EQCOMPARE
    223. 

  223. %left &lt;code&gt; ARITHCOMPARE '&lt;' '&gt;'
    224. 

  224. %left &lt;code&gt; LSHIFT RSHIFT
    225. 

  225. %left &lt;code&gt; '+' '-'
    226. 

  226. %left &lt;code&gt; '*' '/' '%'
    227. 

  227. %left &lt;code&gt; POINTSAT_STAR DOT_STAR
    228. 

  228. %right &lt;code&gt; UNARY PLUSPLUS MINUSMINUS '~'
    229. 

  229. %left HYPERUNARY
    230. 

  230. %left &lt;ttype&gt; PAREN_STAR_PAREN LEFT_RIGHT
    231. 

  231. %left &lt;code&gt; POINTSAT '.' '(' '['
    232. 

  232. 

  233. %right SCOPE			/* C++ extension */
    234. 

  234. %nonassoc NEW DELETE TRY CATCH
    235. 

  235. 

  236. %type &lt;code&gt; unop
    237. 

  237. 

  238. %type &lt;ttype&gt; identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist
    239. 

  239. %type &lt;ttype&gt; PFUNCNAME maybe_identifier
    240. 

  240. %type &lt;ttype&gt; paren_expr_or_null nontrivial_exprlist SELFNAME
    241. 

  241. %type &lt;ttype&gt; expr_no_commas cast_expr unary_expr primary string STRING
    242. 

  242. %type &lt;ttype&gt; reserved_declspecs boolean.literal
    243. 

  243. %type &lt;ttype&gt; reserved_typespecquals
    244. 

  244. %type &lt;ttype&gt; declmods 
    245. 

  245. %type &lt;ttype&gt; SCSPEC TYPESPEC CV_QUALIFIER maybe_cv_qualifier
    246. 

  246. %type &lt;itype&gt; initdecls notype_initdecls initdcl	/* C++ modification */
    247. 

  247. %type &lt;ttype&gt; init initlist maybeasm maybe_init defarg defarg1
    248. 

  248. %type &lt;ttype&gt; asm_operands nonnull_asm_operands asm_operand asm_clobbers
    249. 

  249. %type &lt;ttype&gt; maybe_attribute attributes attribute attribute_list attrib
    250. 

  250. %type &lt;ttype&gt; any_word
    251. 

  251. 

  252. %type &lt;ttype&gt; compstmt implicitly_scoped_stmt
    253. 

  253. 

  254. %type &lt;ttype&gt; declarator notype_declarator after_type_declarator
    255. 

  255. %type &lt;ttype&gt; notype_declarator_intern absdcl_intern
    256. 

  256. %type &lt;ttype&gt; after_type_declarator_intern
    257. 

  257. %type &lt;ttype&gt; direct_notype_declarator direct_after_type_declarator
    258. 

  258. %type &lt;itype&gt; components notype_components
    259. 

  259. %type &lt;ttype&gt; component_decl component_decl_1 
    260. 

  260. %type &lt;ttype&gt; component_declarator component_declarator0
    261. 

  261. %type &lt;ttype&gt; notype_component_declarator notype_component_declarator0
    262. 

  262. %type &lt;ttype&gt; after_type_component_declarator after_type_component_declarator0
    263. 

  263. %type &lt;ttype&gt; enumlist enumerator
    264. 

  264. %type &lt;ttype&gt; absdcl cv_qualifiers
    265. 

  265. %type &lt;ttype&gt; direct_abstract_declarator conversion_declarator
    266. 

  266. %type &lt;ttype&gt; new_declarator direct_new_declarator
    267. 

  267. %type &lt;ttype&gt; xexpr parmlist parms bad_parm 
    268. 

  268. %type &lt;ttype&gt; identifiers_or_typenames
    269. 

  269. %type &lt;ttype&gt; fcast_or_absdcl regcast_or_absdcl
    270. 

  270. %type &lt;ttype&gt; expr_or_declarator expr_or_declarator_intern
    271. 

  271. %type &lt;ttype&gt; complex_notype_declarator
    272. 

  272. %type &lt;ttype&gt; notype_unqualified_id unqualified_id qualified_id
    273. 

  273. %type &lt;ttype&gt; template_id do_id object_template_id notype_template_declarator
    274. 

  274. %type &lt;ttype&gt; overqualified_id notype_qualified_id any_id
    275. 

  275. %type &lt;ttype&gt; complex_direct_notype_declarator functional_cast
    276. 

  276. %type &lt;ttype&gt; complex_parmlist parms_comma 
    277. 

  277. %type &lt;ttype&gt; namespace_qualifier namespace_using_decl
    278. 

  278. 

  279. %type &lt;ftype&gt; type_id new_type_id typed_typespecs typespec typed_declspecs
    280. 

  280. %type &lt;ftype&gt; typed_declspecs1 type_specifier_seq nonempty_cv_qualifiers
    281. 

  281. %type &lt;ftype&gt; structsp typespecqual_reserved parm named_parm full_parm
    282. 

  282. 

  283. /* C++ extensions */
    284. 

  284. %token &lt;ttype&gt; PTYPENAME
    285. 

  285. %token &lt;ttype&gt; PRE_PARSED_FUNCTION_DECL EXTERN_LANG_STRING ALL
    286. 

  286. %token &lt;ttype&gt; PRE_PARSED_CLASS_DECL DEFARG DEFARG_MARKER
    287. 

  287. %type &lt;ttype&gt; component_constructor_declarator
    288. 

  288. %type &lt;ttype&gt; fn.def2 return_id fn.defpen constructor_declarator
    289. 

  289. %type &lt;itype&gt; ctor_initializer_opt function_try_block
    290. 

  290. %type &lt;ttype&gt; named_class_head_sans_basetype
    291. 

  291. %type &lt;ftype&gt; class_head named_class_head 
    292. 

  292. %type &lt;ftype&gt; named_complex_class_head_sans_basetype 
    293. 

  293. %type &lt;ttype&gt; unnamed_class_head
    294. 

  294. %type &lt;ttype&gt; base_class_list
    295. 

  295. %type &lt;ttype&gt; base_class_access_list
    296. 

  296. %type &lt;ttype&gt; base_class maybe_base_class_list base_class.1
    297. 

  297. %type &lt;ttype&gt; exception_specification_opt ansi_raise_identifier ansi_raise_identifiers
    298. 

  298. %type &lt;ttype&gt; operator_name
    299. 

  299. %type &lt;ttype&gt; object aggr
    300. 

  300. %type &lt;itype&gt; new delete .begin_new_placement
    301. 

  301. /* %type &lt;ttype&gt; primary_no_id */
    302. 

  302. %type &lt;ttype&gt; nonmomentary_expr maybe_parmlist
    303. 

  303. %type &lt;itype&gt; initdcl0 notype_initdcl0 member_init_list initdcl0_innards
    304. 

  304. %type &lt;ttype&gt; template_header template_parm_list template_parm
    305. 

  305. %type &lt;ttype&gt; template_type_parm template_template_parm
    306. 

  306. %type &lt;code&gt;  template_close_bracket
    307. 

  307. %type &lt;ttype&gt; apparent_template_type
    308. 

  308. %type &lt;ttype&gt; template_type template_arg_list template_arg_list_opt
    309. 

  309. %type &lt;ttype&gt; template_arg
    310. 

  310. %type &lt;ttype&gt; condition xcond paren_cond_or_null
    311. 

  311. %type &lt;ttype&gt; type_name nested_name_specifier nested_type ptr_to_mem
    312. 

  312. %type &lt;ttype&gt; complete_type_name notype_identifier nonnested_type
    313. 

  313. %type &lt;ttype&gt; complex_type_name nested_name_specifier_1
    314. 

  314. %type &lt;ttype&gt; new_initializer new_placement
    315. 

  315. %type &lt;ttype&gt; using_decl
    316. 

  316. %type &lt;ttype&gt; typename_sub typename_sub0 typename_sub1 typename_sub2
    317. 

  317. %type &lt;ttype&gt; explicit_template_type
    318. 

  318. /* in order to recognize aggr tags as defining and thus shadowing.  */
    319. 

  319. %token TYPENAME_DEFN IDENTIFIER_DEFN PTYPENAME_DEFN
    320. 

  320. %type &lt;ttype&gt; named_class_head_sans_basetype_defn
    321. 

  321. %type &lt;ttype&gt; identifier_defn IDENTIFIER_DEFN TYPENAME_DEFN PTYPENAME_DEFN
    322. 

  322. 

  323. %type &lt;ttype&gt; self_template_type .finish_template_type
    324. 

  324. 

  325. %token NSNAME
    326. 

  326. %type &lt;ttype&gt; NSNAME
    327. 

  327. 

  328. /* Used in lex.c for parsing pragmas.  */
    329. 

  329. %token END_OF_LINE
    330. 

  330. 

  331. /* the Objective-C productions */
    332. 

  332. %type &lt;ttype&gt; ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator
    333. 

  333. %type &lt;ttype&gt; methoddecl unaryselector keywordselector selector methodtype
    334. 

  334. %type &lt;ttype&gt; keyworddecl receiver objcmessageexpr messageargs 
    335. 

  335. %type &lt;ttype&gt; keywordexpr keywordarglist keywordarg reservedword
    336. 

  336. %type &lt;ttype&gt; myparms myparm optparmlist objcselectorexpr 
    337. 

  337. %type &lt;ttype&gt; selectorarg keywordnamelist keywordname objcencodeexpr 
    338. 

  338. %type &lt;ttype&gt; objc_string protocolrefs identifier_list identifier_colon
    339. 

  339. %type &lt;ttype&gt; objcprotocolexpr CLASSNAME OBJC_STRING OBJECTNAME
    340. 

  340. %type &lt;ttype&gt; objc_openbracket.expr objc_closebracket
    341. 

  341. %type &lt;ttype&gt; objc_return_type_mods
    342. 

  342. 

  343. /* lex.c and pt.c depend on this being the last token.  Define
    344. 

  344.    any new tokens before this one!  */
    345. 

  345. %token END_OF_SAVED_INPUT
    346. 

  346. 
    347. 

  347. %{
    348. 

  348. /* List of types and structure classes of the current declaration.  */
    349. 

  349. static tree current_declspecs;
    350. 

  350. 

  351. /* List of prefix attributes in effect.
    352. 

  352.    Prefix attributes are parsed by the reserved_declspecs and declmods
    353. 

  353.    rules.  They create a list that contains *both* declspecs and attrs.  */
    354. 

  354. /* ??? It is not clear yet that all cases where an attribute can now appear in
    355. 

  355.    a declspec list have been updated.  */
    356. 

  356. static tree prefix_attributes;
    357. 

  357. 

  358. /* When defining an aggregate, this is the kind of the most recent one
    359. 

  359.    being defined.  (For example, this might be class_type_node.)  */
    360. 

  360. tree current_aggr;
    361. 

  361. 

  362. /* When defining an enumeration, this is the type of the enumeration.  */
    363. 

  363. static tree current_enum_type;
    364. 

  364. 

  365. /* List of Objective-C specific information */
    366. 

  366. 

  367. tree objc_interface_context;
    368. 

  368. tree objc_implementation_context;
    369. 

  369. tree objc_method_context;
    370. 

  370. tree objc_ivar_chain;
    371. 

  371. tree objc_ivar_context;
    372. 

  372. static enum tree_code objc_inherit_code;
    373. 

  373. int objc_receiver_context = 0;
    374. 

  374. int objc_declarator_context = 0;
    375. 

  375. int objc_msg_context = 0;
    376. 

  376. int objc_public_flag;
    377. 

  377. tree super_type, selector_type, id_type, objc_class_type;
    378. 

  378. tree objc_object_id, objc_class_id, objc_id_id;
    379. 

  379. int objc_need_raw_identifier = 0;
    380. 

  380. int objc_in_method_signature = 0;
    381. 

  381. 

  382. extern char *token_buffer;
    383. 

  383. 

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

  385. 

  386. #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
    387. 

  387. extern void yyprint			PROTO((FILE *, int, YYSTYPE));
    388. 

  388. extern tree combine_strings		PROTO((tree));
    389. 

  389. 

  390. static int
    391. 

  391. parse_decl(declarator, specs_attrs, attributes, initialized, decl)
    392. 

  392.   tree declarator;
    393. 

  393.   tree specs_attrs;
    394. 

  394.   tree attributes;
    395. 

  395.   int initialized;
    396. 

  396.   tree* decl;
    397. 

  397. {
    398. 

  398.   int  sm;
    399. 

  399. 

  400.   split_specs_attrs (specs_attrs, &amp;current_declspecs, &amp;prefix_attributes);
    401. 

  401.   if (current_declspecs
    402. 

  402.       &amp;&amp; TREE_CODE (current_declspecs) != TREE_LIST)
    403. 

  403.     current_declspecs = build_decl_list (NULL_TREE, current_declspecs);
    404. 

  404.   if (have_extern_spec &amp;&amp; !used_extern_spec)
    405. 

  405.     {
    406. 

  406.       current_declspecs = decl_tree_cons (NULL_TREE, 
    407. 

  407. 					  get_identifier (&quot;extern&quot;), 
    408. 

  408. 					  current_declspecs);
    409. 

  409.       used_extern_spec = 1;
    410. 

  410.     }
    411. 

  411.   sm = suspend_momentary ();
    412. 

  412.   *decl = start_decl (declarator, current_declspecs, initialized,
    413. 

  413. 		      attributes, prefix_attributes);
    414. 

  414.   return sm;
    415. 

  415. }
    416. 

  416. %}
    417. 

  417. 
    418. 

  418. %%
    419. 

  419. program:
    420. 

  420. 	  /* empty */
    421. 

  421. 	| extdefs
    422. 

  422.                { finish_translation_unit (); }
    423. 

  423. 	;
    424. 

  424. 

  425. /* the reason for the strange actions in this rule
    426. 

  426.  is so that notype_initdecls when reached via datadef
    427. 

  427.  can find a valid list of type and sc specs in $0.  */
    428. 

  428. 

  429. extdefs:
    430. 

  430. 		{ $&lt;ttype&gt;$ = NULL_TREE; }
    431. 

  431. 	  lang_extdef
    432. 

  432. 		{ $&lt;ttype&gt;$ = NULL_TREE; }
    433. 

  433. 	| extdefs lang_extdef
    434. 

  434. 		{ $&lt;ttype&gt;$ = NULL_TREE; }
    435. 

  435. 	;
    436. 

  436. 

  437. extdefs_opt:
    438. 

  438. 	  extdefs
    439. 

  439. 	| /* empty */
    440. 

  440. 	;
    441. 

  441. 

  442. .hush_warning:
    443. 

  443. 		{ have_extern_spec = 1;
    444. 

  444. 		  used_extern_spec = 0;
    445. 

  445. 		  $&lt;ttype&gt;$ = NULL_TREE; }
    446. 

  446. 	;
    447. 

  447. .warning_ok:
    448. 

  448. 		{ have_extern_spec = 0; }
    449. 

  449. 	;
    450. 

  450. 

  451. extension:
    452. 

  452. 	EXTENSION
    453. 

  453. 		{ $&lt;itype&gt;$ = pedantic;
    454. 

  454. 		  pedantic = 0; }
    455. 

  455. 	;
    456. 

  456. 

  457. asm_keyword:
    458. 

  458. 	  ASM_KEYWORD
    459. 

  459. 	;
    460. 

  460. 

  461. lang_extdef:
    462. 

  462. 		{ if (pending_lang_change) do_pending_lang_change(); }
    463. 

  463. 	  extdef
    464. 

  464. 		{ if (! toplevel_bindings_p () &amp;&amp; ! pseudo_global_level_p())
    465. 

  465. 		  pop_everything (); }
    466. 

  466. 	;
    467. 

  467. 

  468. extdef:
    469. 

  469. 	  fndef eat_saved_input
    470. 

  470. 		{ if (pending_inlines) do_pending_inlines (); }
    471. 

  471. 	| datadef
    472. 

  472. 		{ if (pending_inlines) do_pending_inlines (); }
    473. 

  473.         | objcdef        
    474. 

  474. 	| template_def
    475. 

  475. 		{ if (pending_inlines) do_pending_inlines (); }
    476. 

  476. 	| asm_keyword '(' string ')' ';'
    477. 

  477. 		{ if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
    478. 

  478. 		  assemble_asm ($3); }
    479. 

  479. 	| extern_lang_string '{' extdefs_opt '}'
    480. 

  480. 		{ pop_lang_context (); }
    481. 

  481. 	| extern_lang_string .hush_warning fndef .warning_ok eat_saved_input
    482. 

  482. 		{ if (pending_inlines) do_pending_inlines ();
    483. 

  483. 		  pop_lang_context (); }
    484. 

  484. 	| extern_lang_string .hush_warning datadef .warning_ok
    485. 

  485. 		{ if (pending_inlines) do_pending_inlines ();
    486. 

  486. 		  pop_lang_context (); }
    487. 

  487. 	| NAMESPACE identifier '{'
    488. 

  488. 		{ push_namespace ($2); }
    489. 

  489. 	  extdefs_opt '}'
    490. 

  490. 		{ pop_namespace (); }
    491. 

  491. 	| NAMESPACE '{'
    492. 

  492. 		{ push_namespace (NULL_TREE); }
    493. 

  493. 	  extdefs_opt '}'
    494. 

  494. 		{ pop_namespace (); }
    495. 

  495. 	| namespace_alias
    496. 

  496. 	| using_decl ';'
    497. 

  497. 		{ do_toplevel_using_decl ($1); }
    498. 

  498. 	| using_directive
    499. 

  499. 	| extension extdef
    500. 

  500. 		{ pedantic = $&lt;itype&gt;1; }
    501. 

  501. 	;
    502. 

  502. 

  503. namespace_alias:
    504. 

  504.           NAMESPACE identifier '=' 
    505. 

  505.                 { begin_only_namespace_names (); }
    506. 

  506.           any_id ';'
    507. 

  507. 		{
    508. 

  508. 		  end_only_namespace_names ();
    509. 

  509. 		  if (lastiddecl)
    510. 

  510. 		    $5 = lastiddecl;
    511. 

  511. 		  do_namespace_alias ($2, $5);
    512. 

  512. 		}
    513. 

  513. 	;
    514. 

  514. 

  515. using_decl:
    516. 

  516. 	  USING qualified_id
    517. 

  517. 		{ $$ = $2; }
    518. 

  518. 	| USING global_scope qualified_id
    519. 

  519. 		{ $$ = $3; }
    520. 

  520. 	| USING global_scope unqualified_id
    521. 

  521. 		{ $$ = $3; }
    522. 

  522. 	;
    523. 

  523. 

  524. namespace_using_decl:
    525. 

  525. 	  USING namespace_qualifier identifier
    526. 

  526. 	        { $$ = build_parse_node (SCOPE_REF, $2, $3); }
    527. 

  527. 	| USING global_scope identifier
    528. 

  528. 	        { $$ = build_parse_node (SCOPE_REF, global_namespace, $3); }
    529. 

  529. 	| USING global_scope namespace_qualifier identifier
    530. 

  530. 	        { $$ = build_parse_node (SCOPE_REF, $3, $4); }
    531. 

  531. 	;
    532. 

  532. 

  533. using_directive:
    534. 

  534. 	  USING NAMESPACE
    535. 

  535. 		{ begin_only_namespace_names (); }
    536. 

  536. 	  any_id ';'
    537. 

  537. 		{
    538. 

  538. 		  end_only_namespace_names ();
    539. 

  539. 		  /* If no declaration was found, the using-directive is
    540. 

  540. 		     invalid. Since that was not reported, we need the
    541. 

  541. 		     identifier for the error message. */
    542. 

  542. 		  if (TREE_CODE ($4) == IDENTIFIER_NODE &amp;&amp; lastiddecl)
    543. 

  543. 		    $4 = lastiddecl;
    544. 

  544. 		  do_using_directive ($4);
    545. 

  545. 		}
    546. 

  546. 	;
    547. 

  547. 

  548. namespace_qualifier:
    549. 

  549. 	  NSNAME SCOPE
    550. 

  550. 		{
    551. 

  551. 		  if (TREE_CODE ($$) == IDENTIFIER_NODE)
    552. 

  552. 		    $$ = lastiddecl;
    553. 

  553. 		  got_scope = $$;
    554. 

  554. 		}
    555. 

  555. 	| namespace_qualifier NSNAME SCOPE
    556. 

  556. 		{
    557. 

  557. 		  $$ = $2;
    558. 

  558. 		  if (TREE_CODE ($$) == IDENTIFIER_NODE)
    559. 

  559. 		    $$ = lastiddecl;
    560. 

  560. 		  got_scope = $$;
    561. 

  561. 		}
    562. 

  562. 

  563. any_id:
    564. 

  564. 	  unqualified_id
    565. 

  565. 	| qualified_id
    566. 

  566. 	| global_scope qualified_id
    567. 

  567. 		{ $$ = $2; }
    568. 

  568. 	| global_scope unqualified_id
    569. 

  569. 		{ $$ = $2; }
    570. 

  570. 	;
    571. 

  571. 

  572. extern_lang_string:
    573. 

  573. 	EXTERN_LANG_STRING
    574. 

  574. 		{ push_lang_context ($1); }
    575. 

  575. 	| extern_lang_string EXTERN_LANG_STRING
    576. 

  576. 		{ if (current_lang_name != $2)
    577. 

  577. 		    cp_error (&quot;use of linkage spec `%D' is different from previous spec `%D'&quot;, $2, current_lang_name);
    578. 

  578. 		  pop_lang_context (); push_lang_context ($2); }
    579. 

  579. 	;
    580. 

  580. 

  581. template_header:
    582. 

  582. 	  TEMPLATE '&lt;'
    583. 

  583. 		{ begin_template_parm_list (); }
    584. 

  584. 	  template_parm_list '&gt;'
    585. 

  585. 		{ $$ = end_template_parm_list ($4); }
    586. 

  586. 	| TEMPLATE '&lt;' '&gt;'
    587. 

  587.                 { begin_specialization(); 
    588. 

  588. 		  $$ = NULL_TREE; }
    589. 

  589. 	;
    590. 

  590. 

  591. template_parm_list:
    592. 

  592. 	  template_parm
    593. 

  593. 		{ $$ = process_template_parm (NULL_TREE, $1); }
    594. 

  594. 	| template_parm_list ',' template_parm
    595. 

  595. 		{ $$ = process_template_parm ($1, $3); }
    596. 

  596. 	;
    597. 

  597. 

  598. maybe_identifier:
    599. 

  599. 	  identifier
    600. 

  600. 	  	{ $$ = $1; }
    601. 

  601. 	|	/* empty */
    602. 

  602. 		{ $$ = NULL_TREE; }
    603. 

  603. 

  604. template_type_parm:
    605. 

  605. 	  aggr maybe_identifier
    606. 

  606.                 { $$ = finish_template_type_parm ($1, $2); }
    607. 

  607. 	| TYPENAME_KEYWORD maybe_identifier
    608. 

  608.                 { $$ = finish_template_type_parm (class_type_node, $2); }
    609. 

  609. 	;
    610. 

  610. 

  611. template_template_parm:
    612. 

  612. 	  template_header aggr maybe_identifier
    613. 

  613.                 { $$ = finish_template_template_parm ($2, $3); }
    614. 

  614. 	;
    615. 

  615. 

  616. template_parm:
    617. 

  617. 	/* The following rules introduce a new reduce/reduce
    618. 

  618. 	   conflict on the ',' and '&gt;' input tokens: they are valid
    619. 

  619. 	   prefixes for a `structsp', which means they could match a
    620. 

  620. 	   nameless parameter.  See 14.6, paragraph 3.
    621. 

  621. 	   By putting them before the `parm' rule, we get
    622. 

  622. 	   their match before considering them nameless parameter
    623. 

  623. 	   declarations.  */
    624. 

  624. 	  template_type_parm
    625. 

  625. 		{ $$ = build_tree_list (NULL_TREE, $1); }
    626. 

  626. 	| template_type_parm '=' type_id
    627. 

  627. 		{ $$ = build_tree_list (groktypename ($3.t), $1); }
    628. 

  628. 	| parm
    629. 

  629. 		{ $$ = build_tree_list (NULL_TREE, $1.t); }
    630. 

  630. 	| parm '=' expr_no_commas  %prec ARITHCOMPARE
    631. 

  631. 		{ $$ = build_tree_list ($3, $1.t); }
    632. 

  632. 	| template_template_parm
    633. 

  633. 		{ $$ = build_tree_list (NULL_TREE, $1); }
    634. 

  634. 	| template_template_parm '=' template_arg
    635. 

  635. 		{
    636. 

  636. 		  if (TREE_CODE ($3) != TEMPLATE_DECL
    637. 

  637. 		      &amp;&amp; TREE_CODE ($3) != TEMPLATE_TEMPLATE_PARM
    638. 

  638. 		      &amp;&amp; TREE_CODE ($3) != TYPE_DECL)
    639. 

  639. 		    {
    640. 

  640. 		      error (&quot;invalid default template argument&quot;);
    641. 

  641. 		      $3 = error_mark_node;
    642. 

  642. 		    }
    643. 

  643. 		  $$ = build_tree_list ($3, $1);
    644. 

  644. 		}
    645. 

  645. 	;
    646. 

  646. 

  647. template_def:
    648. 

  648. 	  template_header template_extdef
    649. 

  649.                 { finish_template_decl ($1); }
    650. 

  650. 	| template_header error  %prec EMPTY
    651. 

  651.                 { finish_template_decl ($1); }
    652. 

  652. 	;
    653. 

  653. 

  654. template_extdef:
    655. 

  655. 	  fndef eat_saved_input
    656. 

  656. 		{ if (pending_inlines) do_pending_inlines (); }
    657. 

  657. 	| template_datadef
    658. 

  658. 		{ if (pending_inlines) do_pending_inlines (); }
    659. 

  659. 	| template_def
    660. 

  660. 		{ if (pending_inlines) do_pending_inlines (); }
    661. 

  661. 	| extern_lang_string .hush_warning fndef .warning_ok eat_saved_input
    662. 

  662. 		{ if (pending_inlines) do_pending_inlines ();
    663. 

  663. 		  pop_lang_context (); }
    664. 

  664. 	| extern_lang_string .hush_warning template_datadef .warning_ok
    665. 

  665. 		{ if (pending_inlines) do_pending_inlines ();
    666. 

  666. 		  pop_lang_context (); }
    667. 

  667. 	| extension template_extdef
    668. 

  668. 		{ pedantic = $&lt;itype&gt;1; }
    669. 

  669. 	;
    670. 

  670. 

  671. template_datadef:
    672. 

  672. 	  nomods_initdecls ';'
    673. 

  673. 	| declmods notype_initdecls ';'
    674. 

  674. 		{}
    675. 

  675. 	| typed_declspecs initdecls ';'
    676. 

  676.                 { note_list_got_semicolon ($1.t); }
    677. 

  677. 	| structsp ';'
    678. 

  678.                 { maybe_process_partial_specialization ($1.t);
    679. 

  679. 		  note_got_semicolon ($1.t); }
    680. 

  680. 	;
    681. 

  681. 

  682. datadef:
    683. 

  683. 	  nomods_initdecls ';'
    684. 

  684. 	| declmods notype_initdecls ';'
    685. 

  685. 		{}
    686. 

  686. 	| typed_declspecs initdecls ';'
    687. 

  687.                 { note_list_got_semicolon ($1.t); }
    688. 

  688.         | declmods ';'
    689. 

  689. 		{ pedwarn (&quot;empty declaration&quot;); }
    690. 

  690. 	| explicit_instantiation ';'
    691. 

  691. 	| typed_declspecs ';'
    692. 

  692. 		{
    693. 

  693. 		  tree t, attrs;
    694. 

  694. 		  split_specs_attrs ($1.t, &amp;t, &amp;attrs);
    695. 

  695. 		  shadow_tag (t);
    696. 

  696. 		  note_list_got_semicolon ($1.t);
    697. 

  697. 		}
    698. 

  698. 	| error ';'
    699. 

  699. 	| error '}'
    700. 

  700. 	| ';'
    701. 

  701. 	;
    702. 

  702. 

  703. ctor_initializer_opt:
    704. 

  704. 	  nodecls
    705. 

  705. 		{ $$ = 0; }
    706. 

  706. 	| base_init
    707. 

  707. 		{ $$ = 1; }
    708. 

  708. 	;
    709. 

  709. 

  710. maybe_return_init:
    711. 

  711. 	  /* empty */
    712. 

  712. 	| return_init
    713. 

  713. 	| return_init ';'
    714. 

  714. 	;
    715. 

  715. 

  716. eat_saved_input:
    717. 

  717. 	  /* empty */
    718. 

  718. 	| END_OF_SAVED_INPUT
    719. 

  719. 	;
    720. 

  720. 

  721. fndef:
    722. 

  722. 	  fn.def1 maybe_return_init ctor_initializer_opt compstmt_or_error
    723. 

  723. 		{ finish_function (lineno, (int)$3, 0); }
    724. 

  724. 	| fn.def1 maybe_return_init function_try_block
    725. 

  725. 		{ 
    726. 

  726. 		  int nested = (hack_decl_function_context
    727. 

  727. 				(current_function_decl) != NULL_TREE);
    728. 

  728. 		  finish_function (lineno, (int)$3, nested); 
    729. 

  729. 		}
    730. 

  730. 	| fn.def1 maybe_return_init error
    731. 

  731. 		{ }
    732. 

  732. 	;
    733. 

  733. 

  734. constructor_declarator:
    735. 

  735. 	  nested_name_specifier SELFNAME '(' 
    736. 

  736.                 { $$ = begin_constructor_declarator ($1, $2); }
    737. 

  737. 	  parmlist ')' cv_qualifiers exception_specification_opt
    738. 

  738. 		{ $$ = make_call_declarator ($&lt;ttype&gt;4, $5, $7, $8); }
    739. 

  739. 	| nested_name_specifier SELFNAME LEFT_RIGHT cv_qualifiers exception_specification_opt
    740. 

  740.                 { $$ = begin_constructor_declarator ($1, $2); 
    741. 

  741. 		  $$ = make_call_declarator ($$, empty_parms (), $4, $5);
    742. 

  742. 		}
    743. 

  743. 	| global_scope nested_name_specifier SELFNAME '(' 
    744. 

  744.                 { $$ = begin_constructor_declarator ($2, $3); }
    745. 

  745. 	 parmlist ')' cv_qualifiers exception_specification_opt
    746. 

  746. 		{ $$ = make_call_declarator ($&lt;ttype&gt;5, $6, $8, $9); }
    747. 

  747. 	| global_scope nested_name_specifier SELFNAME LEFT_RIGHT cv_qualifiers exception_specification_opt
    748. 

  748. 		{ $$ = begin_constructor_declarator ($2, $3);
    749. 

  749. 		  $$ = make_call_declarator ($$, empty_parms (), $5, $6);
    750. 

  750. 		}
    751. 

  751. 	| nested_name_specifier self_template_type '(' 
    752. 

  752.                 { $$ = begin_constructor_declarator ($1, $2); }
    753. 

  753. 	  parmlist ')' cv_qualifiers exception_specification_opt
    754. 

  754. 		{ $$ = make_call_declarator ($&lt;ttype&gt;4, $5, $7, $8); }
    755. 

  755. 	| nested_name_specifier self_template_type LEFT_RIGHT cv_qualifiers exception_specification_opt
    756. 

  756. 		{ $$ = begin_constructor_declarator ($1, $2);
    757. 

  757. 		  $$ = make_call_declarator ($$, empty_parms (), $4, $5);
    758. 

  758. 		}
    759. 

  759. 	| global_scope nested_name_specifier self_template_type '(' 
    760. 

  760.                 { $$ = begin_constructor_declarator ($2, $3); }
    761. 

  761. 	 parmlist ')' cv_qualifiers exception_specification_opt
    762. 

  762. 		{ $$ = make_call_declarator ($&lt;ttype&gt;5, $6, $8, $9); }
    763. 

  763. 	| global_scope nested_name_specifier self_template_type LEFT_RIGHT cv_qualifiers exception_specification_opt
    764. 

  764. 		{ $$ = begin_constructor_declarator ($2, $3); 
    765. 

  765. 		  $$ = make_call_declarator ($$, empty_parms (), $5, $6);
    766. 

  766. 		}
    767. 

  767. 	;
    768. 

  768. 

  769. fn.def1:
    770. 

  770. 	  typed_declspecs declarator
    771. 

  771. 		{ if (!begin_function_definition ($1.t, $2))
    772. 

  772. 		    YYERROR1; }
    773. 

  773. 	| declmods notype_declarator
    774. 

  774. 		{ if (!begin_function_definition ($1, $2))
    775. 

  775. 		    YYERROR1; }
    776. 

  776. 	| notype_declarator
    777. 

  777. 		{ if (!begin_function_definition (NULL_TREE, $1))
    778. 

  778. 		    YYERROR1; }
    779. 

  779. 	| declmods constructor_declarator
    780. 

  780. 		{ if (!begin_function_definition ($1, $2))
    781. 

  781. 		    YYERROR1; }
    782. 

  782. 	| constructor_declarator
    783. 

  783. 		{ if (!begin_function_definition (NULL_TREE, $1))
    784. 

  784. 		    YYERROR1; }
    785. 

  785. 	;
    786. 

  786. 

  787. component_constructor_declarator:
    788. 

  788. 	  SELFNAME '(' parmlist ')' cv_qualifiers exception_specification_opt
    789. 

  789. 		{ $$ = make_call_declarator ($1, $3, $5, $6); }
    790. 

  790. 	| SELFNAME LEFT_RIGHT cv_qualifiers exception_specification_opt
    791. 

  791. 		{ $$ = make_call_declarator ($1, empty_parms (), $3, $4); }
    792. 

  792. 	| self_template_type '(' parmlist ')' cv_qualifiers exception_specification_opt
    793. 

  793. 		{ $$ = make_call_declarator ($1, $3, $5, $6); }
    794. 

  794. 	| self_template_type LEFT_RIGHT cv_qualifiers exception_specification_opt
    795. 

  795. 		{ $$ = make_call_declarator ($1, empty_parms (), $3, $4); }
    796. 

  796. 	;
    797. 

  797. 

  798. /* more C++ complexity.  See component_decl for a comment on the
    799. 

  799.    reduce/reduce conflict introduced by these rules.  */
    800. 

  800. fn.def2:
    801. 

  801. 	  declmods component_constructor_declarator
    802. 

  802. 		{ tree specs, attrs;
    803. 

  803. 		  split_specs_attrs ($1, &amp;specs, &amp;attrs);
    804. 

  804. 		  attrs = build_tree_list (attrs, NULL_TREE);
    805. 

  805. 		  $$ = start_method (specs, $2, attrs);
    806. 

  806. 		 rest_of_mdef:
    807. 

  807. 		  if (! $$)
    808. 

  808. 		    YYERROR1;
    809. 

  809. 		  if (yychar == YYEMPTY)
    810. 

  810. 		    yychar = YYLEX;
    811. 

  811. 		  reinit_parse_for_method (yychar, $$); }
    812. 

  812. 	| component_constructor_declarator
    813. 

  813. 		{ $$ = start_method (NULL_TREE, $1, NULL_TREE); 
    814. 

  814. 		  goto rest_of_mdef; }
    815. 

  815. 	| typed_declspecs declarator
    816. 

  816. 		{ tree specs, attrs;
    817. 

  817. 		  split_specs_attrs ($1.t, &amp;specs, &amp;attrs);
    818. 

  818. 		  attrs = build_tree_list (attrs, NULL_TREE);
    819. 

  819. 		  $$ = start_method (specs, $2, attrs); goto rest_of_mdef; }
    820. 

  820. 	| declmods notype_declarator
    821. 

  821. 		{ tree specs, attrs;
    822. 

  822. 		  split_specs_attrs ($1, &amp;specs, &amp;attrs);
    823. 

  823. 		  attrs = build_tree_list (attrs, NULL_TREE);
    824. 

  824. 		  $$ = start_method (specs, $2, attrs); goto rest_of_mdef; }
    825. 

  825. 	| notype_declarator
    826. 

  826. 		{ $$ = start_method (NULL_TREE, $$, NULL_TREE); 
    827. 

  827. 		  goto rest_of_mdef; }
    828. 

  828. 	| declmods constructor_declarator
    829. 

  829. 		{ tree specs, attrs;
    830. 

  830. 		  split_specs_attrs ($1, &amp;specs, &amp;attrs);
    831. 

  831. 		  attrs = build_tree_list (attrs, NULL_TREE);
    832. 

  832. 		  $$ = start_method (specs, $2, attrs); goto rest_of_mdef; }
    833. 

  833. 	| constructor_declarator
    834. 

  834. 		{ $$ = start_method (NULL_TREE, $$, NULL_TREE); 
    835. 

  835. 		  goto rest_of_mdef; }
    836. 

  836. 	;
    837. 

  837. 

  838. return_id:
    839. 

  839. 	  RETURN_KEYWORD IDENTIFIER
    840. 

  840. 		{
    841. 

  841. 		  if (! current_function_parms_stored)
    842. 

  842. 		    store_parm_decls ();
    843. 

  843. 		  $$ = $2;
    844. 

  844. 		}
    845. 

  845. 	;
    846. 

  846. 

  847. return_init:
    848. 

  848. 	  return_id maybe_init
    849. 

  849. 		{ store_return_init ($&lt;ttype&gt;$, $2); }
    850. 

  850. 	| return_id '(' nonnull_exprlist ')'
    851. 

  851. 		{ store_return_init ($&lt;ttype&gt;$, $3); }
    852. 

  852. 	| return_id LEFT_RIGHT
    853. 

  853. 		{ store_return_init ($&lt;ttype&gt;$, NULL_TREE); }
    854. 

  854. 	;
    855. 

  855. 

  856. base_init:
    857. 

  857. 	  ':' .set_base_init member_init_list
    858. 

  858. 		{
    859. 

  859. 		  if ($3 == 0)
    860. 

  860. 		    error (&quot;no base initializers given following ':'&quot;);
    861. 

  861. 		  setup_vtbl_ptr ();
    862. 

  862. 		  /* Always keep the BLOCK node associated with the outermost
    863. 

  863. 		     pair of curley braces of a function.  These are needed
    864. 

  864. 		     for correct operation of dwarfout.c.  */
    865. 

  865. 		  keep_next_level ();
    866. 

  866. 		}
    867. 

  867. 	;
    868. 

  868. 

  869. .set_base_init:
    870. 

  870. 	  /* empty */
    871. 

  871. 		{
    872. 

  872. 		  if (! current_function_parms_stored)
    873. 

  873. 		    store_parm_decls ();
    874. 

  874. 

  875. 		  if (DECL_CONSTRUCTOR_P (current_function_decl))
    876. 

  876. 		    {
    877. 

  877. 		      /* Make a contour for the initializer list.  */
    878. 

  878. 		      pushlevel (0);
    879. 

  879. 		      clear_last_expr ();
    880. 

  880. 		      expand_start_bindings (0);
    881. 

  881. 		    }
    882. 

  882. 		  else if (current_class_type == NULL_TREE)
    883. 

  883. 		    error (&quot;base initializers not allowed for non-member functions&quot;);
    884. 

  884. 		  else if (! DECL_CONSTRUCTOR_P (current_function_decl))
    885. 

  885. 		    error (&quot;only constructors take base initializers&quot;);
    886. 

  886. 		}
    887. 

  887. 	;
    888. 

  888. 

  889. member_init_list:
    890. 

  890. 	  /* empty */
    891. 

  891. 		{ $$ = 0; }
    892. 

  892. 	| member_init
    893. 

  893. 		{ $$ = 1; }
    894. 

  894. 	| member_init_list ',' member_init
    895. 

  895. 	| member_init_list error
    896. 

  896. 	;
    897. 

  897. 

  898. member_init:
    899. 

  899. 	  '(' nonnull_exprlist ')'
    900. 

  900. 		{
    901. 

  901. 		  if (current_class_name)
    902. 

  902. 		    pedwarn (&quot;anachronistic old style base class initializer&quot;);
    903. 

  903. 		  expand_member_init (current_class_ref, NULL_TREE, $2);
    904. 

  904. 		}
    905. 

  905. 	| LEFT_RIGHT
    906. 

  906. 		{
    907. 

  907. 		  if (current_class_name)
    908. 

  908. 		    pedwarn (&quot;anachronistic old style base class initializer&quot;);
    909. 

  909. 		  expand_member_init (current_class_ref, NULL_TREE, void_type_node);
    910. 

  910. 		}
    911. 

  911. 	| notype_identifier '(' nonnull_exprlist ')'
    912. 

  912. 		{ expand_member_init (current_class_ref, $1, $3); }
    913. 

  913. 	| notype_identifier LEFT_RIGHT
    914. 

  914. 		{ expand_member_init (current_class_ref, $1, void_type_node); }
    915. 

  915. 	| nonnested_type '(' nonnull_exprlist ')'
    916. 

  916. 		{ expand_member_init (current_class_ref, $1, $3); }
    917. 

  917. 	| nonnested_type LEFT_RIGHT
    918. 

  918. 		{ expand_member_init (current_class_ref, $1, void_type_node); }
    919. 

  919. 	| typename_sub '(' nonnull_exprlist ')'
    920. 

  920. 		{ expand_member_init (current_class_ref, TYPE_MAIN_DECL ($1),
    921. 

  921. 				      $3); }
    922. 

  922. 	| typename_sub LEFT_RIGHT
    923. 

  923. 		{ expand_member_init (current_class_ref, TYPE_MAIN_DECL ($1),
    924. 

  924. 				      void_type_node); }
    925. 

  925. 	;
    926. 

  926. 

  927. identifier:
    928. 

  928. 	  IDENTIFIER
    929. 

  929. 	| TYPENAME
    930. 

  930. 	| SELFNAME
    931. 

  931. 	| PTYPENAME
    932. 

  932. 	| NSNAME
    933. 

  933. 	| OBJECTNAME
    934. 

  934.         | CLASSNAME
    935. 

  935. 	;
    936. 

  936. 

  937. notype_identifier:
    938. 

  938. 	  IDENTIFIER
    939. 

  939. 	| PTYPENAME 
    940. 

  940. 	| NSNAME  %prec EMPTY
    941. 

  941. 	;
    942. 

  942. 

  943. identifier_defn:
    944. 

  944. 	  IDENTIFIER_DEFN
    945. 

  945. 	| TYPENAME_DEFN
    946. 

  946. 	| PTYPENAME_DEFN
    947. 

  947. 	;
    948. 

  948. 

  949. explicit_instantiation:
    950. 

  950. 	  TEMPLATE begin_explicit_instantiation typespec ';'
    951. 

  951. 		{ do_type_instantiation ($3.t, NULL_TREE);
    952. 

  952. 		  yyungetc (';', 1); }
    953. 

  953.           end_explicit_instantiation
    954. 

  954. 	| TEMPLATE begin_explicit_instantiation typed_declspecs declarator
    955. 

  955. 		{ tree specs = strip_attrs ($3.t);
    956. 

  956. 		  do_decl_instantiation (specs, $4, NULL_TREE); }
    957. 

  957.           end_explicit_instantiation
    958. 

  958. 	| TEMPLATE begin_explicit_instantiation notype_declarator
    959. 

  959. 		{ do_decl_instantiation (NULL_TREE, $3, NULL_TREE); }
    960. 

  960.           end_explicit_instantiation
    961. 

  961. 	| TEMPLATE begin_explicit_instantiation constructor_declarator
    962. 

  962. 		{ do_decl_instantiation (NULL_TREE, $3, NULL_TREE); }
    963. 

  963.           end_explicit_instantiation
    964. 

  964. 	| SCSPEC TEMPLATE begin_explicit_instantiation typespec ';'
    965. 

  965. 		{ do_type_instantiation ($4.t, $1);
    966. 

  966. 		  yyungetc (';', 1); }
    967. 

  967.           end_explicit_instantiation
    968. 

  968. 	| SCSPEC TEMPLATE begin_explicit_instantiation typed_declspecs 
    969. 

  969.           declarator
    970. 

  970. 		{ tree specs = strip_attrs ($4.t);
    971. 

  971. 		  do_decl_instantiation (specs, $5, $1); }
    972. 

  972.           end_explicit_instantiation
    973. 

  973. 	| SCSPEC TEMPLATE begin_explicit_instantiation notype_declarator
    974. 

  974. 		{ do_decl_instantiation (NULL_TREE, $4, $1); }
    975. 

  975.           end_explicit_instantiation
    976. 

  976. 	| SCSPEC TEMPLATE begin_explicit_instantiation constructor_declarator
    977. 

  977. 		{ do_decl_instantiation (NULL_TREE, $4, $1); }
    978. 

  978.           end_explicit_instantiation
    979. 

  979. 	;
    980. 

  980. 

  981. begin_explicit_instantiation: 
    982. 

  982.       { begin_explicit_instantiation(); }
    983. 

  983. 

  984. end_explicit_instantiation: 
    985. 

  985.       { end_explicit_instantiation(); }
    986. 

  986. 

  987. /* The TYPENAME expansions are to deal with use of a template class name as
    988. 

  988.   a template within the class itself, where the template decl is hidden by
    989. 

  989.   a type decl.  Got all that?  */
    990. 

  990. 

  991. template_type:
    992. 

  992. 	  PTYPENAME '&lt;' template_arg_list_opt template_close_bracket
    993. 

  993. 	    .finish_template_type
    994. 

  994.                 { $$ = $5; }
    995. 

  995. 	| TYPENAME  '&lt;' template_arg_list_opt template_close_bracket
    996. 

  996. 	    .finish_template_type
    997. 

  997.                 { $$ = $5; }
    998. 

  998. 	| self_template_type
    999. 

  999. 	;
    1000. 

  1000. 

  1001. apparent_template_type:
    1002. 

  1002. 	  template_type
    1003. 

  1003. 	| identifier '&lt;' template_arg_list_opt '&gt;'
    1004. 

  1004. 	    .finish_template_type
    1005. 

  1005. 		{ $$ = $5; }
    1006. 

  1006. 

  1007. self_template_type:
    1008. 

  1008. 	  SELFNAME  '&lt;' template_arg_list_opt template_close_bracket
    1009. 

  1009. 	    .finish_template_type
    1010. 

  1010.                 { $$ = $5; }
    1011. 

  1011. 	;
    1012. 

  1012. 

  1013. .finish_template_type:
    1014. 

  1014.                 { 
    1015. 

  1015. 		  if (yychar == YYEMPTY)
    1016. 

  1016. 		    yychar = YYLEX;
    1017. 

  1017. 

  1018. 		  $$ = finish_template_type ($&lt;ttype&gt;-3, $&lt;ttype&gt;-1, 
    1019. 

  1019. 					     yychar == SCOPE);
    1020. 

  1020. 		}
    1021. 

  1021. 

  1022. template_close_bracket:
    1023. 

  1023. 	  '&gt;'
    1024. 

  1024. 	| RSHIFT 
    1025. 

  1025. 		{
    1026. 

  1026. 		  /* Handle `Class&lt;Class&lt;Type&gt;&gt;' without space in the `&gt;&gt;' */
    1027. 

  1027. 		  pedwarn (&quot;`&gt;&gt;' should be `&gt; &gt;' in template class name&quot;);
    1028. 

  1028. 		  yyungetc ('&gt;', 1);
    1029. 

  1029. 		}
    1030. 

  1030. 	;
    1031. 

  1031. 

  1032. template_arg_list_opt:
    1033. 

  1033.          /* empty */
    1034. 

  1034.                  { $$ = NULL_TREE; }
    1035. 

  1035.        | template_arg_list
    1036. 

  1036.        ;
    1037. 

  1037. 

  1038. template_arg_list:
    1039. 

  1039.         template_arg
    1040. 

  1040. 		{ $$ = build_tree_list (NULL_TREE, $$); }
    1041. 

  1041. 	| template_arg_list ',' template_arg
    1042. 

  1042. 		{ $$ = chainon ($$, build_tree_list (NULL_TREE, $3)); }
    1043. 

  1043. 	;
    1044. 

  1044. 

  1045. template_arg:
    1046. 

  1046. 	  type_id
    1047. 

  1047. 		{ $$ = groktypename ($1.t); }
    1048. 

  1048. 	| PTYPENAME
    1049. 

  1049. 		{ $$ = lastiddecl; }
    1050. 

  1050. 	| expr_no_commas  %prec ARITHCOMPARE
    1051. 

  1051. 	;
    1052. 

  1052. 

  1053. unop:
    1054. 

  1054. 	  '-'
    1055. 

  1055. 		{ $$ = NEGATE_EXPR; }
    1056. 

  1056. 	| '+'
    1057. 

  1057. 		{ $$ = CONVERT_EXPR; }
    1058. 

  1058. 	| PLUSPLUS
    1059. 

  1059. 		{ $$ = PREINCREMENT_EXPR; }
    1060. 

  1060. 	| MINUSMINUS
    1061. 

  1061. 		{ $$ = PREDECREMENT_EXPR; }
    1062. 

  1062. 	| '!'
    1063. 

  1063. 		{ $$ = TRUTH_NOT_EXPR; }
    1064. 

  1064. 	;
    1065. 

  1065. 

  1066. expr:
    1067. 

  1067. 	  nontrivial_exprlist
    1068. 

  1068. 		{ $$ = build_x_compound_expr ($$); }
    1069. 

  1069. 	| expr_no_commas
    1070. 

  1070. 	;
    1071. 

  1071. 

  1072. paren_expr_or_null:
    1073. 

  1073. 	LEFT_RIGHT
    1074. 

  1074. 		{ error (&quot;ANSI C++ forbids an empty condition for `%s'&quot;,
    1075. 

  1075. 			 cond_stmt_keyword);
    1076. 

  1076. 		  $$ = integer_zero_node; }
    1077. 

  1077. 	| '(' expr ')'
    1078. 

  1078.                 { $$ = $2; }
    1079. 

  1079. 	;
    1080. 

    1081. 

  1081. paren_cond_or_null:
    1082. 

  1082. 	LEFT_RIGHT
    1083. 

  1083. 		{ error (&quot;ANSI C++ forbids an empty condition for `%s'&quot;,
    1084. 

  1084. 			 cond_stmt_keyword);
    1085. 

  1085. 		  $$ = integer_zero_node; }
    1086. 

  1086. 	| '(' condition ')'
    1087. 

  1087.                 { $$ = $2; }
    1088. 

  1088. 	;
    1089. 

  1089. 

  1090. xcond:
    1091. 

  1091. 	  /* empty */
    1092. 

  1092. 		{ $$ = NULL_TREE; }
    1093. 

  1093. 	| condition
    1094. 

  1094. 	| error
    1095. 

  1095. 		{ $$ = NULL_TREE; }
    1096. 

  1096. 	;
    1097. 

  1097. 

  1098. condition:
    1099. 

  1099. 	  type_specifier_seq declarator maybeasm maybe_attribute '='
    1100. 

  1100. 		{ {
    1101. 

  1101. 		  tree d;
    1102. 

  1102. 		  for (d = getdecls (); d; d = TREE_CHAIN (d))
    1103. 

  1103. 		    if (TREE_CODE (d) == TYPE_DECL) {
    1104. 

  1104. 		      tree s = TREE_TYPE (d);
    1105. 

  1105. 		      if (TREE_CODE (s) == RECORD_TYPE)
    1106. 

  1106. 			cp_error (&quot;definition of class `%T' in condition&quot;, s);
    1107. 

  1107. 		      else if (TREE_CODE (s) == ENUMERAL_TYPE)
    1108. 

  1108. 			cp_error (&quot;definition of enum `%T' in condition&quot;, s);
    1109. 

  1109. 		    }
    1110. 

  1110. 		  }
    1111. 

  1111. 		  current_declspecs = $1.t;
    1112. 

  1112. 		  $&lt;itype&gt;5 = suspend_momentary ();
    1113. 

  1113. 		  $&lt;ttype&gt;$ = start_decl ($&lt;ttype&gt;2, current_declspecs, 1,
    1114. 

  1114. 					  $4, /*prefix_attributes*/ NULL_TREE);
    1115. 

  1115. 		}
    1116. 

  1116. 	  init
    1117. 

  1117. 		{ 
    1118. 

  1118. 		  cp_finish_decl ($&lt;ttype&gt;6, $7, $4, 1, LOOKUP_ONLYCONVERTING);
    1119. 

  1119. 		  resume_momentary ($&lt;itype&gt;5);
    1120. 

  1120. 		  $$ = convert_from_reference ($&lt;ttype&gt;6); 
    1121. 

  1121. 		  if (TREE_CODE (TREE_TYPE ($$)) == ARRAY_TYPE)
    1122. 

  1122. 		    cp_error (&quot;definition of array `%#D' in condition&quot;, $$); 
    1123. 

  1123. 		}
    1124. 

  1124. 	| expr
    1125. 

  1125. 	;
    1126. 

    1127. 

  1127. compstmtend:
    1128. 

  1128. 	  '}'
    1129. 

  1129. 	| maybe_label_decls stmts '}'
    1130. 

  1130. 	| maybe_label_decls stmts error '}'
    1131. 

  1131. 	| maybe_label_decls error '}'
    1132. 

  1132. 	;
    1133. 

    1134. 

  1134. already_scoped_stmt:
    1135. 

  1135. 	  '{'
    1136. 

  1136.                 { $&lt;ttype&gt;$ = begin_compound_stmt (1); }
    1137. 

  1137. 	  compstmtend
    1138. 

  1138.                 { finish_compound_stmt (1, $&lt;ttype&gt;2); }
    1139. 

  1139. 	| simple_stmt
    1140. 

  1140. 	;
    1141. 

    1142. 

    1143. 

  1143. nontrivial_exprlist:
    1144. 

  1144. 	  expr_no_commas ',' expr_no_commas
    1145. 

  1145. 		{ $$ = expr_tree_cons (NULL_TREE, $$, 
    1146. 

  1146. 		                  build_expr_list (NULL_TREE, $3)); }
    1147. 

  1147. 	| expr_no_commas ',' error
    1148. 

  1148. 		{ $$ = expr_tree_cons (NULL_TREE, $$, 
    1149. 

  1149. 		                  build_expr_list (NULL_TREE, error_mark_node)); }
    1150. 

  1150. 	| nontrivial_exprlist ',' expr_no_commas
    1151. 

  1151. 		{ chainon ($$, build_expr_list (NULL_TREE, $3)); }
    1152. 

  1152. 	| nontrivial_exprlist ',' error
    1153. 

  1153. 		{ chainon ($$, build_expr_list (NULL_TREE, error_mark_node)); }
    1154. 

  1154. 	;
    1155. 

    1156. 

  1156. nonnull_exprlist:
    1157. 

  1157. 	  expr_no_commas
    1158. 

  1158. 		{ $$ = build_expr_list (NULL_TREE, $$); }
    1159. 

  1159. 	| nontrivial_exprlist
    1160. 

  1160. 	;
    1161. 

    1162. 

  1162. unary_expr:
    1163. 

  1163. 	  primary  %prec UNARY
    1164. 

  1164. 		{ $$ = $1; }
    1165. 

  1165. 	/* __extension__ turns off -pedantic for following primary.  */
    1166. 

  1166. 	| extension cast_expr  	  %prec UNARY
    1167. 

  1167. 		{ $$ = $2;
    1168. 

  1168. 		  pedantic = $&lt;itype&gt;1; }
    1169. 

  1169. 	| '*' cast_expr   %prec UNARY
    1170. 

  1170. 		{ $$ = build_x_indirect_ref ($2, &quot;unary *&quot;); }
    1171. 

  1171. 	| '&amp;' cast_expr   %prec UNARY
    1172. 

  1172. 		{ $$ = build_x_unary_op (ADDR_EXPR, $2); }
    1173. 

  1173. 	| '~' cast_expr
    1174. 

  1174. 		{ $$ = build_x_unary_op (BIT_NOT_EXPR, $2); }
    1175. 

  1175. 	| unop cast_expr  %prec UNARY
    1176. 

  1176.                 { $$ = finish_unary_op_expr ($1, $2); }
    1177. 

  1177. 	/* Refer to the address of a label as a pointer.  */
    1178. 

  1178. 	| ANDAND identifier
    1179. 

  1179. 		{ if (pedantic)
    1180. 

  1180. 		    pedwarn (&quot;ANSI C++ forbids `&amp;&amp;'&quot;);
    1181. 

  1181.   		  $$ = finish_label_address_expr ($2); }
    1182. 

  1182. 	| SIZEOF unary_expr  %prec UNARY
    1183. 

  1183. 		{ $$ = expr_sizeof ($2); }
    1184. 

  1184. 	| SIZEOF '(' type_id ')'  %prec HYPERUNARY
    1185. 

  1185. 		{ $$ = c_sizeof (groktypename ($3.t));
    1186. 

  1186. 		  check_for_new_type (&quot;sizeof&quot;, $3); }
    1187. 

  1187. 	| ALIGNOF unary_expr  %prec UNARY
    1188. 

  1188. 		{ $$ = grok_alignof ($2); }
    1189. 

  1189. 	| ALIGNOF '(' type_id ')'  %prec HYPERUNARY
    1190. 

  1190. 		{ $$ = c_alignof (groktypename ($3.t)); 
    1191. 

  1191. 		  check_for_new_type (&quot;alignof&quot;, $3); }
    1192. 

  1192. 	| VEC_STEP unary_expr  %prec UNARY
    1193. 

  1193. 		{ $$ = c_vec_step_expr ($2); }
    1194. 

  1194. 	| VEC_STEP '(' type_id ')'  %prec HYPERUNARY
    1195. 

  1195. 		{ $$ = c_vec_step (groktypename ($3.t)); }
    1196. 

  1196. 

  1197. 	/* The %prec EMPTY's here are required by the = init initializer
    1198. 

  1198. 	   syntax extension; see below.  */
    1199. 

  1199. 	| new new_type_id  %prec EMPTY
    1200. 

  1200. 		{ $$ = build_new (NULL_TREE, $2.t, NULL_TREE, $1); 
    1201. 

  1201. 		  check_for_new_type (&quot;new&quot;, $2); }
    1202. 

  1202. 	| new new_type_id new_initializer
    1203. 

  1203. 		{ $$ = build_new (NULL_TREE, $2.t, $3, $1); 
    1204. 

  1204. 		  check_for_new_type (&quot;new&quot;, $2); }
    1205. 

  1205. 	| new new_placement new_type_id  %prec EMPTY
    1206. 

  1206. 		{ $$ = build_new ($2, $3.t, NULL_TREE, $1); 
    1207. 

  1207. 		  check_for_new_type (&quot;new&quot;, $3); }
    1208. 

  1208. 	| new new_placement new_type_id new_initializer
    1209. 

  1209. 		{ $$ = build_new ($2, $3.t, $4, $1); 
    1210. 

  1210. 		  check_for_new_type (&quot;new&quot;, $3); }
    1211. 

  1211.         /* The .begin_new_placement in the following rules is
    1212. 

  1212. 	   necessary to avoid shift/reduce conflicts that lead to
    1213. 

  1213. 	   mis-parsing some expressions.  Of course, these constructs
    1214. 

  1214. 	   are not really new-placement and it is bogus to call
    1215. 

  1215. 	   begin_new_placement.  But, the parser cannot always tell at this
    1216. 

  1216. 	   point whether the next thing is an expression or a type-id,
    1217. 

  1217. 	   so there is nothing we can do.  Fortunately,
    1218. 

  1218. 	   begin_new_placement does nothing harmful.  When we rewrite
    1219. 

  1219. 	   the parser, this lossage should be removed, of course.  */
    1220. 

  1220. 	| new '(' .begin_new_placement type_id .finish_new_placement
    1221. 

  1221.             %prec EMPTY
    1222. 

  1222. 		{ $$ = build_new (NULL_TREE, groktypename($4.t),
    1223. 

  1223. 				  NULL_TREE, $1); 
    1224. 

  1224. 		  check_for_new_type (&quot;new&quot;, $4); }
    1225. 

  1225. 	| new '(' .begin_new_placement type_id .finish_new_placement
    1226. 

  1226.             new_initializer
    1227. 

  1227. 		{ $$ = build_new (NULL_TREE, groktypename($4.t), $6, $1); 
    1228. 

  1228. 		  check_for_new_type (&quot;new&quot;, $4); }
    1229. 

  1229. 	| new new_placement '(' .begin_new_placement type_id
    1230. 

  1230. 	    .finish_new_placement   %prec EMPTY
    1231. 

  1231. 		{ $$ = build_new ($2, groktypename($5.t), NULL_TREE, $1); 
    1232. 

  1232. 		  check_for_new_type (&quot;new&quot;, $5); }
    1233. 

  1233. 	| new new_placement '(' .begin_new_placement type_id
    1234. 

  1234. 	    .finish_new_placement  new_initializer
    1235. 

  1235. 		{ $$ = build_new ($2, groktypename($5.t), $7, $1); 
    1236. 

  1236. 		  check_for_new_type (&quot;new&quot;, $5); }
    1237. 

  1237. 

  1238. 	| delete cast_expr  %prec UNARY
    1239. 

  1239. 		{ $$ = delete_sanity ($2, NULL_TREE, 0, $1); }
    1240. 

  1240. 	| delete '[' ']' cast_expr  %prec UNARY
    1241. 

  1241. 		{ $$ = delete_sanity ($4, NULL_TREE, 1, $1);
    1242. 

  1242. 		  if (yychar == YYEMPTY)
    1243. 

  1243. 		    yychar = YYLEX; }
    1244. 

  1244. 	| delete '[' expr ']' cast_expr  %prec UNARY
    1245. 

  1245. 		{ $$ = delete_sanity ($5, $3, 2, $1);
    1246. 

  1246. 		  if (yychar == YYEMPTY)
    1247. 

  1247. 		    yychar = YYLEX; }
    1248. 

  1248. 	| delete objc_openbracket.expr objc_closebracket cast_expr %prec UNARY
    1249. 

  1249. 		{ $$ = delete_sanity ($4, $2, 2, $1);
    1250. 

  1250. 		  if (yychar == YYEMPTY)
    1251. 

  1251. 		    yychar = YYLEX; }
    1252. 

  1252. 	| REALPART cast_expr %prec UNARY
    1253. 

  1253. 		{ $$ = build_x_unary_op (REALPART_EXPR, $2); }
    1254. 

  1254. 	| IMAGPART cast_expr %prec UNARY
    1255. 

  1255. 		{ $$ = build_x_unary_op (IMAGPART_EXPR, $2); }
    1256. 

  1256. 	;
    1257. 

  1257. 

  1258.         /* Note this rule is not suitable for use in new_placement
    1259. 

  1259. 	   since it uses NULL_TREE as the argument to
    1260. 

  1260. 	   finish_new_placement.  This rule serves only to avoid
    1261. 

  1261. 	   reduce/reduce conflicts in unary_expr.  See the comments
    1262. 

  1262. 	   there on the use of begin/finish_new_placement.  */
    1263. 

  1263. .finish_new_placement:
    1264. 

  1264. 	  ')'
    1265. 

  1265.                 { finish_new_placement (NULL_TREE, $&lt;itype&gt;-1); }
    1266. 

  1266. 

  1267. .begin_new_placement:
    1268. 

  1268.                 { $$ = begin_new_placement (); }
    1269. 

  1269. 

  1270. new_placement:
    1271. 

  1271. 	  '(' .begin_new_placement nonnull_exprlist ')'
    1272. 

  1272.                 { $$ = finish_new_placement ($3, $2); }
    1273. 

  1273. 	| '{' .begin_new_placement nonnull_exprlist '}'
    1274. 

  1274.                 { cp_pedwarn (&quot;old style placement syntax, use () instead&quot;);
    1275. 

  1275. 		  $$ = finish_new_placement ($3, $2); }
    1276. 

  1276. 	;
    1277. 

  1277. 

  1278. new_initializer:
    1279. 

  1279. 	  '(' nonnull_exprlist ')'
    1280. 

  1280. 		{ $$ = $2; }
    1281. 

  1281. 	| LEFT_RIGHT
    1282. 

  1282. 		{ $$ = NULL_TREE; }
    1283. 

  1283. 	| '(' typespec ')'
    1284. 

  1284. 		{
    1285. 

  1285. 		  cp_error (&quot;`%T' is not a valid expression&quot;, $2.t);
    1286. 

  1286. 		  $$ = error_mark_node;
    1287. 

  1287. 		}
    1288. 

  1288. 	/* GNU extension so people can use initializer lists.  Note that
    1289. 

  1289. 	   this alters the meaning of `new int = 1', which was previously
    1290. 

  1290. 	   syntactically valid but semantically invalid.  */
    1291. 

  1291. 	| '=' init
    1292. 

  1292. 		{
    1293. 

  1293. 		  if (pedantic)
    1294. 

  1294. 		    pedwarn (&quot;ANSI C++ forbids initialization of new expression with `='&quot;);
    1295. 

  1295. 		  if (TREE_CODE ($2) != TREE_LIST
    1296. 

  1296. 		      &amp;&amp; TREE_CODE ($2) != CONSTRUCTOR)
    1297. 

  1297. 		    $$ = build_expr_list (NULL_TREE, $2);
    1298. 

  1298. 		  else
    1299. 

  1299. 		    $$ = $2;
    1300. 

  1300. 		}
    1301. 

  1301. 	;
    1302. 

    1303. 

  1303. /* This is necessary to postpone reduction of `int ((int)(int)(int))'.  */
    1304. 

  1304. regcast_or_absdcl:
    1305. 

  1305. 	  '(' type_id ')'  %prec EMPTY
    1306. 

  1306. 		{ $2.t = finish_parmlist (build_tree_list (NULL_TREE, $2.t), 0);
    1307. 

  1307. 		  $$ = make_call_declarator (NULL_TREE, $2.t, NULL_TREE, NULL_TREE);
    1308. 

  1308. 		  check_for_new_type (&quot;cast&quot;, $2); }
    1309. 

  1309. 	| regcast_or_absdcl '(' type_id ')'  %prec EMPTY
    1310. 

  1310. 		{ $3.t = finish_parmlist (build_tree_list (NULL_TREE, $3.t), 0); 
    1311. 

  1311. 		  $$ = make_call_declarator ($$, $3.t, NULL_TREE, NULL_TREE);
    1312. 

  1312. 		  check_for_new_type (&quot;cast&quot;, $3); }
    1313. 

  1313. 	;
    1314. 

  1314. 

  1315. cast_expr:
    1316. 

  1316. 	  unary_expr
    1317. 

  1317. 	| regcast_or_absdcl '(' nontrivial_exprlist ')'  %prec UNARY
    1318. 

  1318. 		{ $$ = reparse_absdcl_as_casts_or_vector_constant ($$, $3); }
    1319. 

  1319. 	| regcast_or_absdcl unary_expr  %prec UNARY
    1320. 

  1320. 		{ $$ = reparse_absdcl_as_casts_or_vector_constant ($$, $2); }
    1321. 

  1321. 	| regcast_or_absdcl '{' initlist maybecomma '}'  %prec UNARY
    1322. 

  1322. 		{ 
    1323. 

  1323. 		  tree init = build_nt (CONSTRUCTOR, NULL_TREE,
    1324. 

  1324. 					nreverse ($3)); 
    1325. 

  1325. 		  if (pedantic)
    1326. 

  1326. 		    pedwarn (&quot;ANSI C++ forbids constructor-expressions&quot;);
    1327. 

  1327. 		  /* Indicate that this was a GNU C constructor expression.  */
    1328. 

  1328. 		  TREE_HAS_CONSTRUCTOR (init) = 1;
    1329. 

  1329. 

  1330. 		  $$ = reparse_absdcl_as_casts ($$, init);
    1331. 

  1331. 		}
    1332. 

  1332. 	;
    1333. 

  1333. 

  1334. expr_no_commas:
    1335. 

  1335. 	  cast_expr
    1336. 

  1336. 	/* Handle general members.  */
    1337. 

  1337. 	| expr_no_commas POINTSAT_STAR expr_no_commas
    1338. 

  1338. 		{ $$ = build_x_binary_op (MEMBER_REF, $$, $3); }
    1339. 

  1339. 	| expr_no_commas DOT_STAR expr_no_commas
    1340. 

  1340. 		{ $$ = build_m_component_ref ($$, $3); }
    1341. 

  1341. 	| expr_no_commas '+' expr_no_commas
    1342. 

  1342. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1343. 

  1343. 	| expr_no_commas '-' expr_no_commas
    1344. 

  1344. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1345. 

  1345. 	| expr_no_commas '*' expr_no_commas
    1346. 

  1346. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1347. 

  1347. 	| expr_no_commas '/' expr_no_commas
    1348. 

  1348. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1349. 

  1349. 	| expr_no_commas '%' expr_no_commas
    1350. 

  1350. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1351. 

  1351. 	| expr_no_commas LSHIFT expr_no_commas
    1352. 

  1352. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1353. 

  1353. 	| expr_no_commas RSHIFT expr_no_commas
    1354. 

  1354. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1355. 

  1355. 	| expr_no_commas ARITHCOMPARE expr_no_commas
    1356. 

  1356. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1357. 

  1357. 	| expr_no_commas '&lt;' expr_no_commas
    1358. 

  1358. 		{ $$ = build_x_binary_op (LT_EXPR, $$, $3); }
    1359. 

  1359. 	| expr_no_commas '&gt;' expr_no_commas
    1360. 

  1360. 		{ $$ = build_x_binary_op (GT_EXPR, $$, $3); }
    1361. 

  1361. 	| expr_no_commas EQCOMPARE expr_no_commas
    1362. 

  1362. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1363. 

  1363. 	| expr_no_commas MIN_MAX expr_no_commas
    1364. 

  1364. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1365. 

  1365. 	| expr_no_commas '&amp;' expr_no_commas
    1366. 

  1366. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1367. 

  1367. 	| expr_no_commas '|' expr_no_commas
    1368. 

  1368. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1369. 

  1369. 	| expr_no_commas '^' expr_no_commas
    1370. 

  1370. 		{ $$ = build_x_binary_op ($2, $$, $3); }
    1371. 

  1371. 	| expr_no_commas ANDAND expr_no_commas
    1372. 

  1372. 		{ $$ = build_x_binary_op (TRUTH_ANDIF_EXPR, $$, $3); }
    1373. 

  1373. 	| expr_no_commas OROR expr_no_commas
    1374. 

  1374. 		{ $$ = build_x_binary_op (TRUTH_ORIF_EXPR, $$, $3); }
    1375. 

  1375. 	| expr_no_commas '?' xexpr ':' expr_no_commas
    1376. 

  1376. 		{ $$ = build_x_conditional_expr ($$, $3, $5); }
    1377. 

  1377. 	| expr_no_commas '=' expr_no_commas
    1378. 

  1378. 		{ $$ = build_x_modify_expr ($$, NOP_EXPR, $3);
    1379. 

  1379. 		  if ($$ != error_mark_node)
    1380. 

  1380.                     C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); }
    1381. 

  1381. 	| expr_no_commas ASSIGN expr_no_commas
    1382. 

  1382. 		{ $$ = build_x_modify_expr ($$, $2, $3); }
    1383. 

  1383. 	| THROW  %prec EMPTY
    1384. 

  1384. 		{ $$ = build_throw (NULL_TREE); }
    1385. 

  1385. 	| THROW expr_no_commas
    1386. 

  1386. 		{ $$ = build_throw ($2); }
    1387. 

  1387. /* These extensions are not defined.  The second arg to build_m_component_ref
    1388. 

  1388.    is old, build_m_component_ref now does an implicit
    1389. 

  1389.    build_indirect_ref (x, NULL_PTR) on the second argument.
    1390. 

  1390. 	| object '&amp;' expr_no_commas  %prec UNARY
    1391. 

  1391. 		{ $$ = build_m_component_ref ($$, build_x_unary_op (ADDR_EXPR, $3)); }
    1392. 

  1392. 	| object unop expr_no_commas  %prec UNARY
    1393. 

  1393. 		{ $$ = build_m_component_ref ($$, build_x_unary_op ($2, $3)); }
    1394. 

  1394. 	| object '(' type_id ')' expr_no_commas  %prec UNARY
    1395. 

  1395. 		{ tree type = groktypename ($3.t);
    1396. 

  1396. 		  $$ = build_m_component_ref ($$, build_c_cast (type, $5)); }
    1397. 

  1397. 	| object primary_no_id  %prec UNARY
    1398. 

  1398. 		{ $$ = build_m_component_ref ($$, $2); }
    1399. 

  1399. */
    1400. 

  1400. 	;
    1401. 

  1401. 

  1402. notype_unqualified_id:
    1403. 

  1403. 	  '~' see_typename identifier
    1404. 

  1404. 		{ $$ = build_parse_node (BIT_NOT_EXPR, $3); }
    1405. 

  1405. 	| '~' see_typename template_type
    1406. 

  1406. 		{ $$ = build_parse_node (BIT_NOT_EXPR, $3); }
    1407. 

  1407.         | template_id
    1408. 

  1408. 	| operator_name
    1409. 

  1409. 	| IDENTIFIER
    1410. 

  1410. 	| PTYPENAME
    1411. 

  1411. 	| NSNAME  %prec EMPTY
    1412. 

  1412. 	;
    1413. 

  1413. 

  1414. do_id:
    1415. 

  1415. 		{
    1416. 

  1416. 		  /* If lastiddecl is a TREE_LIST, it's a baselink, which
    1417. 

  1417. 		     means that we're in an expression like S::f&lt;int&gt;, so
    1418. 

  1418. 		     don't do_identifier; we only do that for unqualified
    1419. 

  1419. 		     identifiers.  */
    1420. 

  1420. 		  if (lastiddecl &amp;&amp; TREE_CODE (lastiddecl) != TREE_LIST)
    1421. 

  1421. 		    $$ = do_identifier ($&lt;ttype&gt;-1, 1, NULL_TREE);
    1422. 

  1422. 		  else
    1423. 

  1423. 		    $$ = $&lt;ttype&gt;-1;
    1424. 

  1424. 		}
    1425. 

  1425. 

  1426. template_id:
    1427. 

  1427.           PFUNCNAME '&lt;' do_id template_arg_list_opt template_close_bracket 
    1428. 

  1428.                 { $$ = lookup_template_function ($3, $4); }
    1429. 

  1429.         | operator_name '&lt;' do_id template_arg_list_opt template_close_bracket
    1430. 

  1430.                 { $$ = lookup_template_function ($3, $4); }
    1431. 

  1431. 	;
    1432. 

  1432. 

  1433. object_template_id:
    1434. 

  1434.         TEMPLATE identifier '&lt;' template_arg_list_opt template_close_bracket
    1435. 

  1435.                 { $$ = lookup_template_function ($2, $4); }
    1436. 

  1436.         | TEMPLATE PFUNCNAME '&lt;' template_arg_list_opt template_close_bracket
    1437. 

  1437.                 { $$ = lookup_template_function ($2, $4); }
    1438. 

  1438.         | TEMPLATE operator_name '&lt;' template_arg_list_opt 
    1439. 

  1439.           template_close_bracket
    1440. 

  1440.                 { $$ = lookup_template_function ($2, $4); }
    1441. 

  1441.         ;
    1442. 

  1442. 

  1443. unqualified_id:
    1444. 

  1444. 	  notype_unqualified_id
    1445. 

  1445. 	| TYPENAME
    1446. 

  1446. 	| SELFNAME
    1447. 

  1447. 	;
    1448. 

  1448. 

  1449. expr_or_declarator_intern:
    1450. 

  1450. 	  expr_or_declarator
    1451. 

  1451. 	| attributes expr_or_declarator
    1452. 

  1452. 		{
    1453. 

  1453. 		  /* Provide support for '(' attributes '*' declarator ')'
    1454. 

  1454. 		     etc */
    1455. 

  1455. 		  $$ = decl_tree_cons ($1, $2, NULL_TREE);
    1456. 

  1456. 		}
    1457. 

  1457. 	;
    1458. 

  1458. 

  1459. expr_or_declarator:
    1460. 

  1460. 	  notype_unqualified_id
    1461. 

  1461. 	| '*' expr_or_declarator_intern  %prec UNARY
    1462. 

  1462. 		{ $$ = build_parse_node (INDIRECT_REF, $2); }
    1463. 

  1463. 	| '&amp;' expr_or_declarator_intern  %prec UNARY
    1464. 

  1464. 		{ $$ = build_parse_node (ADDR_EXPR, $2); }
    1465. 

  1465. 	| '(' expr_or_declarator_intern ')'
    1466. 

  1466. 		{ $$ = $2; }
    1467. 

  1467. 	;
    1468. 

  1468. 

  1469. notype_template_declarator:
    1470. 

  1470. 	  IDENTIFIER '&lt;' template_arg_list_opt template_close_bracket
    1471. 

  1471.                 { $$ = lookup_template_function ($1, $3); }
    1472. 

  1472. 	| NSNAME '&lt;' template_arg_list template_close_bracket
    1473. 

  1473.                 { $$ = lookup_template_function ($1, $3); }
    1474. 

  1474. 	;
    1475. 

  1475. 		
    1476. 

  1476. direct_notype_declarator:
    1477. 

  1477. 	  complex_direct_notype_declarator
    1478. 

  1478. 	/* This precedence declaration is to prefer this reduce
    1479. 

  1479. 	   to the Koenig lookup shift in primary, below.  I hate yacc.  */
    1480. 

  1480. 	| notype_unqualified_id %prec '('
    1481. 

  1481. 	| notype_template_declarator
    1482. 

  1482. 	| '(' expr_or_declarator_intern ')'
    1483. 

  1483.                 { $$ = finish_decl_parsing ($2); }
    1484. 

  1484. 	;
    1485. 

  1485. 

  1486. primary:
    1487. 

  1487. 	  notype_unqualified_id
    1488. 

  1488. 		{
    1489. 

  1489. 		  if (TREE_CODE ($1) == BIT_NOT_EXPR)
    1490. 

  1490. 		    $$ = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND ($1, 0));
    1491. 

  1491. 		  else 
    1492. 

  1492. 		    $$ = finish_id_expr ($1);
    1493. 

  1493. 		}		
    1494. 

  1494. 	| CONSTANT
    1495. 

  1495. 	| boolean.literal
    1496. 

  1496. 	| string
    1497. 

  1497. 		{
    1498. 

  1498. 		  if (processing_template_decl)
    1499. 

  1499. 		    push_obstacks (&amp;permanent_obstack, &amp;permanent_obstack);
    1500. 

  1500. 		  $$ = combine_strings ($$);
    1501. 

  1501. 		  /* combine_strings doesn't set up TYPE_MAIN_VARIANT of
    1502. 

  1502. 		     a const array the way we want, so fix it.  */
    1503. 

  1503. 		  if (flag_const_strings)
    1504. 

  1504. 		    TREE_TYPE ($$) = build_cplus_array_type
    1505. 

  1505. 		      (TREE_TYPE (TREE_TYPE ($$)),
    1506. 

  1506. 		       TYPE_DOMAIN (TREE_TYPE ($$)));
    1507. 

  1507. 		  if (processing_template_decl)
    1508. 

  1508. 		    pop_obstacks ();
    1509. 

  1509. 		}
    1510. 

  1510. 	| '(' expr ')'
    1511. 

  1511. 		{ $$ = finish_parenthesized_expr ($2); }
    1512. 

  1512. 	| '(' expr_or_declarator_intern ')'
    1513. 

  1513. 		{ $2 = reparse_decl_as_expr (NULL_TREE, $2);
    1514. 

  1514. 		  $$ = finish_parenthesized_expr ($2); }
    1515. 

  1515. 	| '(' error ')'
    1516. 

  1516. 		{ $$ = error_mark_node; }
    1517. 

  1517. 	| '('
    1518. 

  1518. 		{ tree scope = current_scope ();
    1519. 

  1519. 		  if (!scope || TREE_CODE (scope) != FUNCTION_DECL)
    1520. 

  1520. 		    {
    1521. 

  1521. 		      error (&quot;braced-group within expression allowed only inside a function&quot;);
    1522. 

  1522. 		      YYERROR;
    1523. 

  1523. 		    }
    1524. 

  1524. 		  if (pedantic)
    1525. 

  1525. 		    pedwarn (&quot;ANSI C++ forbids braced-groups within expressions&quot;);  
    1526. 

  1526. 		  $&lt;ttype&gt;$ = begin_stmt_expr (); 
    1527. 

  1527. 		}
    1528. 

  1528. 	  compstmt ')'
    1529. 

  1529.                { $$ = finish_stmt_expr ($&lt;ttype&gt;2, $3); }
    1530. 

  1530.         /* Koenig lookup support
    1531. 

  1531.            We could store lastiddecl in $1 to avoid another lookup,
    1532. 

  1532.            but that would result in many additional reduce/reduce conflicts. */
    1533. 

  1533.         | notype_unqualified_id '(' nonnull_exprlist ')'
    1534. 

  1534.                { $$ = finish_call_expr ($1, $3, 1); }
    1535. 

  1535.         | notype_unqualified_id LEFT_RIGHT
    1536. 

  1536.                { $$ = finish_call_expr ($1, NULL_TREE, 1); }
    1537. 

  1537. 	| primary '(' nonnull_exprlist ')'
    1538. 

  1538.                { $$ = finish_call_expr ($1, $3, 0); }
    1539. 

  1539. 	| primary LEFT_RIGHT
    1540. 

  1540.          …
    1541.

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