PageRenderTime 61ms CodeModel.GetById 19ms RepoModel.GetById 1ms app.codeStats 0ms

/opensource.apple.com/source/gdb/gdb-330.1/src/binutils/rcparse.y

#
Happy | 1764 lines | 1632 code | 132 blank | 0 comment | 0 complexity | 87a8c4f024d0db2e2edc7c8fc8a6403b 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 
    

  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>rcparse.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">rcparse.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. %{ /* rcparse.y -- parser for Windows rc files
    24. 

  24.    Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
    25. 

  25.    Written by Ian Lance Taylor, Cygnus Support.
    26. 

    27. 

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

    29. 

  29.    This program 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 of the License, or
    32. 

  32.    (at your option) any later version.
    33. 

    34. 

  34.    This program 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 this program; if not, write to the Free Software
    41. 

  41.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
    42. 

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

  43. 

  44. /* This is a parser for Windows rc files.  It is based on the parser
    45. 

  45.    by Gunther Ebert &lt;<a href="mailto:gunther.ebert@ixos-leipzig.de">gunther.ebert@ixos-leipzig.de</a>&gt;.  */
    46. 

  46. 

  47. #include &quot;bfd.h&quot;
    48. 

  48. #include &quot;bucomm.h&quot;
    49. 

  49. #include &quot;libiberty.h&quot;
    50. 

  50. #include &quot;windres.h&quot;
    51. 

  51. #include &quot;safe-ctype.h&quot;
    52. 

  52. 

  53. /* The current language.  */
    54. 

  54. 

  55. static unsigned short language;
    56. 

  56. 

  57. /* The resource information during a sub statement.  */
    58. 

  58. 

  59. static struct res_res_info sub_res_info;
    60. 

  60. 

  61. /* Dialog information.  This is built by the nonterminals styles and
    62. 

  62.    controls.  */
    63. 

  63. 

  64. static struct dialog dialog;
    65. 

  65. 

  66. /* This is used when building a style.  It is modified by the
    67. 

  67.    nonterminal styleexpr.  */
    68. 

  68. 

  69. static unsigned long style;
    70. 

  70. 

  71. /* These are used when building a control.  They are set before using
    72. 

  72.    control_params.  */
    73. 

  73. 

  74. static unsigned long base_style;
    75. 

  75. static unsigned long default_style;
    76. 

  76. static unsigned long class;
    77. 

  77. 

  78. %}
    79. 

  79. 

  80. %union
    81. 

  81. {
    82. 

  82.   struct accelerator acc;
    83. 

  83.   struct accelerator *pacc;
    84. 

  84.   struct dialog_control *dialog_control;
    85. 

  85.   struct menuitem *menuitem;
    86. 

  86.   struct
    87. 

  87.   {
    88. 

  88.     struct rcdata_item *first;
    89. 

  89.     struct rcdata_item *last;
    90. 

  90.   } rcdata;
    91. 

  91.   struct rcdata_item *rcdata_item;
    92. 

  92.   struct stringtable_data *stringtable;
    93. 

  93.   struct fixed_versioninfo *fixver;
    94. 

  94.   struct ver_info *verinfo;
    95. 

  95.   struct ver_stringinfo *verstring;
    96. 

  96.   struct ver_varinfo *vervar;
    97. 

  97.   struct res_id id;
    98. 

  98.   struct res_res_info res_info;
    99. 

  99.   struct
    100. 

  100.   {
    101. 

  101.     unsigned short on;
    102. 

  102.     unsigned short off;
    103. 

  103.   } memflags;
    104. 

  104.   struct
    105. 

  105.   {
    106. 

  106.     unsigned long val;
    107. 

  107.     /* Nonzero if this number was explicitly specified as long.  */
    108. 

  108.     int dword;
    109. 

  109.   } i;
    110. 

  110.   unsigned long il;
    111. 

  111.   unsigned short is;
    112. 

  112.   const char *s;
    113. 

  113.   struct
    114. 

  114.   {
    115. 

  115.     unsigned long length;
    116. 

  116.     const char *s;
    117. 

  117.   } ss;
    118. 

  118. };
    119. 

  119. 

  120. %token BEG END
    121. 

  121. %token ACCELERATORS VIRTKEY ASCII NOINVERT SHIFT CONTROL ALT
    122. 

  122. %token BITMAP
    123. 

  123. %token CURSOR
    124. 

  124. %token DIALOG DIALOGEX EXSTYLE CAPTION CLASS STYLE
    125. 

  125. %token AUTO3STATE AUTOCHECKBOX AUTORADIOBUTTON CHECKBOX COMBOBOX CTEXT
    126. 

  126. %token DEFPUSHBUTTON EDITTEXT GROUPBOX LISTBOX LTEXT PUSHBOX PUSHBUTTON
    127. 

  127. %token RADIOBUTTON RTEXT SCROLLBAR STATE3 USERBUTTON
    128. 

  128. %token BEDIT HEDIT IEDIT
    129. 

  129. %token FONT
    130. 

  130. %token ICON
    131. 

  131. %token LANGUAGE CHARACTERISTICS VERSIONK
    132. 

  132. %token MENU MENUEX MENUITEM SEPARATOR POPUP CHECKED GRAYED HELP INACTIVE
    133. 

  133. %token MENUBARBREAK MENUBREAK
    134. 

  134. %token MESSAGETABLE
    135. 

  135. %token RCDATA
    136. 

  136. %token STRINGTABLE
    137. 

  137. %token VERSIONINFO FILEVERSION PRODUCTVERSION FILEFLAGSMASK FILEFLAGS
    138. 

  138. %token FILEOS FILETYPE FILESUBTYPE BLOCKSTRINGFILEINFO BLOCKVARFILEINFO
    139. 

  139. %token VALUE
    140. 

  140. %token &lt;s&gt; BLOCK
    141. 

  141. %token MOVEABLE FIXED PURE IMPURE PRELOAD LOADONCALL DISCARDABLE
    142. 

  142. %token NOT
    143. 

  143. %token &lt;s&gt; QUOTEDSTRING STRING
    144. 

  144. %token &lt;i&gt; NUMBER
    145. 

  145. %token &lt;ss&gt; SIZEDSTRING
    146. 

  146. %token IGNORED_TOKEN
    147. 

  147. 

  148. %type &lt;pacc&gt; acc_entries
    149. 

  149. %type &lt;acc&gt; acc_entry acc_event
    150. 

  150. %type &lt;dialog_control&gt; control control_params
    151. 

  151. %type &lt;menuitem&gt; menuitems menuitem menuexitems menuexitem
    152. 

  152. %type &lt;rcdata&gt; optrcdata_data optrcdata_data_int rcdata_data
    153. 

  153. %type &lt;rcdata_item&gt; opt_control_data
    154. 

  154. %type &lt;fixver&gt; fixedverinfo
    155. 

  155. %type &lt;verinfo&gt; verblocks
    156. 

  156. %type &lt;verstring&gt; vervals
    157. 

  157. %type &lt;vervar&gt; vertrans
    158. 

  158. %type &lt;res_info&gt; suboptions memflags_move_discard memflags_move
    159. 

  159. %type &lt;memflags&gt; memflag
    160. 

  160. %type &lt;id&gt; id resref
    161. 

  161. %type &lt;il&gt; exstyle parennumber
    162. 

  162. %type &lt;il&gt; numexpr posnumexpr cnumexpr optcnumexpr cposnumexpr
    163. 

  163. %type &lt;is&gt; acc_options acc_option menuitem_flags menuitem_flag
    164. 

  164. %type &lt;s&gt; optstringc file_name resname
    165. 

  165. %type &lt;i&gt; sizednumexpr sizedposnumexpr
    166. 

  166. 

  167. %left '|'
    168. 

  168. %left '^'
    169. 

  169. %left '&amp;'
    170. 

  170. %left '+' '-'
    171. 

  171. %left '*' '/' '%'
    172. 

  172. %right '~' NEG
    173. 

  173. 

  174. %%
    175. 

  175. 

  176. input:
    177. 

  177. 	  /* empty */
    178. 

  178. 	| input accelerator
    179. 

  179. 	| input bitmap
    180. 

  180. 	| input cursor
    181. 

  181. 	| input dialog
    182. 

  182. 	| input font
    183. 

  183. 	| input icon
    184. 

  184. 	| input language
    185. 

  185. 	| input menu
    186. 

  186. 	| input menuex
    187. 

  187. 	| input messagetable
    188. 

  188. 	| input rcdata
    189. 

  189. 	| input stringtable
    190. 

  190. 	| input user
    191. 

  191. 	| input versioninfo
    192. 

  192. 	| input IGNORED_TOKEN
    193. 

  193. 	;
    194. 

  194. 

  195. /* Accelerator resources.  */
    196. 

  196. 

  197. accelerator:
    198. 

  198. 	  id ACCELERATORS suboptions BEG acc_entries END
    199. 

  199. 	  {
    200. 

  200. 	    define_accelerator ($1, &amp;$3, $5);
    201. 

  201. 	    if (yychar != YYEMPTY)
    202. 

  202. 	      YYERROR;
    203. 

  203. 	    rcparse_discard_strings ();
    204. 

  204. 	  }
    205. 

  205. 	;
    206. 

  206. 

  207. acc_entries:
    208. 

  208. 	  /* empty */
    209. 

  209. 	  {
    210. 

  210. 	    $$ = NULL;
    211. 

  211. 	  }
    212. 

  212. 	| acc_entries acc_entry
    213. 

  213. 	  {
    214. 

  214. 	    struct accelerator *a;
    215. 

  215. 

  216. 	    a = (struct accelerator *) res_alloc (sizeof *a);
    217. 

  217. 	    *a = $2;
    218. 

  218. 	    if ($1 == NULL)
    219. 

  219. 	      $$ = a;
    220. 

  220. 	    else
    221. 

  221. 	      {
    222. 

  222. 		struct accelerator **pp;
    223. 

  223. 

  224. 		for (pp = &amp;$1-&gt;next; *pp != NULL; pp = &amp;(*pp)-&gt;next)
    225. 

  225. 		  ;
    226. 

  226. 		*pp = a;
    227. 

  227. 		$$ = $1;
    228. 

  228. 	      }
    229. 

  229. 	  }
    230. 

  230. 	;
    231. 

  231. 

  232. acc_entry:
    233. 

  233. 	  acc_event cposnumexpr
    234. 

  234. 	  {
    235. 

  235. 	    $$ = $1;
    236. 

  236. 	    $$.id = $2;
    237. 

  237. 	  }
    238. 

  238. 	| acc_event cposnumexpr ',' acc_options
    239. 

  239. 	  {
    240. 

  240. 	    $$ = $1;
    241. 

  241. 	    $$.id = $2;
    242. 

  242. 	    $$.flags |= $4;
    243. 

  243. 	    if (($$.flags &amp; ACC_VIRTKEY) == 0
    244. 

  244. 		&amp;&amp; ($$.flags &amp; (ACC_SHIFT | ACC_CONTROL)) != 0)
    245. 

  245. 	      rcparse_warning (_(&quot;inappropriate modifiers for non-VIRTKEY&quot;));
    246. 

  246. 	  }
    247. 

  247. 	;
    248. 

  248. 

  249. acc_event:
    250. 

  250. 	  QUOTEDSTRING
    251. 

  251. 	  {
    252. 

  252. 	    const char *s = $1;
    253. 

  253. 	    char ch;
    254. 

  254. 

  255. 	    $$.next = NULL;
    256. 

  256. 	    $$.id = 0;
    257. 

  257. 	    ch = *s;
    258. 

  258. 	    if (ch != '^')
    259. 

  259. 	      $$.flags = 0;
    260. 

  260. 	    else
    261. 

  261. 	      {
    262. 

  262. 		$$.flags = ACC_CONTROL | ACC_VIRTKEY;
    263. 

  263. 		++s;
    264. 

  264. 		ch = *s;
    265. 

  265. 		ch = TOUPPER (ch);
    266. 

  266. 	      }
    267. 

  267. 	    $$.key = ch;
    268. 

  268. 	    if (s[1] != '\0')
    269. 

  269. 	      rcparse_warning (_(&quot;accelerator should only be one character&quot;));
    270. 

  270. 	  }
    271. 

  271. 	| posnumexpr
    272. 

  272. 	  {
    273. 

  273. 	    $$.next = NULL;
    274. 

  274. 	    $$.flags = 0;
    275. 

  275. 	    $$.id = 0;
    276. 

  276. 	    $$.key = $1;
    277. 

  277. 	  }
    278. 

  278. 	;
    279. 

  279. 

  280. acc_options:
    281. 

  281. 	  acc_option
    282. 

  282. 	  {
    283. 

  283. 	    $$ = $1;
    284. 

  284. 	  }
    285. 

  285. 	| acc_options ',' acc_option
    286. 

  286. 	  {
    287. 

  287. 	    $$ = $1 | $3;
    288. 

  288. 	  }
    289. 

  289. 	/* I've had one report that the comma is optional.  */
    290. 

  290. 	| acc_options acc_option
    291. 

  291. 	  {
    292. 

  292. 	    $$ = $1 | $2;
    293. 

  293. 	  }
    294. 

  294. 	;
    295. 

  295. 

  296. acc_option:
    297. 

  297. 	  VIRTKEY
    298. 

  298. 	  {
    299. 

  299. 	    $$ = ACC_VIRTKEY;
    300. 

  300. 	  }
    301. 

  301. 	| ASCII
    302. 

  302. 	  {
    303. 

  303. 	    /* This is just the absence of VIRTKEY.  */
    304. 

  304. 	    $$ = 0;
    305. 

  305. 	  }
    306. 

  306. 	| NOINVERT
    307. 

  307. 	  {
    308. 

  308. 	    $$ = ACC_NOINVERT;
    309. 

  309. 	  }
    310. 

  310. 	| SHIFT
    311. 

  311. 	  {
    312. 

  312. 	    $$ = ACC_SHIFT;
    313. 

  313. 	  }
    314. 

  314. 	| CONTROL
    315. 

  315. 	  {
    316. 

  316. 	    $$ = ACC_CONTROL;
    317. 

  317. 	  }
    318. 

  318. 	| ALT
    319. 

  319. 	  {
    320. 

  320. 	    $$ = ACC_ALT;
    321. 

  321. 	  }
    322. 

  322. 	;
    323. 

  323. 

  324. /* Bitmap resources.  */
    325. 

  325. 

  326. bitmap:
    327. 

  327. 	  id BITMAP memflags_move file_name
    328. 

  328. 	  {
    329. 

  329. 	    define_bitmap ($1, &amp;$3, $4);
    330. 

  330. 	    if (yychar != YYEMPTY)
    331. 

  331. 	      YYERROR;
    332. 

  332. 	    rcparse_discard_strings ();
    333. 

  333. 	  }
    334. 

  334. 	;
    335. 

  335. 

  336. /* Cursor resources.  */
    337. 

  337. 

  338. cursor:
    339. 

  339. 	  id CURSOR memflags_move_discard file_name
    340. 

  340. 	  {
    341. 

  341. 	    define_cursor ($1, &amp;$3, $4);
    342. 

  342. 	    if (yychar != YYEMPTY)
    343. 

  343. 	      YYERROR;
    344. 

  344. 	    rcparse_discard_strings ();
    345. 

  345. 	  }
    346. 

  346. 	;
    347. 

  347. 

  348. /* Dialog resources.  */
    349. 

  349. 

  350. dialog:
    351. 

  351. 	  id DIALOG memflags_move exstyle posnumexpr cnumexpr cnumexpr
    352. 

  352. 	    cnumexpr
    353. 

  353. 	    {
    354. 

  354. 	      memset (&amp;dialog, 0, sizeof dialog);
    355. 

  355. 	      dialog.x = $5;
    356. 

  356. 	      dialog.y = $6;
    357. 

  357. 	      dialog.width = $7;
    358. 

  358. 	      dialog.height = $8;
    359. 

  359. 	      dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
    360. 

  360. 	      dialog.exstyle = $4;
    361. 

  361. 	      dialog.menu.named = 1;
    362. 

  362. 	      dialog.class.named = 1;
    363. 

  363. 	      dialog.font = NULL;
    364. 

  364. 	      dialog.ex = NULL;
    365. 

  365. 	      dialog.controls = NULL;
    366. 

  366. 	      sub_res_info = $3;
    367. 

  367. 	      style = 0;
    368. 

  368. 	    }
    369. 

  369. 	    styles BEG controls END
    370. 

  370. 	  {
    371. 

  371. 	    define_dialog ($1, &amp;sub_res_info, &amp;dialog);
    372. 

  372. 	    if (yychar != YYEMPTY)
    373. 

  373. 	      YYERROR;
    374. 

  374. 	    rcparse_discard_strings ();
    375. 

  375. 	  }
    376. 

  376. 	| id DIALOGEX memflags_move exstyle posnumexpr cnumexpr cnumexpr
    377. 

  377. 	    cnumexpr
    378. 

  378. 	    {
    379. 

  379. 	      memset (&amp;dialog, 0, sizeof dialog);
    380. 

  380. 	      dialog.x = $5;
    381. 

  381. 	      dialog.y = $6;
    382. 

  382. 	      dialog.width = $7;
    383. 

  383. 	      dialog.height = $8;
    384. 

  384. 	      dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
    385. 

  385. 	      dialog.exstyle = $4;
    386. 

  386. 	      dialog.menu.named = 1;
    387. 

  387. 	      dialog.class.named = 1;
    388. 

  388. 	      dialog.font = NULL;
    389. 

  389. 	      dialog.ex = ((struct dialog_ex *)
    390. 

  390. 			   res_alloc (sizeof (struct dialog_ex)));
    391. 

  391. 	      memset (dialog.ex, 0, sizeof (struct dialog_ex));
    392. 

  392. 	      dialog.controls = NULL;
    393. 

  393. 	      sub_res_info = $3;
    394. 

  394. 	      style = 0;
    395. 

  395. 	    }
    396. 

  396. 	    styles BEG controls END
    397. 

  397. 	  {
    398. 

  398. 	    define_dialog ($1, &amp;sub_res_info, &amp;dialog);
    399. 

  399. 	    if (yychar != YYEMPTY)
    400. 

  400. 	      YYERROR;
    401. 

  401. 	    rcparse_discard_strings ();
    402. 

  402. 	  }
    403. 

  403. 	| id DIALOGEX memflags_move exstyle posnumexpr cnumexpr cnumexpr
    404. 

  404. 	    cnumexpr cnumexpr
    405. 

  405. 	    {
    406. 

  406. 	      memset (&amp;dialog, 0, sizeof dialog);
    407. 

  407. 	      dialog.x = $5;
    408. 

  408. 	      dialog.y = $6;
    409. 

  409. 	      dialog.width = $7;
    410. 

  410. 	      dialog.height = $8;
    411. 

  411. 	      dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
    412. 

  412. 	      dialog.exstyle = $4;
    413. 

  413. 	      dialog.menu.named = 1;
    414. 

  414. 	      dialog.class.named = 1;
    415. 

  415. 	      dialog.font = NULL;
    416. 

  416. 	      dialog.ex = ((struct dialog_ex *)
    417. 

  417. 			   res_alloc (sizeof (struct dialog_ex)));
    418. 

  418. 	      memset (dialog.ex, 0, sizeof (struct dialog_ex));
    419. 

  419. 	      dialog.ex-&gt;help = $9;
    420. 

  420. 	      dialog.controls = NULL;
    421. 

  421. 	      sub_res_info = $3;
    422. 

  422. 	      style = 0;
    423. 

  423. 	    }
    424. 

  424. 	    styles BEG controls END
    425. 

  425. 	  {
    426. 

  426. 	    define_dialog ($1, &amp;sub_res_info, &amp;dialog);
    427. 

  427. 	    if (yychar != YYEMPTY)
    428. 

  428. 	      YYERROR;
    429. 

  429. 	    rcparse_discard_strings ();
    430. 

  430. 	  }
    431. 

  431. 	;
    432. 

  432. 

  433. exstyle:
    434. 

  434. 	  /* empty */
    435. 

  435. 	  {
    436. 

  436. 	    $$ = 0;
    437. 

  437. 	  }
    438. 

  438. 	| EXSTYLE '=' numexpr
    439. 

  439. 	  {
    440. 

  440. 	    $$ = $3;
    441. 

  441. 	  }
    442. 

  442. 	;
    443. 

  443. 

  444. styles:
    445. 

  445. 	  /* empty */
    446. 

  446. 	| styles CAPTION QUOTEDSTRING
    447. 

  447. 	  {
    448. 

  448. 	    dialog.style |= WS_CAPTION;
    449. 

  449. 	    style |= WS_CAPTION;
    450. 

  450. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.caption, $3);
    451. 

  451. 	  }
    452. 

  452. 	| styles CLASS id
    453. 

  453. 	  {
    454. 

  454. 	    dialog.class = $3;
    455. 

  455. 	  }
    456. 

  456. 	| styles STYLE
    457. 

  457. 	    styleexpr
    458. 

  458. 	  {
    459. 

  459. 	    dialog.style = style;
    460. 

  460. 	  }
    461. 

  461. 	| styles EXSTYLE numexpr
    462. 

  462. 	  {
    463. 

  463. 	    dialog.exstyle = $3;
    464. 

  464. 	  }
    465. 

  465. 	| styles CLASS QUOTEDSTRING
    466. 

  466. 	  {
    467. 

  467. 	    res_string_to_id (&amp; dialog.class, $3);
    468. 

  468. 	  }
    469. 

  469. 	| styles FONT numexpr ',' QUOTEDSTRING
    470. 

  470. 	  {
    471. 

  471. 	    dialog.style |= DS_SETFONT;
    472. 

  472. 	    style |= DS_SETFONT;
    473. 

  473. 	    dialog.pointsize = $3;
    474. 

  474. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    475. 

  475. 	    if (dialog.ex != NULL)
    476. 

  476. 	      {
    477. 

  477. 		dialog.ex-&gt;weight = 0;
    478. 

  478. 		dialog.ex-&gt;italic = 0;
    479. 

  479. 		dialog.ex-&gt;charset = 1;
    480. 

  480. 	      }
    481. 

  481. 	  }
    482. 

  482. 	| styles FONT numexpr ',' QUOTEDSTRING cnumexpr
    483. 

  483. 	  {
    484. 

  484. 	    dialog.style |= DS_SETFONT;
    485. 

  485. 	    style |= DS_SETFONT;
    486. 

  486. 	    dialog.pointsize = $3;
    487. 

  487. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    488. 

  488. 	    if (dialog.ex == NULL)
    489. 

  489. 	      rcparse_warning (_(&quot;extended FONT requires DIALOGEX&quot;));
    490. 

  490. 	    else
    491. 

  491. 	      {
    492. 

  492. 		dialog.ex-&gt;weight = $6;
    493. 

  493. 		dialog.ex-&gt;italic = 0;
    494. 

  494. 		dialog.ex-&gt;charset = 1;
    495. 

  495. 	      }
    496. 

  496. 	  }
    497. 

  497. 	| styles FONT numexpr ',' QUOTEDSTRING cnumexpr cnumexpr
    498. 

  498. 	  {
    499. 

  499. 	    dialog.style |= DS_SETFONT;
    500. 

  500. 	    style |= DS_SETFONT;
    501. 

  501. 	    dialog.pointsize = $3;
    502. 

  502. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    503. 

  503. 	    if (dialog.ex == NULL)
    504. 

  504. 	      rcparse_warning (_(&quot;extended FONT requires DIALOGEX&quot;));
    505. 

  505. 	    else
    506. 

  506. 	      {
    507. 

  507. 		dialog.ex-&gt;weight = $6;
    508. 

  508. 		dialog.ex-&gt;italic = $7;
    509. 

  509. 		dialog.ex-&gt;charset = 1;
    510. 

  510. 	      }
    511. 

  511. 	  }
    512. 

  512. 	| styles FONT numexpr ',' QUOTEDSTRING cnumexpr cnumexpr cnumexpr
    513. 

  513. 	  {
    514. 

  514. 	    dialog.style |= DS_SETFONT;
    515. 

  515. 	    style |= DS_SETFONT;
    516. 

  516. 	    dialog.pointsize = $3;
    517. 

  517. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    518. 

  518. 	    if (dialog.ex == NULL)
    519. 

  519. 	      rcparse_warning (_(&quot;extended FONT requires DIALOGEX&quot;));
    520. 

  520. 	    else
    521. 

  521. 	      {
    522. 

  522. 		dialog.ex-&gt;weight = $6;
    523. 

  523. 		dialog.ex-&gt;italic = $7;
    524. 

  524. 		dialog.ex-&gt;charset = $8;
    525. 

  525. 	      }
    526. 

  526. 	  }
    527. 

  527. 	| styles MENU id
    528. 

  528. 	  {
    529. 

  529. 	    dialog.menu = $3;
    530. 

  530. 	  }
    531. 

  531. 	| styles CHARACTERISTICS numexpr
    532. 

  532. 	  {
    533. 

  533. 	    sub_res_info.characteristics = $3;
    534. 

  534. 	  }
    535. 

  535. 	| styles LANGUAGE numexpr cnumexpr
    536. 

  536. 	  {
    537. 

  537. 	    sub_res_info.language = $3 | ($4 &lt;&lt; SUBLANG_SHIFT);
    538. 

  538. 	  }
    539. 

  539. 	| styles VERSIONK numexpr
    540. 

  540. 	  {
    541. 

  541. 	    sub_res_info.version = $3;
    542. 

  542. 	  }
    543. 

  543. 	;
    544. 

  544. 

  545. controls:
    546. 

  546. 	  /* empty */
    547. 

  547. 	| controls control
    548. 

  548. 	  {
    549. 

  549. 	    struct dialog_control **pp;
    550. 

  550. 

  551. 	    for (pp = &amp;dialog.controls; *pp != NULL; pp = &amp;(*pp)-&gt;next)
    552. 

  552. 	      ;
    553. 

  553. 	    *pp = $2;
    554. 

  554. 	  }
    555. 

  555. 	;
    556. 

  556. 

  557. control:
    558. 

  558. 	  AUTO3STATE
    559. 

  559. 	    {
    560. 

  560. 	      default_style = BS_AUTO3STATE | WS_TABSTOP;
    561. 

  561. 	      base_style = BS_AUTO3STATE;
    562. 

  562. 	      class = CTL_BUTTON;
    563. 

  563. 	    }
    564. 

  564. 	    control_params
    565. 

  565. 	  {
    566. 

  566. 	    $$ = $3;
    567. 

  567. 	  }
    568. 

  568. 	| AUTOCHECKBOX
    569. 

  569. 	    {
    570. 

  570. 	      default_style = BS_AUTOCHECKBOX | WS_TABSTOP;
    571. 

  571. 	      base_style = BS_AUTOCHECKBOX;
    572. 

  572. 	      class = CTL_BUTTON;
    573. 

  573. 	    }
    574. 

  574. 	    control_params
    575. 

  575. 	  {
    576. 

  576. 	    $$ = $3;
    577. 

  577. 	  }
    578. 

  578. 	| AUTORADIOBUTTON
    579. 

  579. 	    {
    580. 

  580. 	      default_style = BS_AUTORADIOBUTTON | WS_TABSTOP;
    581. 

  581. 	      base_style = BS_AUTORADIOBUTTON;
    582. 

  582. 	      class = CTL_BUTTON;
    583. 

  583. 	    }
    584. 

  584. 	    control_params
    585. 

  585. 	  {
    586. 

  586. 	    $$ = $3;
    587. 

  587. 	  }
    588. 

  588. 	| BEDIT
    589. 

  589. 	    {
    590. 

  590. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    591. 

  591. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    592. 

  592. 	      class = CTL_EDIT;
    593. 

  593. 	    }
    594. 

  594. 	    control_params
    595. 

  595. 	  {
    596. 

  596. 	    $$ = $3;
    597. 

  597. 	    if (dialog.ex == NULL)
    598. 

  598. 	      rcparse_warning (_(&quot;BEDIT requires DIALOGEX&quot;));
    599. 

  599. 	    res_string_to_id (&amp;$$-&gt;class, &quot;BEDIT&quot;);
    600. 

  600. 	  }
    601. 

  601. 	| CHECKBOX
    602. 

  602. 	    {
    603. 

  603. 	      default_style = BS_CHECKBOX | WS_TABSTOP;
    604. 

  604. 	      base_style = BS_CHECKBOX | WS_TABSTOP;
    605. 

  605. 	      class = CTL_BUTTON;
    606. 

  606. 	    }
    607. 

  607. 	    control_params
    608. 

  608. 	  {
    609. 

  609. 	    $$ = $3;
    610. 

  610. 	  }
    611. 

  611. 	| COMBOBOX
    612. 

  612. 	    {
    613. 

  613. 	      default_style = CBS_SIMPLE | WS_TABSTOP;
    614. 

  614. 	      base_style = 0;
    615. 

  615. 	      class = CTL_COMBOBOX;
    616. 

  616. 	    }
    617. 

  617. 	    control_params
    618. 

  618. 	  {
    619. 

  619. 	    $$ = $3;
    620. 

  620. 	  }
    621. 

  621. 	| CONTROL optstringc numexpr cnumexpr control_styleexpr cnumexpr
    622. 

  622. 	    cnumexpr cnumexpr cnumexpr optcnumexpr opt_control_data
    623. 

  623. 	  {
    624. 

  624. 	    $$ = define_control ($2, $3, $6, $7, $8, $9, $4, style, $10);
    625. 

  625. 	    if ($11 != NULL)
    626. 

  626. 	      {
    627. 

  627. 		if (dialog.ex == NULL)
    628. 

  628. 		  rcparse_warning (_(&quot;control data requires DIALOGEX&quot;));
    629. 

  629. 		$$-&gt;data = $11;
    630. 

  630. 	      }
    631. 

  631. 	  }
    632. 

  632. 	| CONTROL optstringc numexpr cnumexpr control_styleexpr cnumexpr
    633. 

  633. 	    cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr opt_control_data
    634. 

  634. 	  {
    635. 

  635. 	    $$ = define_control ($2, $3, $6, $7, $8, $9, $4, style, $10);
    636. 

  636. 	    if (dialog.ex == NULL)
    637. 

  637. 	      rcparse_warning (_(&quot;help ID requires DIALOGEX&quot;));
    638. 

  638. 	    $$-&gt;help = $11;
    639. 

  639. 	    $$-&gt;data = $12;
    640. 

  640. 	  }
    641. 

  641. 	| CONTROL optstringc numexpr ',' QUOTEDSTRING control_styleexpr
    642. 

  642. 	    cnumexpr cnumexpr cnumexpr cnumexpr optcnumexpr opt_control_data
    643. 

  643. 	  {
    644. 

  644. 	    $$ = define_control ($2, $3, $7, $8, $9, $10, 0, style, $11);
    645. 

  645. 	    if ($12 != NULL)
    646. 

  646. 	      {
    647. 

  647. 		if (dialog.ex == NULL)
    648. 

  648. 		  rcparse_warning (&quot;control data requires DIALOGEX&quot;);
    649. 

  649. 		$$-&gt;data = $12;
    650. 

  650. 	      }
    651. 

  651. 	    $$-&gt;class.named = 1;
    652. 

  652.   	    unicode_from_ascii (&amp;$$-&gt;class.u.n.length, &amp;$$-&gt;class.u.n.name, $5);
    653. 

  653. 	  }
    654. 

  654. 	| CONTROL optstringc numexpr ',' QUOTEDSTRING control_styleexpr
    655. 

  655. 	    cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr opt_control_data
    656. 

  656. 	  {
    657. 

  657. 	    $$ = define_control ($2, $3, $7, $8, $9, $10, 0, style, $11);
    658. 

  658. 	    if (dialog.ex == NULL)
    659. 

  659. 	      rcparse_warning (&quot;help ID requires DIALOGEX&quot;);
    660. 

  660. 	    $$-&gt;help = $12;
    661. 

  661. 	    $$-&gt;data = $13;
    662. 

  662. 	    $$-&gt;class.named = 1;
    663. 

  663.   	    unicode_from_ascii (&amp;$$-&gt;class.u.n.length, &amp;$$-&gt;class.u.n.name, $5);
    664. 

  664. 	  }
    665. 

  665. 	| CTEXT
    666. 

  666. 	    {
    667. 

  667. 	      default_style = SS_CENTER | WS_GROUP;
    668. 

  668. 	      base_style = SS_CENTER;
    669. 

  669. 	      class = CTL_STATIC;
    670. 

  670. 	    }
    671. 

  671. 	    control_params
    672. 

  672. 	  {
    673. 

  673. 	    $$ = $3;
    674. 

  674. 	  }
    675. 

  675. 	| DEFPUSHBUTTON
    676. 

  676. 	    {
    677. 

  677. 	      default_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
    678. 

  678. 	      base_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
    679. 

  679. 	      class = CTL_BUTTON;
    680. 

  680. 	    }
    681. 

  681. 	    control_params
    682. 

  682. 	  {
    683. 

  683. 	    $$ = $3;
    684. 

  684. 	  }
    685. 

  685. 	| EDITTEXT
    686. 

  686. 	    {
    687. 

  687. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    688. 

  688. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    689. 

  689. 	      class = CTL_EDIT;
    690. 

  690. 	    }
    691. 

  691. 	    control_params
    692. 

  692. 	  {
    693. 

  693. 	    $$ = $3;
    694. 

  694. 	  }
    695. 

  695. 	| GROUPBOX
    696. 

  696. 	    {
    697. 

  697. 	      default_style = BS_GROUPBOX;
    698. 

  698. 	      base_style = BS_GROUPBOX;
    699. 

  699. 	      class = CTL_BUTTON;
    700. 

  700. 	    }
    701. 

  701. 	    control_params
    702. 

  702. 	  {
    703. 

  703. 	    $$ = $3;
    704. 

  704. 	  }
    705. 

  705. 	| HEDIT
    706. 

  706. 	    {
    707. 

  707. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    708. 

  708. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    709. 

  709. 	      class = CTL_EDIT;
    710. 

  710. 	    }
    711. 

  711. 	    control_params
    712. 

  712. 	  {
    713. 

  713. 	    $$ = $3;
    714. 

  714. 	    if (dialog.ex == NULL)
    715. 

  715. 	      rcparse_warning (_(&quot;IEDIT requires DIALOGEX&quot;));
    716. 

  716. 	    res_string_to_id (&amp;$$-&gt;class, &quot;HEDIT&quot;);
    717. 

  717. 	  }
    718. 

  718. 	| ICON resref numexpr cnumexpr cnumexpr opt_control_data
    719. 

  719.           {
    720. 

  720. 	    $$ = define_icon_control ($2, $3, $4, $5, 0, 0, 0, $6,
    721. 

  721. 				      dialog.ex);
    722. 

  722.           }
    723. 

  723. 	| ICON resref numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    724. 

  724. 	    opt_control_data
    725. 

  725.           {
    726. 

  726. 	    $$ = define_icon_control ($2, $3, $4, $5, 0, 0, 0, $8,
    727. 

  727. 				      dialog.ex);
    728. 

  728.           }
    729. 

  729. 	| ICON resref numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    730. 

  730. 	    icon_styleexpr optcnumexpr opt_control_data
    731. 

  731.           {
    732. 

  732. 	    $$ = define_icon_control ($2, $3, $4, $5, style, $9, 0, $10,
    733. 

  733. 				      dialog.ex);
    734. 

  734.           }
    735. 

  735. 	| ICON resref numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    736. 

  736. 	    icon_styleexpr cnumexpr cnumexpr opt_control_data
    737. 

  737.           {
    738. 

  738. 	    $$ = define_icon_control ($2, $3, $4, $5, style, $9, $10, $11,
    739. 

  739. 				      dialog.ex);
    740. 

  740.           }
    741. 

  741. 	| IEDIT
    742. 

  742. 	    {
    743. 

  743. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    744. 

  744. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    745. 

  745. 	      class = CTL_EDIT;
    746. 

  746. 	    }
    747. 

  747. 	    control_params
    748. 

  748. 	  {
    749. 

  749. 	    $$ = $3;
    750. 

  750. 	    if (dialog.ex == NULL)
    751. 

  751. 	      rcparse_warning (_(&quot;IEDIT requires DIALOGEX&quot;));
    752. 

  752. 	    res_string_to_id (&amp;$$-&gt;class, &quot;IEDIT&quot;);
    753. 

  753. 	  }
    754. 

  754. 	| LISTBOX
    755. 

  755. 	    {
    756. 

  756. 	      default_style = LBS_NOTIFY | WS_BORDER;
    757. 

  757. 	      base_style = LBS_NOTIFY | WS_BORDER;
    758. 

  758. 	      class = CTL_LISTBOX;
    759. 

  759. 	    }
    760. 

  760. 	    control_params
    761. 

  761. 	  {
    762. 

  762. 	    $$ = $3;
    763. 

  763. 	  }
    764. 

  764. 	| LTEXT
    765. 

  765. 	    {
    766. 

  766. 	      default_style = SS_LEFT | WS_GROUP;
    767. 

  767. 	      base_style = SS_LEFT;
    768. 

  768. 	      class = CTL_STATIC;
    769. 

  769. 	    }
    770. 

  770. 	    control_params
    771. 

  771. 	  {
    772. 

  772. 	    $$ = $3;
    773. 

  773. 	  }
    774. 

  774. 	| PUSHBOX
    775. 

  775. 	    {
    776. 

  776. 	      default_style = BS_PUSHBOX | WS_TABSTOP;
    777. 

  777. 	      base_style = BS_PUSHBOX;
    778. 

  778. 	      class = CTL_BUTTON;
    779. 

  779. 	    }
    780. 

  780. 	    control_params
    781. 

  781. 	  {
    782. 

  782. 	    $$ = $3;
    783. 

  783. 	  }
    784. 

  784. 	| PUSHBUTTON
    785. 

  785. 	    {
    786. 

  786. 	      default_style = BS_PUSHBUTTON | WS_TABSTOP;
    787. 

  787. 	      base_style = BS_PUSHBUTTON | WS_TABSTOP;
    788. 

  788. 	      class = CTL_BUTTON;
    789. 

  789. 	    }
    790. 

  790. 	    control_params
    791. 

  791. 	  {
    792. 

  792. 	    $$ = $3;
    793. 

  793. 	  }
    794. 

  794. 	| RADIOBUTTON
    795. 

  795. 	    {
    796. 

  796. 	      default_style = BS_RADIOBUTTON | WS_TABSTOP;
    797. 

  797. 	      base_style = BS_RADIOBUTTON;
    798. 

  798. 	      class = CTL_BUTTON;
    799. 

  799. 	    }
    800. 

  800. 	    control_params
    801. 

  801. 	  {
    802. 

  802. 	    $$ = $3;
    803. 

  803. 	  }
    804. 

  804. 	| RTEXT
    805. 

  805. 	    {
    806. 

  806. 	      default_style = SS_RIGHT | WS_GROUP;
    807. 

  807. 	      base_style = SS_RIGHT;
    808. 

  808. 	      class = CTL_STATIC;
    809. 

  809. 	    }
    810. 

  810. 	    control_params
    811. 

  811. 	  {
    812. 

  812. 	    $$ = $3;
    813. 

  813. 	  }
    814. 

  814. 	| SCROLLBAR
    815. 

  815. 	    {
    816. 

  816. 	      default_style = SBS_HORZ;
    817. 

  817. 	      base_style = 0;
    818. 

  818. 	      class = CTL_SCROLLBAR;
    819. 

  819. 	    }
    820. 

  820. 	    control_params
    821. 

  821. 	  {
    822. 

  822. 	    $$ = $3;
    823. 

  823. 	  }
    824. 

  824. 	| STATE3
    825. 

  825. 	    {
    826. 

  826. 	      default_style = BS_3STATE | WS_TABSTOP;
    827. 

  827. 	      base_style = BS_3STATE;
    828. 

  828. 	      class = CTL_BUTTON;
    829. 

  829. 	    }
    830. 

  830. 	    control_params
    831. 

  831. 	  {
    832. 

  832. 	    $$ = $3;
    833. 

  833. 	  }
    834. 

  834. 	| USERBUTTON QUOTEDSTRING ',' numexpr ',' numexpr ',' numexpr ','
    835. 

  835. 	    numexpr ',' numexpr ',' 
    836. 

  836. 	    { style = WS_CHILD | WS_VISIBLE; }
    837. 

  837. 	    styleexpr optcnumexpr
    838. 

  838. 	  {
    839. 

  839. 	    $$ = define_control ($2, $4, $6, $8, $10, $12, CTL_BUTTON,
    840. 

  840. 				 style, $16);
    841. 

  841. 	  }
    842. 

  842. 	;
    843. 

  843. 

  844. /* Parameters for a control.  The static variables DEFAULT_STYLE,
    845. 

  845.    BASE_STYLE, and CLASS must be initialized before this nonterminal
    846. 

  846.    is used.  DEFAULT_STYLE is the style to use if no style expression
    847. 

  847.    is specified.  BASE_STYLE is the base style to use if a style
    848. 

  848.    expression is specified; the style expression modifies the base
    849. 

  849.    style.  CLASS is the class of the control.  */
    850. 

  850. 

  851. control_params:
    852. 

  852. 	  optstringc numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    853. 

  853. 	    opt_control_data
    854. 

  854. 	  {
    855. 

  855. 	    $$ = define_control ($1, $2, $3, $4, $5, $6, class,
    856. 

  856. 				 default_style | WS_CHILD | WS_VISIBLE, 0);
    857. 

  857. 	    if ($7 != NULL)
    858. 

  858. 	      {
    859. 

  859. 		if (dialog.ex == NULL)
    860. 

  860. 		  rcparse_warning (_(&quot;control data requires DIALOGEX&quot;));
    861. 

  861. 		$$-&gt;data = $7;
    862. 

  862. 	      }
    863. 

  863. 	  }
    864. 

  864. 	| optstringc numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    865. 

  865. 	    control_params_styleexpr optcnumexpr opt_control_data
    866. 

  866. 	  {
    867. 

  867. 	    $$ = define_control ($1, $2, $3, $4, $5, $6, class, style, $8);
    868. 

  868. 	    if ($9 != NULL)
    869. 

  869. 	      {
    870. 

  870. 		if (dialog.ex == NULL)
    871. 

  871. 		  rcparse_warning (_(&quot;control data requires DIALOGEX&quot;));
    872. 

  872. 		$$-&gt;data = $9;
    873. 

  873. 	      }
    874. 

  874. 	  }
    875. 

  875. 	| optstringc numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    876. 

  876. 	    control_params_styleexpr cnumexpr cnumexpr opt_control_data
    877. 

  877. 	  {
    878. 

  878. 	    $$ = define_control ($1, $2, $3, $4, $5, $6, class, style, $8);
    879. 

  879. 	    if (dialog.ex == NULL)
    880. 

  880. 	      rcparse_warning (_(&quot;help ID requires DIALOGEX&quot;));
    881. 

  881. 	    $$-&gt;help = $9;
    882. 

  882. 	    $$-&gt;data = $10;
    883. 

  883. 	  }
    884. 

  884. 	;
    885. 

  885. 

  886. optstringc:
    887. 

  887. 	  /* empty */
    888. 

  888. 	  {
    889. 

  889. 	    $$ = NULL;
    890. 

  890. 	  }
    891. 

  891. 	| QUOTEDSTRING
    892. 

  892. 	  {
    893. 

  893. 	    $$ = $1;
    894. 

  894. 	  }
    895. 

  895. 	| QUOTEDSTRING ','
    896. 

  896. 	  {
    897. 

  897. 	    $$ = $1;
    898. 

  898. 	  }
    899. 

  899. 	;
    900. 

  900. 

  901. opt_control_data:
    902. 

  902. 	  /* empty */
    903. 

  903. 	  {
    904. 

  904. 	    $$ = NULL;
    905. 

  905. 	  }
    906. 

  906. 	| BEG optrcdata_data END
    907. 

  907. 	  {
    908. 

  908. 	    $$ = $2.first;
    909. 

  909. 	  }
    910. 

  910. 	;
    911. 

  911. 

  912. /* These only exist to parse a reduction out of a common case.  */
    913. 

  913. 

  914. control_styleexpr:
    915. 

  915. 	  ','
    916. 

  916. 	  { style = WS_CHILD | WS_VISIBLE; }
    917. 

  917. 	  styleexpr
    918. 

  918. 	;
    919. 

  919. 

  920. icon_styleexpr:
    921. 

  921. 	  ','
    922. 

  922. 	  { style = SS_ICON | WS_CHILD | WS_VISIBLE; }
    923. 

  923. 	  styleexpr
    924. 

  924. 	;
    925. 

  925. 

  926. control_params_styleexpr:
    927. 

  927. 	  ','
    928. 

  928. 	  { style = base_style | WS_CHILD | WS_VISIBLE; }
    929. 

  929. 	  styleexpr
    930. 

  930. 	;
    931. 

  931. 

  932. /* Font resources.  */
    933. 

  933. 

  934. font:
    935. 

  935. 	  id FONT memflags_move_discard file_name
    936. 

  936. 	  {
    937. 

  937. 	    define_font ($1, &amp;$3, $4);
    938. 

  938. 	    if (yychar != YYEMPTY)
    939. 

  939. 	      YYERROR;
    940. 

  940. 	    rcparse_discard_strings ();
    941. 

  941. 	  }
    942. 

  942. 	;
    943. 

  943. 

  944. /* Icon resources.  */
    945. 

  945. 

  946. icon:
    947. 

  947. 	  id ICON memflags_move_discard file_name
    948. 

  948. 	  {
    949. 

  949. 	    define_icon ($1, &amp;$3, $4);
    950. 

  950. 	    if (yychar != YYEMPTY)
    951. 

  951. 	      YYERROR;
    952. 

  952. 	    rcparse_discard_strings ();
    953. 

  953. 	  }
    954. 

  954. 	;
    955. 

  955. 

  956. /* Language command.  This changes the static variable language, which
    957. 

  957.    affects all subsequent resources.  */
    958. 

  958. 

  959. language:
    960. 

  960. 	  LANGUAGE numexpr cnumexpr
    961. 

  961. 	  {
    962. 

  962. 	    language = $2 | ($3 &lt;&lt; SUBLANG_SHIFT);
    963. 

  963. 	  }
    964. 

  964. 	;
    965. 

  965. 

  966. /* Menu resources.  */
    967. 

  967. 

  968. menu:
    969. 

  969. 	  id MENU suboptions BEG menuitems END
    970. 

  970. 	  {
    971. 

  971. 	    define_menu ($1, &amp;$3, $5);
    972. 

  972. 	    if (yychar != YYEMPTY)
    973. 

  973. 	      YYERROR;
    974. 

  974. 	    rcparse_discard_strings ();
    975. 

  975. 	  }
    976. 

  976. 	;
    977. 

  977. 

  978. menuitems:
    979. 

  979. 	  /* empty */
    980. 

  980. 	  {
    981. 

  981. 	    $$ = NULL;
    982. 

  982. 	  }
    983. 

  983. 	| menuitems menuitem
    984. 

  984. 	  {
    985. 

  985. 	    if ($1 == NULL)
    986. 

  986. 	      $$ = $2;
    987. 

  987. 	    else
    988. 

  988. 	      {
    989. 

  989. 		struct menuitem **pp;
    990. 

  990. 

  991. 		for (pp = &amp;$1-&gt;next; *pp != NULL; pp = &amp;(*pp)-&gt;next)
    992. 

  992. 		  ;
    993. 

  993. 		*pp = $2;
    994. 

  994. 		$$ = $1;
    995. 

  995. 	      }
    996. 

  996. 	  }
    997. 

  997. 	;
    998. 

  998. 

  999. menuitem:
    1000. 

  1000. 	  MENUITEM QUOTEDSTRING cnumexpr menuitem_flags
    1001. 

  1001. 	  {
    1002. 

  1002. 	    $$ = define_menuitem ($2, $3, $4, 0, 0, NULL);
    1003. 

  1003. 	  }
    1004. 

  1004. 	| MENUITEM SEPARATOR
    1005. 

  1005. 	  {
    1006. 

  1006. 	    $$ = define_menuitem (NULL, 0, 0, 0, 0, NULL);
    1007. 

  1007. 	  }
    1008. 

  1008. 	| POPUP QUOTEDSTRING menuitem_flags BEG menuitems END
    1009. 

  1009. 	  {
    1010. 

  1010. 	    $$ = define_menuitem ($2, 0, $3, 0, 0, $5);
    1011. 

  1011. 	  }
    1012. 

  1012. 	;
    1013. 

  1013. 

  1014. menuitem_flags:
    1015. 

  1015. 	  /* empty */
    1016. 

  1016. 	  {
    1017. 

  1017. 	    $$ = 0;
    1018. 

  1018. 	  }
    1019. 

  1019. 	| menuitem_flags ',' menuitem_flag
    1020. 

  1020. 	  {
    1021. 

  1021. 	    $$ = $1 | $3;
    1022. 

  1022. 	  }
    1023. 

  1023. 	| menuitem_flags menuitem_flag
    1024. 

  1024. 	  {
    1025. 

  1025. 	    $$ = $1 | $2;
    1026. 

  1026. 	  }
    1027. 

  1027. 	;
    1028. 

  1028. 

  1029. menuitem_flag:
    1030. 

  1030. 	  CHECKED
    1031. 

  1031. 	  {
    1032. 

  1032. 	    $$ = MENUITEM_CHECKED;
    1033. 

  1033. 	  }
    1034. 

  1034. 	| GRAYED
    1035. 

  1035. 	  {
    1036. 

  1036. 	    $$ = MENUITEM_GRAYED;
    1037. 

  1037. 	  }
    1038. 

  1038. 	| HELP
    1039. 

  1039. 	  {
    1040. 

  1040. 	    $$ = MENUITEM_HELP;
    1041. 

  1041. 	  }
    1042. 

  1042. 	| INACTIVE
    1043. 

  1043. 	  {
    1044. 

  1044. 	    $$ = MENUITEM_INACTIVE;
    1045. 

  1045. 	  }
    1046. 

  1046. 	| MENUBARBREAK
    1047. 

  1047. 	  {
    1048. 

  1048. 	    $$ = MENUITEM_MENUBARBREAK;
    1049. 

  1049. 	  }
    1050. 

  1050. 	| MENUBREAK
    1051. 

  1051. 	  {
    1052. 

  1052. 	    $$ = MENUITEM_MENUBREAK;
    1053. 

  1053. 	  }
    1054. 

  1054. 	;
    1055. 

  1055. 

  1056. /* Menuex resources.  */
    1057. 

  1057. 

  1058. menuex:
    1059. 

  1059. 	  id MENUEX suboptions BEG menuexitems END
    1060. 

  1060. 	  {
    1061. 

  1061. 	    define_menu ($1, &amp;$3, $5);
    1062. 

  1062. 	    if (yychar != YYEMPTY)
    1063. 

  1063. 	      YYERROR;
    1064. 

  1064. 	    rcparse_discard_strings ();
    1065. 

  1065. 	  }
    1066. 

  1066. 	;
    1067. 

  1067. 

  1068. menuexitems:
    1069. 

  1069. 	  /* empty */
    1070. 

  1070. 	  {
    1071. 

  1071. 	    $$ = NULL;
    1072. 

  1072. 	  }
    1073. 

  1073. 	| menuexitems menuexitem
    1074. 

  1074. 	  {
    1075. 

  1075. 	    if ($1 == NULL)
    1076. 

  1076. 	      $$ = $2;
    1077. 

  1077. 	    else
    1078. 

  1078. 	      {
    1079. 

  1079. 		struct menuitem **pp;
    1080. 

  1080. 

  1081. 		for (pp = &amp;$1-&gt;next; *pp != NULL; pp = &amp;(*pp)-&gt;next)
    1082. 

  1082. 		  ;
    1083. 

  1083. 		*pp = $2;
    1084. 

  1084. 		$$ = $1;
    1085. 

  1085. 	      }
    1086. 

  1086. 	  }
    1087. 

  1087. 	;
    1088. 

  1088. 

  1089. menuexitem:
    1090. 

  1090. 	  MENUITEM QUOTEDSTRING
    1091. 

  1091. 	  {
    1092. 

  1092. 	    $$ = define_menuitem ($2, 0, 0, 0, 0, NULL);
    1093. 

  1093. 	  }
    1094. 

  1094. 	| MENUITEM QUOTEDSTRING cnumexpr
    1095. 

  1095. 	  {
    1096. 

  1096. 	    $$ = define_menuitem ($2, $3, 0, 0, 0, NULL);
    1097. 

  1097. 	  }
    1098. 

  1098. 	| MENUITEM QUOTEDSTRING cnumexpr cnumexpr optcnumexpr
    1099. 

  1099. 	  {
    1100. 

  1100. 	    $$ = define_menuitem ($2, $3, $4, $5, 0, NULL);
    1101. 

  1101. 	  }
    1102. 

  1102.  	| MENUITEM SEPARATOR
    1103. 

  1103.  	  {
    1104. 

  1104.  	    $$ = define_menuitem (NULL, 0, 0, 0, 0, NULL);
    1105. 

  1105.  	  }
    1106. 

  1106. 	| POPUP QUOTEDSTRING BEG menuexitems END
    1107. 

  1107. 	  {
    1108. 

  1108. 	    $$ = define_menuitem ($2, 0, 0, 0, 0, $4);
    1109. 

  1109. 	  }
    1110. 

  1110. 	| POPUP QUOTEDSTRING cnumexpr BEG menuexitems END
    1111. 

  1111. 	  {
    1112. 

  1112. 	    $$ = define_menuitem ($2, $3, 0, 0, 0, $5);
    1113. 

  1113. 	  }
    1114. 

  1114. 	| POPUP QUOTEDSTRING cnumexpr cnumexpr BEG menuexitems END
    1115. 

  1115. 	  {
    1116. 

  1116. 	    $$ = define_menuitem ($2, $3, $4, 0, 0, $6);
    1117. 

  1117. 	  }
    1118. 

  1118. 	| POPUP QUOTEDSTRING cnumexpr cnumexpr cnumexpr optcnumexpr
    1119. 

  1119. 	    BEG menuexitems END
    1120. 

  1120. 	  {
    1121. 

  1121. 	    $$ = define_menuitem ($2, $3, $4, $5, $6, $8);
    1122. 

  1122. 	  }
    1123. 

  1123. 	;
    1124. 

  1124. 

  1125. /* Messagetable resources.  */
    1126. 

  1126. 

  1127. messagetable:
    1128. 

  1128. 	  id MESSAGETABLE memflags_move file_name
    1129. 

  1129. 	  {
    1130. 

  1130. 	    define_messagetable ($1, &amp;$3, $4);
    1131. 

  1131. 	    if (yychar != YYEMPTY)
    1132. 

  1132. 	      YYERROR;
    1133. 

  1133. 	    rcparse_discard_strings ();
    1134. 

  1134. 	  }
    1135. 

  1135. 	;
    1136. 

  1136. 

  1137. /* Rcdata resources.  */
    1138. 

  1138. 

  1139. rcdata:
    1140. 

  1140. 	  id RCDATA suboptions BEG optrcdata_data END
    1141. 

  1141. 	  {
    1142. 

  1142. 	    define_rcdata ($1, &amp;$3, $5.first);
    1143. 

  1143. 	    if (yychar != YYEMPTY)
    1144. 

  1144. 	      YYERROR;
    1145. 

  1145. 	    rcparse_discard_strings ();
    1146. 

  1146. 	  }
    1147. 

  1147. 	;
    1148. 

  1148. 

  1149. /* We use a different lexing algorithm, because rcdata strings may
    1150. 

  1150.    contain embedded null bytes, and we need to know the length to use.  */
    1151. 

  1151. 

  1152. optrcdata_data:
    1153. 

  1153. 	  {
    1154. 

  1154. 	    rcparse_rcdata ();
    1155. 

  1155. 	  }
    1156. 

  1156. 	  optrcdata_data_int
    1157. 

  1157. 	  {
    1158. 

  1158. 	    rcparse_normal ();
    1159. 

  1159. 	    $$ = $2;
    1160. 

  1160. 	  }
    1161. 

  1161. 	;
    1162. 

  1162. 

  1163. optrcdata_data_int:
    1164. 

  1164. 	  /* empty */
    1165. 

  1165. 	  {
    1166. 

  1166. 	    $$.first = NULL;
    1167. 

  1167. 	    $$.last = NULL;
    1168. 

  1168. 	  }
    1169. 

  1169. 	| rcdata_data
    1170. 

  1170. 	  {
    1171. 

  1171. 	    $$ = $1;
    1172. 

  1172. 	  }
    1173. 

  1173. 	;
    1174. 

  1174. 

  1175. rcdata_data:
    1176. 

  1176. 	  SIZEDSTRING
    1177. 

  1177. 	  {
    1178. 

  1178. 	    struct rcdata_item *ri;
    1179. 

  1179. 

  1180. 	    ri = define_rcdata_string ($1.s, $1.length);
    1181. 

  1181. 	    $$.first = ri;
    1182. 

  1182. 	    $$.last = ri;
    1183. 

  1183. 	  }
    1184. 

  1184. 	| sizednumexpr
    1185. 

  1185. 	  {
    1186. 

  1186. 	    struct rcdata_item *ri;
    1187. 

  1187. 

  1188. 	    ri = define_rcdata_number ($1.val, $1.dword);
    1189. 

  1189. 	    $$.first = ri;
    1190. 

  1190. 	    $$.last = ri;
    1191. 

  1191. 	  }
    1192. 

  1192. 	| rcdata_data ',' SIZEDSTRING
    1193. 

  1193. 	  {
    1194. 

  1194. 	    struct rcdata_item *ri;
    1195. 

  1195. 

  1196. 	    ri = define_rcdata_string ($3.s, $3.length);
    1197. 

  1197. 	    $$.first = $1.first;
    1198. 

  1198. 	    $1.last-&gt;next = ri;
    1199. 

  1199. 	    $$.last = ri;
    1200. 

  1200. 	  }
    1201. 

  1201. 	| rcdata_data ',' sizednumexpr
    1202. 

  1202. 	  {
    1203. 

  1203. 	    struct rcdata_item *ri;
    1204. 

  1204. 

  1205. 	    ri = define_rcdata_number ($3.val, $3.dword);
    1206. 

  1206. 	    $$.first = $1.first;
    1207. 

  1207. 	    $1.last-&gt;next = ri;
    1208. 

  1208. 	    $$.last = ri;
    1209. 

  1209. 	  }
    1210. 

  1210. 	;
    1211. 

  1211. 

  1212. /* Stringtable resources.  */
    1213. 

  1213. 

  1214. stringtable:
    1215. 

  1215. 	  STRINGTABLE suboptions BEG 
    1216. 

  1216. 	    { sub_res_info = $2; }
    1217. 

  1217. 	    string_data END
    1218. 

  1218. 	;
    1219. 

  1219. 

  1220. string_data:
    1221. 

  1221. 	  /* empty */
    1222. 

  1222. 	| string_data numexpr QUOTEDSTRING
    1223. 

  1223. 	  {
    1224. 

  1224. 	    define_stringtable (&amp;sub_res_info, $2, $3);
    1225. 

  1225. 	    if (yychar != YYEMPTY)
    1226. 

  1226. 	      YYERROR;
    1227. 

  1227. 	    rcparse_discard_strings ();
    1228. 

  1228. 	  }
    1229. 

  1229. 	| string_data numexpr ',' QUOTEDSTRING
    1230. 

  1230. 	  {
    1231. 

  1231. 	    define_stringtable (&amp;sub_res_info, $2, $4);
    1232. 

  1232. 	    if (yychar != YYEMPTY)
    1233. 

  1233. 	      YYERROR;
    1234. 

  1234. 	    rcparse_discard_strings ();
    1235. 

  1235. 	  }
    1236. 

  1236. 	;
    1237. 

  1237. 

  1238. /* User defined resources.  We accept general suboptions in the
    1239. 

  1239.    file_name case to keep the parser happy.  */
    1240. 

  1240. 

  1241. user:
    1242. 

  1242. 	  id id suboptions BEG optrcdata_data END
    1243. 

  1243. 	  {
    1244. 

  1244. 	    define_user_data ($1, $2, &amp;$3, $5.first);
    1245. 

  1245. 	    if (yychar != YYEMPTY)
    1246. 

  1246. 	      YYERROR;
    1247. 

  1247. 	    rcparse_discard_strings ();
    1248. 

  1248. 	  }
    1249. 

  1249. 	| id id suboptions file_name
    1250. 

  1250. 	  {
    1251. 

  1251. 	    define_user_file ($1, $2, &amp;$3, $4);
    1252. 

  1252. 	    if (yychar != YYEMPTY)
    1253. 

  1253. 	      YYERROR;
    1254. 

  1254. 	    rcparse_discard_strings ();
    1255. 

  1255. 	  }
    1256. 

  1256. 	;
    1257. 

  1257. 

  1258. /* Versioninfo resources.  */
    1259. 

  1259. 

  1260. versioninfo:
    1261. 

  1261. 	  id VERSIONINFO fixedverinfo BEG verblocks END
    1262. 

  1262. 	  {
    1263. 

  1263. 	    define_versioninfo ($1, language, $3, $5);
    1264. 

  1264. 	    if (yychar != YYEMPTY)
    1265. 

  1265. 	      YYERROR;
    1266. 

  1266. 	    rcparse_discard_strings ();
    1267. 

  1267. 	  }
    1268. 

  1268. 	;
    1269. 

  1269. 

  1270. fixedverinfo:
    1271. 

  1271. 	  /* empty */
    1272. 

  1272. 	  {
    1273. 

  1273. 	    $$ = ((struct fixed_versioninfo *)
    1274. 

  1274. 		  res_alloc (sizeof (struct fixed_versioninfo)));
    1275. 

  1275. 	    memset ($$, 0, sizeof (struct fixed_versioninfo));
    1276. 

  1276. 	  }
    1277. 

  1277. 	| fixedverinfo FILEVERSION numexpr cnumexpr cnumexpr cnumexpr
    1278. 

  1278. 	  {
    1279. 

  1279. 	    $1-&gt;file_version_ms = ($3 &lt;&lt; 16) | $4;
    1280. 

  1280. 	    $1-&gt;file_version_ls = ($5 &lt;&lt; 16) | $6;
    1281. 

  1281. 	    $$ = $1;
    1282. 

  1282. 	  }
    1283. 

  1283. 	| fixedverinfo PRODUCTVERSION numexpr cnumexpr cnumexpr cnumexpr
    1284. 

  1284. 	  {
    1285. 

  1285. 	    $1-&gt;product_version_ms = ($3 &lt;&lt; 16) | $4;
    1286. 

  1286. 	    $1-&gt;product_version_ls = ($5 &lt;&lt; 16) | $6;
    1287. 

  1287. 	    $$ = $1;
    1288. 

  1288. 	  }
    1289. 

  1289. 	| fixedverinfo FILEFLAGSMASK numexpr
    1290. 

  1290. 	  {
    1291. 

  1291. 	    $1-&gt;file_flags_mask = $3;
    1292. 

  1292. 	    $$ = $1;
    1293. 

  1293. 	  }
    1294. 

  1294. 	| fixedverinfo FILEFLAGS numexpr
    1295. 

  1295. 	  {
    1296. 

  1296. 	    $1-&gt;file_flags = $3;
    1297. 

  1297. 	    $$ = $1;
    1298. 

  1298. 	  }
    1299. 

  1299. 	| fixedverinfo FILEOS numexpr
    1300. 

  1300. 	  {
    1301. 

  1301. 	    $1-&gt;file_os = $3;
    1302. 

  1302. 	    $$ = $1;
    1303. 

  1303. 	  }
    1304. 

  1304. 	| fixedverinfo FILETYPE numexpr
    1305. 

  1305. 	  {
    1306. 

  1306. 	    $1-&gt;file_type = $3;
    1307. 

  1307. 	    $$ = $1;
    1308. 

  1308. 	  }
    1309. 

  1309. 	| fixedverinfo FILESUBTYPE numexpr
    1310. 

  1310. 	  {
    1311. 

  1311. 	    $1-&gt;file_subtype = $3;
    1312. 

  1312. 	    $$ = $1;
    1313. 

  1313. 	  }
    1314. 

  1314. 	;
    1315. 

  1315. 

  1316. /* To handle verblocks successfully, the lexer handles BLOCK
    1317. 

  1317.    specially.  A BLOCK &quot;StringFileInfo&quot; is returned as
    1318. 

  1318.    BLOCKSTRINGFILEINFO.  A BLOCK &quot;VarFileInfo&quot; is returned as
    1319. 

  1319.    BLOCKVARFILEINFO.  A BLOCK with some other string returns BLOCK
    1320. 

  1320.    with the string as the value.  */
    1321. 

  1321. 

  1322. verblocks:
    1323. 

  1323. 	  /* empty */
    1324. 

  1324. 	  {
    1325. 

  1325. 	    $$ = NULL;
    1326. 

  1326. 	  }
    1327. 

  1327. 	| verblocks BLOCKSTRINGFILEINFO BEG BLOCK BEG vervals END END
    1328. 

  1328. 	  {
    1329. 

  1329. 	    $$ = append_ver_stringfileinfo ($1, $4, $6);
    1330. 

  1330. 	  }
    1331. 

  1331. 	| verblocks BLOCKVARFILEINFO BEG VALUE QUOTEDSTRING vertrans END
    1332. 

  1332. 	  {
    1333. 

  1333. 	    $$ = append_ver_varfileinfo ($1, $5, $6);
    1334. 

  1334. 	  }
    1335. 

  1335. 	;
    1336. 

  1336. 

  1337. vervals:
    1338. 

  1338. 	  /* empty */
    1339. 

  1339. 	  {
    1340. 

  1340. 	    $$ = NULL;
    1341. 

  1341. 	  }
    1342. 

  1342. 	| vervals VALUE QUOTEDSTRING ',' QUOTEDSTRING
    1343. 

  1343. 	  {
    1344. 

  1344. 	    $$ = append_verval ($1, $3, $5);
    1345. 

  1345. 	  }
    1346. 

  1346. 	;
    1347. 

  1347. 

  1348. vertrans:
    1349. 

  1349. 	  /* empty */
    1350. 

  1350. 	  {
    1351. 

  1351. 	    $$ = NULL;
    1352. 

  1352. 	  }
    1353. 

  1353. 	| vertrans cnumexpr cnumexpr
    1354. 

  1354. 	  {
    1355. 

  1355. 	    $$ = append_vertrans ($1, $2, $3);
    1356. 

  1356. 	  }
    1357. 

  1357. 	;
    1358. 

  1358. 

  1359. /* A resource ID.  */
    1360. 

  1360. 

  1361. id:
    1362. 

  1362. 	  posnumexpr
    1363. 

  1363. 	  {
    1364. 

  1364. 	    $$.named = 0;
    1365. 

  1365. 	    $$.u.id = $1;
    1366. 

  1366. 	  }
    1367. 

  1367. 	| STRING
    1368. 

  1368. 	  {
    1369. 

  1369. 	    char *copy, *s;
    1370. 

  1370. 

  1371. 	    /* It seems that resource ID's are forced to upper case.  */
    1372. 

  1372. 	    copy = xstrdup ($1);
    1373. 

  1373. 	    for (s = copy; *s != '\0'; s++)
    1374. 

  1374. 	      *s = TOUPPER (*s);
    1375. 

  1375. 	    res_string_to_id (&amp;$$, copy);
    1376. 

  1376. 	    free (copy);
    1377. 

  1377. 	  }
    1378. 

  1378. 	;
    1379. 

  1379. 

  1380. /* A resource reference.  */
    1381. 

  1381. 

  1382. resname:
    1383. 

  1383. 	  QUOTEDSTRING
    1384. 

  1384. 	  {
    1385. 

  1385. 	    $$ = $1;
    1386. 

  1386. 	  }
    1387. 

  1387. 	| QUOTEDSTRING ','
    1388. 

  1388. 	  {
    1389. 

  1389. 	    $$ = $1;
    1390. 

  1390. 	  }
    1391. 

  1391. 	| STRING ','
    1392. 

  1392. 	  {
    1393. 

  1393. 	    $$ = $1;
    1394. 

  1394. 	  }
    1395. 

  1395. 	;
    1396. 

  1396. 

  1397. 

  1398. resref:
    1399. 

  1399. 	  posnumexpr ','
    1400. 

  1400. 	  {
    1401. 

  1401. 	    $$.named = 0;
    1402. 

  1402. 	    $$.u.id = $1;
    1403. 

  1403. 	  }
    1404. 

  1404. 	| resname
    1405. 

  1405. 	  {
    1406. 

  1406. 	    char *copy, *s;
    1407. 

  1407. 

  1408. 	    /* It seems that resource ID's are forced to upper case.  */
    1409. 

  1409. 	    copy = xstrdup ($1);
    1410. 

  1410. 	    for (s = copy; *s != '\0'; s++)
    1411. 

  1411. 	      *s = TOUPPER (*s);
    1412. 

  1412. 	    res_string_to_id (&amp;$$, copy);
    1413. 

  1413. 	    free (copy);
    1414. 

  1414. 	  }
    1415. 

  1415. 	;
    1416. 

  1416. 

  1417. /* Generic suboptions.  These may appear before the BEGIN in any
    1418. 

  1418.    multiline statement.  */
    1419. 

  1419. 

  1420. suboptions:
    1421. 

  1421. 	  /* empty */
    1422. 

  1422. 	  {
    1423. 

  1423. 	    memset (&amp;$$, 0, sizeof (struct res_res_info));
    1424. 

  1424. 	    $$.language = language;
    1425. 

  1425. 	    /* FIXME: Is this the right default?  */
    1426. 

  1426. 	    $$.memflags = MEMFLAG_MOVEABLE | MEMFLAG_PURE | MEMFLAG_DISCARDABLE;
    1427. 

  1427. 	  }
    1428. 

  1428. 	| suboptions memflag
    1429. 

  1429. 	  {
    1430. 

  1430. 	    $$ = $1;
    1431. 

  1431. 	    $$.memflags |= $2.on;
    1432. 

  1432. 	    $$.memflags &amp;=~ $2.off;
    1433. 

  1433. 	  }
    1434. 

  1434. 	| suboptions CHARACTERISTICS numexpr
    1435. 

  1435. 	  {
    1436. 

  1436. 	    $$ = $1;
    1437. 

  1437. 	    $$.characteristics = $3;
    1438. 

  1438. 	  }
    1439. 

  1439. 	| suboptions LANGUAGE numexpr cnumexpr
    1440. 

  1440. 	  {
    1441. 

  1441. 	    $$ = $1;
    1442. 

  1442. 	    $$.language = $3 | ($4 &lt;&lt; SUBLANG_SHIFT);
    1443. 

  1443. 	  }
    1444. 

  1444. 	| suboptions VERSIONK numexpr
    1445. 

  1445. 	  {
    1446. 

  1446. 	    $$ = $1;
    1447. 

  1447. 	    $$.version = $3;
    1448. 

  1448. 	  }
    1449. 

  1449. 	;
    1450. 

  1450. 

  1451. /* Memory flags which default to MOVEABLE and DISCARDABLE.  */
    1452. 

  1452. 

  1453. memflags_move_discard:
    1454. 

  1454. 	  /* empty */
    1455. 

  1455. 	  {
    1456. 

  1456. 	    memset (&amp;$$, 0, sizeof (struct res_res_info));
    1457. 

  1457. 	    $$.language = language;
    1458. 

  1458. 	    $$.memflags = MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE;
    1459. 

  1459. 	  }
    1460. 

  1460. 	| memflags_move_discard memflag
    1461. 

  1461. 	  {
    1462. 

  1462. 	    $$ = $1;
    1463. 

  1463. 	    $$.memflags |= $2.on;
    1464. 

  1464. 	    $$.memflags &amp;=~ $2.off;
    1465. 

  1465. 	  }
    1466. 

  1466. 	;
    1467. 

  1467. 

  1468. /* Memory flags which default to MOVEABLE.  */
    1469. 

  1469. 

  1470. memflags_move:
    1471. 

  1471. 	  /* empty */
    1472. 

  1472. 	  {
    1473. 

  1473. 	    memset (&amp;$$, 0, sizeof (struct res_res_info));
    1474. 

  1474. 	    $$.language = language;
    1475. 

  1475. 	    $$.memflags = MEMFLAG_MOVEABLE | MEMFLAG_PURE | MEMFLAG_DISCARDABLE;
    1476. 

  1476. 	  }
    1477. 

  1477. 	| memflags_move memflag
    1478. 

  1478. 	  {
    1479. 

  1479. 	    $$ = $1;
    1480. 

  1480. 	    $$.memflags |= $2.on;
    1481. 

  1481. 	    $$.memflags &amp;=~ $2.off;
    1482. 

  1482. 	  }
    1483. 

  1483. 	;
    1484. 

  1484. 

  1485. /* Memory flags.  This returns a struct with two integers, because we
    1486. 

  1486.    sometimes want to set bits and we sometimes want to clear them.  */
    1487. 

  1487. 

  1488. memflag:
    1489. 

  1489. 	  MOVEABLE
    1490. 

  1490. 	  {
    1491. 

  1491. 	    $$.on = MEMFLAG_MOVEABLE;
    1492. 

  1492. 	    $$.off = 0;
    1493. 

  1493. 	  }
    1494. 

  1494. 	| FIXED
    1495. 

  1495. 	  {
    1496. 

  1496. 	    $$.on = 0;
    1497. 

  1497. 	    $$.off = MEMFLAG_MOVEABLE;
    1498. 

  1498. 	  }
    1499. 

  1499. 	| PURE
    1500. 

  1500. 	  {
    1501. 

  1501. 	    $$.on = MEMFLAG_PURE;
    1502. 

  1502. 	    $$.off = 0;
    1503. 

  1503. 	  }
    1504. 

  1504. 	| IMPURE
    1505. 

  1505. 	  {
    1506. 

  1506. 	    $$.on = 0;
    1507. 

  1507. 	    $$.off = MEMFLAG_PURE;
    1508. 

  1508. 	  }
    1509. 

  1509. 	| PRELOAD
    1510. 

  1510. 	  {
    1511. 

  1511. 	    $$.on = MEMFLAG_PRELOAD;
    1512. 

  1512. 	    $$.off = 0;
    1513. 

  1513. 	  }
    1514. 

  1514. 	| LOADONCALL
    1515. 

  1515. 	  {
    1516. 

  1516. 	    $$.on = 0;
    1517. 

  1517. 	    $$.off = MEMFLAG_PRELOAD;
    1518. 

  1518. 	  }
    1519. 

  1519. 	| DISCARDABLE
    1520. 

  1520. 	  {
    1521. 

  1521. 	    $$.on = MEMFLAG_DISCARDABLE;
    1522. 

  1522. 	    $$.off = 0;
    1523. 

  1523. 	  }
    1524. 

  1524. 	;
    1525. 

  1525. 

  1526. /* A file name.  */
    1527. 

  1527. 

  1528. file_name:
    1529. 

  1529. 	  QUOTEDSTRING
    1530. 

  1530. 	  {
    1531. 

  1531. 	    $$ = $1;
    1532. 

  1532. 	  }
    1533. 

  1533. 	| STRING
    1534. 

  1534. 	  {
    1535. 

  1535. 	    $$ = $1;
    1536. 

  1536. 	  }
    1537. 

  1537. 	;
    1538. 

  1538. 

  1539. /* A style expression.  This changes the static variable STYLE.  We do
    1540. 

  1540.    it this way because rc appears to permit a style to be set to
    1541. 

  1541.    something like
    1542. 

  1542.        WS_GROUP | NOT WS_TABSTOP
    1543. 

  1543.    to mean that a default of WS_TABSTOP should be removed.  Anything
    1544. 

  1544.    which wants to accept a style must first set STYLE to the default
    1545. 

  1545.    value.  The styleexpr nonterminal will change STYLE as specified by
    1546. 

  1546.    the user.  Note that we do not accept arbitrary expressions here,
    1547. 

  1547.    just numbers separated by '|'.  */
    1548. 

  1548. 

  1549. styleexpr:
    1550. 

  1550. 	  parennumber
    1551. 

  1551. 	  {
    1552. 

  1552. 	    style |= $1;
    1553. 

  1553. 	  }
    1554. 

  1554. 	| NOT parennumber
    1555. 

  1555. 	  {
    1556. 

  1556. 	    style &amp;=~ $2;
    1557. 

  1557. 	  }
    1558. 

  1558. 	| styleexpr '|' parennumber
    1559. 

  1559. 	  {
    1560. 

  1560. 	    style |= $3;
    1561. 

  1561. 	  }
    1562. 

  1562. 	| styleexpr '|' NOT parennumber
    1563. 

  1563. 	  {
    1564. 

  1564. 	    style &amp;=~ $4;
    1565. 

  1565. 	  }
    1566. 

  1566. 	;
    1567. 

  1567. 

  1568. parennumber:
    1569. 

  1569. 	  NUMBER
    1570. 

  1570. 	  {
    1571. 

  1571. 	    $$ = $1.val;
    1572. 

  1572. 	  }
    1573. 

  1573. 	| '(' numexpr ')'
    1574. 

  1574. 	  {
    1575. 

  1575. 	    $$ = $2;
    1576. 

  1576. 	  }
    1577. 

  1577. 	;
    1578. 

  1578. 

  1579. /* An optional expression with a leading comma.  */
    1580. 

  1580. 

  1581. optcnumexpr:
    1582. 

  1582. 	  /* empty */
    1583. 

  1583. 	  {
    1584. 

  1584. 	    $$ = 0;
    1585. 

  1585. 	  }
    1586. 

  1586. 	| cnumexpr
    1587. 

  1587. 	  {
    1588. 

  1588. 	    $$ = $1;
    1589. 

  1589. 	  }
    1590. 

  1590. 	;
    1591. 

  1591. 

  1592. /* An expression with a leading comma.  */
    1593. 

  1593. 

  1594. cnumexpr:
    1595. 

  1595. 	  ',' numexpr
    1596. 

  1596. 	  {
    1597. 

  1597. 	    $$ = $2;
    1598. 

  1598. 	  }
    1599. 

  1599. 	;
    1600. 

  1600. 

  1601. /* A possibly negated numeric expression.  */
    1602. 

  1602. 

  1603. numexpr:
    1604. 

  1604. 	  sizednumexpr
    1605. 

  1605. 	  {
    1606. 

  1606. 	    $$ = $1.val;
    1607. 

  1607. 	  }
    1608. 

  1608. 	;
    1609. 

  1609. 

  1610. /* A possibly negated expression with a size.  */
    1611. 

  1611. 

  1612. sizednumexpr:
    1613. 

  1613. 	  NUMBER
    1614. 

  1614. 	  {
    1615. 

  1615. 	    $$ = $1;
    1616. 

  1616. 	  }
    1617. 

  1617. 	| '(' sizednumexpr ')'
    1618. 

  1618. 	  {
    1619. 

  1619. 	    $$ = $2;
    1620. 

  1620. 	  }
    1621. 

  1621. 	| '~' sizednumexpr %prec '~'
    1622. 

  1622. 	  {
    1623. 

  1623. 	    $$.val = ~ $2.val;
    1624. 

  1624. 	    $$.dword = $2.dword;
    1625. 

  1625. 	  }
    1626. 

  1626. 	| '-' sizednumexpr %prec NEG
    1627. 

  1627. 	  {
    1628. 

  1628. 	    $$.val = - $2.val;
    1629. 

  1629. 	    $$.dword = $2.dword;
    1630. 

  1630. 	  }
    1631. 

  1631. 	| sizednumexpr '*' sizednumexpr
    1632. 

  1632. 	  {
    1633. 

  1633. 	    $$.val = $1.val * $3.val;
    1634. 

  1634. 	    $$.dword = $1.dword || $3.dword;
    1635. 

  1635. 	  }
    1636. 

  1636. 	| sizednumexpr '/' sizednumexpr
    1637. 

  1637. 	  {
    1638. 

  1638. 	    $$.val = $1.val / $3.val;
    1639. 

  1639. 	    $$.dword = $1.dword || $3.dword;
    1640. 

  1640. 	  }
    1641. 

  1641. 	| sizednumexpr '%' sizednumexpr
    1642. 

  1642. 	  {
    1643. 

  1643. 	    $$.val = $1.val % $3.val;
    1644. 

  1644. 	    $$.dword = $1.dword || $3.dword;
    1645. 

  1645. 	  }
    1646. 

  1646. 	| sizednumexpr '+' sizednumexpr
    1647. 

  1647. 	  {
    1648. 

  1648. 	    $$.val = $1.val + $3.val;
    1649. 

  1649. 	    $$.dword = $1.dword || $3.dword;
    1650. 

  1650. 	  }
    1651. 

  1651. 	| sizednumexpr '-' sizednumexpr
    1652. 

  1652. 	  {
    1653. 

  1653. 	    $$.val = $1.val - $3.val;
    1654. 

  1654. 	    $$.dword = $1.dword || $3.dword;
    1655. 

  1655. 	  }
    1656. 

  1656. 	| sizednumexpr '&amp;' sizednumexpr
    1657. 

  1657. 	  {
    1658. 

  1658. 	    $$.val = $1.val &amp; $3.val;
    1659. 

  1659. 	    $$.dword = $1.dword || $3.dword;
    1660. 

  1660. 	  }
    1661. 

  1661. 	| sizednumexpr '^' sizednumexpr
    1662. 

  1662. 	  {
    1663. 

  1663. 	    $$.val = $1.val ^ $3.val;
    1664. 

  1664. 	    $$.dword = $1.dword || $3.dword;
    1665. 

  1665. 	  }
    1666. 

  1666. 	| sizednumexpr '|' sizednumexpr
    1667. 

  1667. 	  {
    1668. 

  1668. 	    $$.val = $1.val | $3.val;
    1669. 

  1669. 	    $$.dword = $1.dword || $3.dword;
    1670. 

  1670. 	  }
    1671. 

  1671. 	;
    1672. 

  1672. 

  1673. /* An expression with a leading comma which does not use unary
    1674. 

  1674.    negation.  */
    1675. 

  1675. 

  1676. cposnumexpr:
    1677. 

  1677. 	  ',' posnumexpr
    1678. 

  1678. 	  {
    1679. 

  1679. 	    $$ = $2;
    1680. 

  1680. 	  }
    1681. 

  1681. 	;
    1682. 

  1682. 

  1683. /* An expression which does not use unary negation.  */
    1684. 

  1684. 

  1685. posnumexpr:
    1686. 

  1686. 	  sizedposnumexpr
    1687. 

  1687. 	  {
    1688. 

  1688. 	    $$ = $1.val;
    1689. 

  1689. 	  }
    1690. 

  1690. 	;
    1691. 

  1691. 

  1692. /* An expression which does not use unary negation.  We separate unary
    1693. 

  1693.    negation to avoid parsing conflicts when two numeric expressions
    1694. 

  1694.    appear consecutively.  */
    1695. 

  1695. 

  1696. sizedposnumexpr:
    1697. 

  1697. 	  NUMBER
    1698. 

  1698. 	  {
    1699. 

  1699. 	    $$ = $1;
    1700. 

  1700. 	  }
    1701. 

  1701. 	| '(' sizednumexpr ')'
    1702. 

  1702. 	  {
    1703. 

  1703. 	    $$ = $2;
    1704. 

  1704. 	  }
    1705. 

  1705. 	| '~' sizednumexpr %prec '~'
    1706. 

  1706. 	  {
    1707. 

  1707. 	    $$.val = ~ $2.val;
    1708. 

  1708. 	    $$.dword = $2.dword;
    1709. 

  1709. 	  }
    1710. 

  1710. 	| sizedposnumexpr '*' sizednumexpr
    1711. 

  1711. 	  {
    1712. 

  1712. 	    $$.val = $1.val * $3.val;
    1713. 

  1713. 	    $$.dword = $1.dword || $3.dword;
    1714. 

  1714. 	  }
    1715. 

  1715. 	| sizedposnumexpr '/' sizednumexpr
    1716. 

  1716. 	  {
    1717. 

  1717. 	    $$.val = $1.val / $3.val;
    1718. 

  1718. 	    $$.dword = $1.dword || $3.dword;
    1719. 

  1719. 	  }
    1720. 

  1720. 	| sizedposnumexpr '%' sizednumexpr
    1721. 

  1721. 	  {
    1722. 

  1722. 	    $$.val = $1.val % $3.val;
    1723. 

  1723. 	    $$.dword = $1.dword || $3.dword;
    1724. 

  1724. 	  }
    1725. 

  1725. 	| sizedposnumexpr '+' sizednumexpr
    1726. 

  1726. 	  {
    1727. 

  1727. 	    $$.val = $1.val + $3.val;
    1728. 

  1728. 	    $$.dword = $1.dword || $3.dword;
    1729. 

  1729. 	  }
    1730. 

  1730. 	| sizedposnumexpr '-' sizednumexpr
    1731. 

  1731. 	  {
    1732. 

  1732. 	    $$.val = $1.val - $3.val;
    1733. 

  1733. 	    $$.dword = $1.dword || $3.dword;
    1734. 

  1734. 	  }
    1735. 

  1735. 	| sizedposnumexpr '&amp;' sizednumexpr
    1736. 

  1736. 	  {
    1737. 

  1737. 	    $$.val = $1.val &amp; $3.val;
    1738. 

  1738. 	    $$.dword = $1.dword || $3.dword;
    1739. 

  1739. 	  }
    1740. 

  1740. 	| sizedposnumexpr '^' sizednumexpr
    1741. 

  1741. 	  {
    1742. 

  1742. 	    $$.val = $1.val ^ $3.val;
    1743. 

  1743. 	    $$.dword = $1.dword || $3.dword;
    1744. 

  1744. 	  }
    1745. 

  1745. 	| sizedposnumexpr '|' sizednumexpr
    1746. 

  1746. 	  {
    1747. 

  1747. 	    $$.val = $1.val | $3.val;
    1748. 

  1748. 	    $$.dword = $1.dword || $3.dword;
    1749. 

  1749. 	  }
    1750. 

  1750. 	;
    1751. 

  1751. 

  1752. %%
    1753. 

  1753. 

  1754. /* Set the language from the command line.  */
    1755. 

  1755. 

  1756. void
    1757. 

  1757. rcparse_set_language (lang)
    1758. 

  1758.      int lang;
    1759. 

  1759. {
    1760. 

  1760.   language = lang;
    1761. 

  1761. }
    1762. 

  1762. </pre>
    1763. 

  1763. <hr />
    1764. 

  1764. </body></html>
    1765.