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

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

#
Happy | 1793 lines | 1660 code | 133 blank | 0 comment | 0 complexity | 57844cad0a33302469b2de8e76df158a 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, 2003 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. static struct res_id res_text_field;
    78. 

  78. 

  79. /* This is used for COMBOBOX, LISTBOX and EDITTEXT which
    80. 

  80.    do not allow resource 'text' field in control definition. */
    81. 

  81. static const struct res_id res_null_text = { 1, {{0, L&quot;&quot;}}};
    82. 

  82. 

  83. %}
    84. 

  84. 

  85. %union
    86. 

  86. {
    87. 

  87.   struct accelerator acc;
    88. 

  88.   struct accelerator *pacc;
    89. 

  89.   struct dialog_control *dialog_control;
    90. 

  90.   struct menuitem *menuitem;
    91. 

  91.   struct
    92. 

  92.   {
    93. 

  93.     struct rcdata_item *first;
    94. 

  94.     struct rcdata_item *last;
    95. 

  95.   } rcdata;
    96. 

  96.   struct rcdata_item *rcdata_item;
    97. 

  97.   struct stringtable_data *stringtable;
    98. 

  98.   struct fixed_versioninfo *fixver;
    99. 

  99.   struct ver_info *verinfo;
    100. 

  100.   struct ver_stringinfo *verstring;
    101. 

  101.   struct ver_varinfo *vervar;
    102. 

  102.   struct res_id id;
    103. 

  103.   struct res_res_info res_info;
    104. 

  104.   struct
    105. 

  105.   {
    106. 

  106.     unsigned short on;
    107. 

  107.     unsigned short off;
    108. 

  108.   } memflags;
    109. 

  109.   struct
    110. 

  110.   {
    111. 

  111.     unsigned long val;
    112. 

  112.     /* Nonzero if this number was explicitly specified as long.  */
    113. 

  113.     int dword;
    114. 

  114.   } i;
    115. 

  115.   unsigned long il;
    116. 

  116.   unsigned short is;
    117. 

  117.   const char *s;
    118. 

  118.   struct
    119. 

  119.   {
    120. 

  120.     unsigned long length;
    121. 

  121.     const char *s;
    122. 

  122.   } ss;
    123. 

  123. };
    124. 

  124. 

  125. %token BEG END
    126. 

  126. %token ACCELERATORS VIRTKEY ASCII NOINVERT SHIFT CONTROL ALT
    127. 

  127. %token BITMAP
    128. 

  128. %token CURSOR
    129. 

  129. %token DIALOG DIALOGEX EXSTYLE CAPTION CLASS STYLE
    130. 

  130. %token AUTO3STATE AUTOCHECKBOX AUTORADIOBUTTON CHECKBOX COMBOBOX CTEXT
    131. 

  131. %token DEFPUSHBUTTON EDITTEXT GROUPBOX LISTBOX LTEXT PUSHBOX PUSHBUTTON
    132. 

  132. %token RADIOBUTTON RTEXT SCROLLBAR STATE3 USERBUTTON
    133. 

  133. %token BEDIT HEDIT IEDIT
    134. 

  134. %token FONT
    135. 

  135. %token ICON
    136. 

  136. %token LANGUAGE CHARACTERISTICS VERSIONK
    137. 

  137. %token MENU MENUEX MENUITEM SEPARATOR POPUP CHECKED GRAYED HELP INACTIVE
    138. 

  138. %token MENUBARBREAK MENUBREAK
    139. 

  139. %token MESSAGETABLE
    140. 

  140. %token RCDATA
    141. 

  141. %token STRINGTABLE
    142. 

  142. %token VERSIONINFO FILEVERSION PRODUCTVERSION FILEFLAGSMASK FILEFLAGS
    143. 

  143. %token FILEOS FILETYPE FILESUBTYPE BLOCKSTRINGFILEINFO BLOCKVARFILEINFO
    144. 

  144. %token VALUE
    145. 

  145. %token &lt;s&gt; BLOCK
    146. 

  146. %token MOVEABLE FIXED PURE IMPURE PRELOAD LOADONCALL DISCARDABLE
    147. 

  147. %token NOT
    148. 

  148. %token &lt;s&gt; QUOTEDSTRING STRING
    149. 

  149. %token &lt;i&gt; NUMBER
    150. 

  150. %token &lt;ss&gt; SIZEDSTRING
    151. 

  151. %token IGNORED_TOKEN
    152. 

  152. 

  153. %type &lt;pacc&gt; acc_entries
    154. 

  154. %type &lt;acc&gt; acc_entry acc_event
    155. 

  155. %type &lt;dialog_control&gt; control control_params
    156. 

  156. %type &lt;menuitem&gt; menuitems menuitem menuexitems menuexitem
    157. 

  157. %type &lt;rcdata&gt; optrcdata_data optrcdata_data_int rcdata_data
    158. 

  158. %type &lt;rcdata_item&gt; opt_control_data
    159. 

  159. %type &lt;fixver&gt; fixedverinfo
    160. 

  160. %type &lt;verinfo&gt; verblocks
    161. 

  161. %type &lt;verstring&gt; vervals
    162. 

  162. %type &lt;vervar&gt; vertrans
    163. 

  163. %type &lt;res_info&gt; suboptions memflags_move_discard memflags_move
    164. 

  164. %type &lt;memflags&gt; memflag
    165. 

  165. %type &lt;id&gt; id optresidc resref
    166. 

  166. %type &lt;il&gt; exstyle parennumber
    167. 

  167. %type &lt;il&gt; numexpr posnumexpr cnumexpr optcnumexpr cposnumexpr
    168. 

  168. %type &lt;is&gt; acc_options acc_option menuitem_flags menuitem_flag
    169. 

  169. %type &lt;s&gt; file_name resname
    170. 

  170. %type &lt;i&gt; sizednumexpr sizedposnumexpr
    171. 

  171. 

  172. %left '|'
    173. 

  173. %left '^'
    174. 

  174. %left '&amp;'
    175. 

  175. %left '+' '-'
    176. 

  176. %left '*' '/' '%'
    177. 

  177. %right '~' NEG
    178. 

  178. 

  179. %%
    180. 

  180. 

  181. input:
    182. 

  182. 	  /* empty */
    183. 

  183. 	| input accelerator
    184. 

  184. 	| input bitmap
    185. 

  185. 	| input cursor
    186. 

  186. 	| input dialog
    187. 

  187. 	| input font
    188. 

  188. 	| input icon
    189. 

  189. 	| input language
    190. 

  190. 	| input menu
    191. 

  191. 	| input menuex
    192. 

  192. 	| input messagetable
    193. 

  193. 	| input rcdata
    194. 

  194. 	| input stringtable
    195. 

  195. 	| input user
    196. 

  196. 	| input versioninfo
    197. 

  197. 	| input IGNORED_TOKEN
    198. 

  198. 	;
    199. 

  199. 

  200. /* Accelerator resources.  */
    201. 

  201. 

  202. accelerator:
    203. 

  203. 	  id ACCELERATORS suboptions BEG acc_entries END
    204. 

  204. 	  {
    205. 

  205. 	    define_accelerator ($1, &amp;$3, $5);
    206. 

  206. 	    if (yychar != YYEMPTY)
    207. 

  207. 	      YYERROR;
    208. 

  208. 	    rcparse_discard_strings ();
    209. 

  209. 	  }
    210. 

  210. 	;
    211. 

  211. 

  212. acc_entries:
    213. 

  213. 	  /* empty */
    214. 

  214. 	  {
    215. 

  215. 	    $$ = NULL;
    216. 

  216. 	  }
    217. 

  217. 	| acc_entries acc_entry
    218. 

  218. 	  {
    219. 

  219. 	    struct accelerator *a;
    220. 

  220. 

  221. 	    a = (struct accelerator *) res_alloc (sizeof *a);
    222. 

  222. 	    *a = $2;
    223. 

  223. 	    if ($1 == NULL)
    224. 

  224. 	      $$ = a;
    225. 

  225. 	    else
    226. 

  226. 	      {
    227. 

  227. 		struct accelerator **pp;
    228. 

  228. 

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

  230. 		  ;
    231. 

  231. 		*pp = a;
    232. 

  232. 		$$ = $1;
    233. 

  233. 	      }
    234. 

  234. 	  }
    235. 

  235. 	;
    236. 

  236. 

  237. acc_entry:
    238. 

  238. 	  acc_event cposnumexpr
    239. 

  239. 	  {
    240. 

  240. 	    $$ = $1;
    241. 

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

  242. 	  }
    243. 

  243. 	| acc_event cposnumexpr ',' acc_options
    244. 

  244. 	  {
    245. 

  245. 	    $$ = $1;
    246. 

  246. 	    $$.id = $2;
    247. 

  247. 	    $$.flags |= $4;
    248. 

  248. 	    if (($$.flags &amp; ACC_VIRTKEY) == 0
    249. 

  249. 		&amp;&amp; ($$.flags &amp; (ACC_SHIFT | ACC_CONTROL)) != 0)
    250. 

  250. 	      rcparse_warning (_(&quot;inappropriate modifiers for non-VIRTKEY&quot;));
    251. 

  251. 	  }
    252. 

  252. 	;
    253. 

  253. 

  254. acc_event:
    255. 

  255. 	  QUOTEDSTRING
    256. 

  256. 	  {
    257. 

  257. 	    const char *s = $1;
    258. 

  258. 	    char ch;
    259. 

  259. 

  260. 	    $$.next = NULL;
    261. 

  261. 	    $$.id = 0;
    262. 

  262. 	    ch = *s;
    263. 

  263. 	    if (ch != '^')
    264. 

  264. 	      $$.flags = 0;
    265. 

  265. 	    else
    266. 

  266. 	      {
    267. 

  267. 		$$.flags = ACC_CONTROL | ACC_VIRTKEY;
    268. 

  268. 		++s;
    269. 

  269. 		ch = *s;
    270. 

  270. 		ch = TOUPPER (ch);
    271. 

  271. 	      }
    272. 

  272. 	    $$.key = ch;
    273. 

  273. 	    if (s[1] != '\0')
    274. 

  274. 	      rcparse_warning (_(&quot;accelerator should only be one character&quot;));
    275. 

  275. 	  }
    276. 

  276. 	| posnumexpr
    277. 

  277. 	  {
    278. 

  278. 	    $$.next = NULL;
    279. 

  279. 	    $$.flags = 0;
    280. 

  280. 	    $$.id = 0;
    281. 

  281. 	    $$.key = $1;
    282. 

  282. 	  }
    283. 

  283. 	;
    284. 

  284. 

  285. acc_options:
    286. 

  286. 	  acc_option
    287. 

  287. 	  {
    288. 

  288. 	    $$ = $1;
    289. 

  289. 	  }
    290. 

  290. 	| acc_options ',' acc_option
    291. 

  291. 	  {
    292. 

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

  293. 	  }
    294. 

  294. 	/* I've had one report that the comma is optional.  */
    295. 

  295. 	| acc_options acc_option
    296. 

  296. 	  {
    297. 

  297. 	    $$ = $1 | $2;
    298. 

  298. 	  }
    299. 

  299. 	;
    300. 

  300. 

  301. acc_option:
    302. 

  302. 	  VIRTKEY
    303. 

  303. 	  {
    304. 

  304. 	    $$ = ACC_VIRTKEY;
    305. 

  305. 	  }
    306. 

  306. 	| ASCII
    307. 

  307. 	  {
    308. 

  308. 	    /* This is just the absence of VIRTKEY.  */
    309. 

  309. 	    $$ = 0;
    310. 

  310. 	  }
    311. 

  311. 	| NOINVERT
    312. 

  312. 	  {
    313. 

  313. 	    $$ = ACC_NOINVERT;
    314. 

  314. 	  }
    315. 

  315. 	| SHIFT
    316. 

  316. 	  {
    317. 

  317. 	    $$ = ACC_SHIFT;
    318. 

  318. 	  }
    319. 

  319. 	| CONTROL
    320. 

  320. 	  {
    321. 

  321. 	    $$ = ACC_CONTROL;
    322. 

  322. 	  }
    323. 

  323. 	| ALT
    324. 

  324. 	  {
    325. 

  325. 	    $$ = ACC_ALT;
    326. 

  326. 	  }
    327. 

  327. 	;
    328. 

  328. 

  329. /* Bitmap resources.  */
    330. 

  330. 

  331. bitmap:
    332. 

  332. 	  id BITMAP memflags_move file_name
    333. 

  333. 	  {
    334. 

  334. 	    define_bitmap ($1, &amp;$3, $4);
    335. 

  335. 	    if (yychar != YYEMPTY)
    336. 

  336. 	      YYERROR;
    337. 

  337. 	    rcparse_discard_strings ();
    338. 

  338. 	  }
    339. 

  339. 	;
    340. 

  340. 

  341. /* Cursor resources.  */
    342. 

  342. 

  343. cursor:
    344. 

  344. 	  id CURSOR memflags_move_discard file_name
    345. 

  345. 	  {
    346. 

  346. 	    define_cursor ($1, &amp;$3, $4);
    347. 

  347. 	    if (yychar != YYEMPTY)
    348. 

  348. 	      YYERROR;
    349. 

  349. 	    rcparse_discard_strings ();
    350. 

  350. 	  }
    351. 

  351. 	;
    352. 

  352. 

  353. /* Dialog resources.  */
    354. 

  354. 

  355. dialog:
    356. 

  356. 	  id DIALOG memflags_move exstyle posnumexpr cnumexpr cnumexpr
    357. 

  357. 	    cnumexpr
    358. 

  358. 	    {
    359. 

  359. 	      memset (&amp;dialog, 0, sizeof dialog);
    360. 

  360. 	      dialog.x = $5;
    361. 

  361. 	      dialog.y = $6;
    362. 

  362. 	      dialog.width = $7;
    363. 

  363. 	      dialog.height = $8;
    364. 

  364. 	      dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
    365. 

  365. 	      dialog.exstyle = $4;
    366. 

  366. 	      dialog.menu.named = 1;
    367. 

  367. 	      dialog.class.named = 1;
    368. 

  368. 	      dialog.font = NULL;
    369. 

  369. 	      dialog.ex = NULL;
    370. 

  370. 	      dialog.controls = NULL;
    371. 

  371. 	      sub_res_info = $3;
    372. 

  372. 	      style = 0;
    373. 

  373. 	    }
    374. 

  374. 	    styles BEG controls END
    375. 

  375. 	  {
    376. 

  376. 	    define_dialog ($1, &amp;sub_res_info, &amp;dialog);
    377. 

  377. 	    if (yychar != YYEMPTY)
    378. 

  378. 	      YYERROR;
    379. 

  379. 	    rcparse_discard_strings ();
    380. 

  380. 	  }
    381. 

  381. 	| id DIALOGEX memflags_move exstyle posnumexpr cnumexpr cnumexpr
    382. 

  382. 	    cnumexpr
    383. 

  383. 	    {
    384. 

  384. 	      memset (&amp;dialog, 0, sizeof dialog);
    385. 

  385. 	      dialog.x = $5;
    386. 

  386. 	      dialog.y = $6;
    387. 

  387. 	      dialog.width = $7;
    388. 

  388. 	      dialog.height = $8;
    389. 

  389. 	      dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
    390. 

  390. 	      dialog.exstyle = $4;
    391. 

  391. 	      dialog.menu.named = 1;
    392. 

  392. 	      dialog.class.named = 1;
    393. 

  393. 	      dialog.font = NULL;
    394. 

  394. 	      dialog.ex = ((struct dialog_ex *)
    395. 

  395. 			   res_alloc (sizeof (struct dialog_ex)));
    396. 

  396. 	      memset (dialog.ex, 0, sizeof (struct dialog_ex));
    397. 

  397. 	      dialog.controls = NULL;
    398. 

  398. 	      sub_res_info = $3;
    399. 

  399. 	      style = 0;
    400. 

  400. 	    }
    401. 

  401. 	    styles BEG controls END
    402. 

  402. 	  {
    403. 

  403. 	    define_dialog ($1, &amp;sub_res_info, &amp;dialog);
    404. 

  404. 	    if (yychar != YYEMPTY)
    405. 

  405. 	      YYERROR;
    406. 

  406. 	    rcparse_discard_strings ();
    407. 

  407. 	  }
    408. 

  408. 	| id DIALOGEX memflags_move exstyle posnumexpr cnumexpr cnumexpr
    409. 

  409. 	    cnumexpr cnumexpr
    410. 

  410. 	    {
    411. 

  411. 	      memset (&amp;dialog, 0, sizeof dialog);
    412. 

  412. 	      dialog.x = $5;
    413. 

  413. 	      dialog.y = $6;
    414. 

  414. 	      dialog.width = $7;
    415. 

  415. 	      dialog.height = $8;
    416. 

  416. 	      dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
    417. 

  417. 	      dialog.exstyle = $4;
    418. 

  418. 	      dialog.menu.named = 1;
    419. 

  419. 	      dialog.class.named = 1;
    420. 

  420. 	      dialog.font = NULL;
    421. 

  421. 	      dialog.ex = ((struct dialog_ex *)
    422. 

  422. 			   res_alloc (sizeof (struct dialog_ex)));
    423. 

  423. 	      memset (dialog.ex, 0, sizeof (struct dialog_ex));
    424. 

  424. 	      dialog.ex-&gt;help = $9;
    425. 

  425. 	      dialog.controls = NULL;
    426. 

  426. 	      sub_res_info = $3;
    427. 

  427. 	      style = 0;
    428. 

  428. 	    }
    429. 

  429. 	    styles BEG controls END
    430. 

  430. 	  {
    431. 

  431. 	    define_dialog ($1, &amp;sub_res_info, &amp;dialog);
    432. 

  432. 	    if (yychar != YYEMPTY)
    433. 

  433. 	      YYERROR;
    434. 

  434. 	    rcparse_discard_strings ();
    435. 

  435. 	  }
    436. 

  436. 	;
    437. 

  437. 

  438. exstyle:
    439. 

  439. 	  /* empty */
    440. 

  440. 	  {
    441. 

  441. 	    $$ = 0;
    442. 

  442. 	  }
    443. 

  443. 	| EXSTYLE '=' numexpr
    444. 

  444. 	  {
    445. 

  445. 	    $$ = $3;
    446. 

  446. 	  }
    447. 

  447. 	;
    448. 

  448. 

  449. styles:
    450. 

  450. 	  /* empty */
    451. 

  451. 	| styles CAPTION QUOTEDSTRING
    452. 

  452. 	  {
    453. 

  453. 	    dialog.style |= WS_CAPTION;
    454. 

  454. 	    style |= WS_CAPTION;
    455. 

  455. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.caption, $3);
    456. 

  456. 	  }
    457. 

  457. 	| styles CLASS id
    458. 

  458. 	  {
    459. 

  459. 	    dialog.class = $3;
    460. 

  460. 	  }
    461. 

  461. 	| styles STYLE
    462. 

  462. 	    styleexpr
    463. 

  463. 	  {
    464. 

  464. 	    dialog.style = style;
    465. 

  465. 	  }
    466. 

  466. 	| styles EXSTYLE numexpr
    467. 

  467. 	  {
    468. 

  468. 	    dialog.exstyle = $3;
    469. 

  469. 	  }
    470. 

  470. 	| styles CLASS QUOTEDSTRING
    471. 

  471. 	  {
    472. 

  472. 	    res_string_to_id (&amp; dialog.class, $3);
    473. 

  473. 	  }
    474. 

  474. 	| styles FONT numexpr ',' QUOTEDSTRING
    475. 

  475. 	  {
    476. 

  476. 	    dialog.style |= DS_SETFONT;
    477. 

  477. 	    style |= DS_SETFONT;
    478. 

  478. 	    dialog.pointsize = $3;
    479. 

  479. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    480. 

  480. 	    if (dialog.ex != NULL)
    481. 

  481. 	      {
    482. 

  482. 		dialog.ex-&gt;weight = 0;
    483. 

  483. 		dialog.ex-&gt;italic = 0;
    484. 

  484. 		dialog.ex-&gt;charset = 1;
    485. 

  485. 	      }
    486. 

  486. 	  }
    487. 

  487. 	| styles FONT numexpr ',' QUOTEDSTRING cnumexpr
    488. 

  488. 	  {
    489. 

  489. 	    dialog.style |= DS_SETFONT;
    490. 

  490. 	    style |= DS_SETFONT;
    491. 

  491. 	    dialog.pointsize = $3;
    492. 

  492. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    493. 

  493. 	    if (dialog.ex == NULL)
    494. 

  494. 	      rcparse_warning (_(&quot;extended FONT requires DIALOGEX&quot;));
    495. 

  495. 	    else
    496. 

  496. 	      {
    497. 

  497. 		dialog.ex-&gt;weight = $6;
    498. 

  498. 		dialog.ex-&gt;italic = 0;
    499. 

  499. 		dialog.ex-&gt;charset = 1;
    500. 

  500. 	      }
    501. 

  501. 	  }
    502. 

  502. 	| styles FONT numexpr ',' QUOTEDSTRING cnumexpr cnumexpr
    503. 

  503. 	  {
    504. 

  504. 	    dialog.style |= DS_SETFONT;
    505. 

  505. 	    style |= DS_SETFONT;
    506. 

  506. 	    dialog.pointsize = $3;
    507. 

  507. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    508. 

  508. 	    if (dialog.ex == NULL)
    509. 

  509. 	      rcparse_warning (_(&quot;extended FONT requires DIALOGEX&quot;));
    510. 

  510. 	    else
    511. 

  511. 	      {
    512. 

  512. 		dialog.ex-&gt;weight = $6;
    513. 

  513. 		dialog.ex-&gt;italic = $7;
    514. 

  514. 		dialog.ex-&gt;charset = 1;
    515. 

  515. 	      }
    516. 

  516. 	  }
    517. 

  517. 	| styles FONT numexpr ',' QUOTEDSTRING cnumexpr cnumexpr cnumexpr
    518. 

  518. 	  {
    519. 

  519. 	    dialog.style |= DS_SETFONT;
    520. 

  520. 	    style |= DS_SETFONT;
    521. 

  521. 	    dialog.pointsize = $3;
    522. 

  522. 	    unicode_from_ascii ((int *) NULL, &amp;dialog.font, $5);
    523. 

  523. 	    if (dialog.ex == NULL)
    524. 

  524. 	      rcparse_warning (_(&quot;extended FONT requires DIALOGEX&quot;));
    525. 

  525. 	    else
    526. 

  526. 	      {
    527. 

  527. 		dialog.ex-&gt;weight = $6;
    528. 

  528. 		dialog.ex-&gt;italic = $7;
    529. 

  529. 		dialog.ex-&gt;charset = $8;
    530. 

  530. 	      }
    531. 

  531. 	  }
    532. 

  532. 	| styles MENU id
    533. 

  533. 	  {
    534. 

  534. 	    dialog.menu = $3;
    535. 

  535. 	  }
    536. 

  536. 	| styles CHARACTERISTICS numexpr
    537. 

  537. 	  {
    538. 

  538. 	    sub_res_info.characteristics = $3;
    539. 

  539. 	  }
    540. 

  540. 	| styles LANGUAGE numexpr cnumexpr
    541. 

  541. 	  {
    542. 

  542. 	    sub_res_info.language = $3 | ($4 &lt;&lt; SUBLANG_SHIFT);
    543. 

  543. 	  }
    544. 

  544. 	| styles VERSIONK numexpr
    545. 

  545. 	  {
    546. 

  546. 	    sub_res_info.version = $3;
    547. 

  547. 	  }
    548. 

  548. 	;
    549. 

  549. 

  550. controls:
    551. 

  551. 	  /* empty */
    552. 

  552. 	| controls control
    553. 

  553. 	  {
    554. 

  554. 	    struct dialog_control **pp;
    555. 

  555. 

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

  557. 	      ;
    558. 

  558. 	    *pp = $2;
    559. 

  559. 	  }
    560. 

  560. 	;
    561. 

  561. 

  562. control:
    563. 

  563. 	  AUTO3STATE optresidc
    564. 

  564. 	    {
    565. 

  565. 	      default_style = BS_AUTO3STATE | WS_TABSTOP;
    566. 

  566. 	      base_style = BS_AUTO3STATE;
    567. 

  567. 	      class = CTL_BUTTON;
    568. 

  568. 	      res_text_field = $2;	
    569. 

  569. 	    }
    570. 

  570. 	    control_params
    571. 

  571. 	  {
    572. 

  572. 	    $$ = $4;
    573. 

  573. 	  }
    574. 

  574. 	| AUTOCHECKBOX optresidc
    575. 

  575. 	    {
    576. 

  576. 	      default_style = BS_AUTOCHECKBOX | WS_TABSTOP;
    577. 

  577. 	      base_style = BS_AUTOCHECKBOX;
    578. 

  578. 	      class = CTL_BUTTON;
    579. 

  579. 	      res_text_field = $2;	
    580. 

  580. 	    }
    581. 

  581. 	    control_params
    582. 

  582. 	  {
    583. 

  583. 	    $$ = $4;
    584. 

  584. 	  }
    585. 

  585. 	| AUTORADIOBUTTON optresidc
    586. 

  586. 	    {
    587. 

  587. 	      default_style = BS_AUTORADIOBUTTON | WS_TABSTOP;
    588. 

  588. 	      base_style = BS_AUTORADIOBUTTON;
    589. 

  589. 	      class = CTL_BUTTON;
    590. 

  590. 	      res_text_field = $2;	
    591. 

  591. 	    }
    592. 

  592. 	    control_params
    593. 

  593. 	  {
    594. 

  594. 	    $$ = $4;
    595. 

  595. 	  }
    596. 

  596. 	| BEDIT optresidc
    597. 

  597. 	    {
    598. 

  598. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    599. 

  599. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    600. 

  600. 	      class = CTL_EDIT;
    601. 

  601. 	      res_text_field = $2;	
    602. 

  602. 	    }
    603. 

  603. 	    control_params
    604. 

  604. 	  {
    605. 

  605. 	    $$ = $4;
    606. 

  606. 	    if (dialog.ex == NULL)
    607. 

  607. 	      rcparse_warning (_(&quot;BEDIT requires DIALOGEX&quot;));
    608. 

  608. 	    res_string_to_id (&amp;$$-&gt;class, &quot;BEDIT&quot;);
    609. 

  609. 	  }
    610. 

  610. 	| CHECKBOX optresidc
    611. 

  611. 	    {
    612. 

  612. 	      default_style = BS_CHECKBOX | WS_TABSTOP;
    613. 

  613. 	      base_style = BS_CHECKBOX | WS_TABSTOP;
    614. 

  614. 	      class = CTL_BUTTON;
    615. 

  615. 	      res_text_field = $2;	
    616. 

  616. 	    }
    617. 

  617. 	    control_params
    618. 

  618. 	  {
    619. 

  619. 	    $$ = $4;
    620. 

  620. 	  }
    621. 

  621. 	| COMBOBOX
    622. 

  622. 	    {
    623. 

  623. 	      /* This is as per MSDN documentation.  With some (???)
    624. 

  624. 		 versions of MS rc.exe their is no default style.  */
    625. 

  625. 	      default_style = CBS_SIMPLE | WS_TABSTOP;
    626. 

  626. 	      base_style = 0;
    627. 

  627. 	      class = CTL_COMBOBOX;
    628. 

  628. 	      res_text_field = res_null_text;	
    629. 

  629. 	    }
    630. 

  630. 	    control_params
    631. 

  631. 	  {
    632. 

  632. 	    $$ = $3;
    633. 

  633. 	  }
    634. 

  634. 	| CONTROL optresidc numexpr cnumexpr control_styleexpr cnumexpr
    635. 

  635. 	    cnumexpr cnumexpr cnumexpr optcnumexpr opt_control_data
    636. 

  636. 	  {
    637. 

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

  638. 	    if ($11 != NULL)
    639. 

  639. 	      {
    640. 

  640. 		if (dialog.ex == NULL)
    641. 

  641. 		  rcparse_warning (_(&quot;control data requires DIALOGEX&quot;));
    642. 

  642. 		$$-&gt;data = $11;
    643. 

  643. 	      }
    644. 

  644. 	  }
    645. 

  645. 	| CONTROL optresidc numexpr cnumexpr control_styleexpr cnumexpr
    646. 

  646. 	    cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr opt_control_data
    647. 

  647. 	  {
    648. 

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

  649. 	    if (dialog.ex == NULL)
    650. 

  650. 	      rcparse_warning (_(&quot;help ID requires DIALOGEX&quot;));
    651. 

  651. 	    $$-&gt;help = $11;
    652. 

  652. 	    $$-&gt;data = $12;
    653. 

  653. 	  }
    654. 

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

  655. 	    cnumexpr cnumexpr cnumexpr cnumexpr optcnumexpr opt_control_data
    656. 

  656. 	  {
    657. 

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

  658. 	    if ($12 != NULL)
    659. 

  659. 	      {
    660. 

  660. 		if (dialog.ex == NULL)
    661. 

  661. 		  rcparse_warning (&quot;control data requires DIALOGEX&quot;);
    662. 

  662. 		$$-&gt;data = $12;
    663. 

  663. 	      }
    664. 

  664. 	    $$-&gt;class.named = 1;
    665. 

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

  666. 	  }
    667. 

  667. 	| CONTROL optresidc numexpr ',' QUOTEDSTRING control_styleexpr
    668. 

  668. 	    cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr opt_control_data
    669. 

  669. 	  {
    670. 

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

  671. 	    if (dialog.ex == NULL)
    672. 

  672. 	      rcparse_warning (&quot;help ID requires DIALOGEX&quot;);
    673. 

  673. 	    $$-&gt;help = $12;
    674. 

  674. 	    $$-&gt;data = $13;
    675. 

  675. 	    $$-&gt;class.named = 1;
    676. 

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

  677. 	  }
    678. 

  678. 	| CTEXT optresidc
    679. 

  679. 	    {
    680. 

  680. 	      default_style = SS_CENTER | WS_GROUP;
    681. 

  681. 	      base_style = SS_CENTER;
    682. 

  682. 	      class = CTL_STATIC;
    683. 

  683. 	      res_text_field = $2;	
    684. 

  684. 	    }
    685. 

  685. 	    control_params
    686. 

  686. 	  {
    687. 

  687. 	    $$ = $4;
    688. 

  688. 	  }
    689. 

  689. 	| DEFPUSHBUTTON optresidc
    690. 

  690. 	    {
    691. 

  691. 	      default_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
    692. 

  692. 	      base_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
    693. 

  693. 	      class = CTL_BUTTON;
    694. 

  694. 	      res_text_field = $2;	
    695. 

  695. 	    }
    696. 

  696. 	    control_params
    697. 

  697. 	  {
    698. 

  698. 	    $$ = $4;
    699. 

  699. 	  }
    700. 

  700. 	| EDITTEXT
    701. 

  701. 	    {
    702. 

  702. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    703. 

  703. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    704. 

  704. 	      class = CTL_EDIT;
    705. 

  705. 	      res_text_field = res_null_text;	
    706. 

  706. 	    }
    707. 

  707. 	    control_params
    708. 

  708. 	  {
    709. 

  709. 	    $$ = $3;
    710. 

  710. 	  }
    711. 

  711. 	| GROUPBOX optresidc
    712. 

  712. 	    {
    713. 

  713. 	      default_style = BS_GROUPBOX;
    714. 

  714. 	      base_style = BS_GROUPBOX;
    715. 

  715. 	      class = CTL_BUTTON;
    716. 

  716. 	      res_text_field = $2;	
    717. 

  717. 	    }
    718. 

  718. 	    control_params
    719. 

  719. 	  {
    720. 

  720. 	    $$ = $4;
    721. 

  721. 	  }
    722. 

  722. 	| HEDIT optresidc
    723. 

  723. 	    {
    724. 

  724. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    725. 

  725. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    726. 

  726. 	      class = CTL_EDIT;
    727. 

  727. 	      res_text_field = $2;	
    728. 

  728. 	    }
    729. 

  729. 	    control_params
    730. 

  730. 	  {
    731. 

  731. 	    $$ = $4;
    732. 

  732. 	    if (dialog.ex == NULL)
    733. 

  733. 	      rcparse_warning (_(&quot;IEDIT requires DIALOGEX&quot;));
    734. 

  734. 	    res_string_to_id (&amp;$$-&gt;class, &quot;HEDIT&quot;);
    735. 

  735. 	  }
    736. 

  736. 	| ICON resref numexpr cnumexpr cnumexpr opt_control_data
    737. 

  737.           {
    738. 

  738. 	    $$ = define_icon_control ($2, $3, $4, $5, 0, 0, 0, $6,
    739. 

  739. 				      dialog.ex);
    740. 

  740.           }
    741. 

  741. 	| ICON resref numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    742. 

  742. 	    opt_control_data
    743. 

  743.           {
    744. 

  744. 	    $$ = define_icon_control ($2, $3, $4, $5, 0, 0, 0, $8,
    745. 

  745. 				      dialog.ex);
    746. 

  746.           }
    747. 

  747. 	| ICON resref numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    748. 

  748. 	    icon_styleexpr optcnumexpr opt_control_data
    749. 

  749.           {
    750. 

  750. 	    $$ = define_icon_control ($2, $3, $4, $5, style, $9, 0, $10,
    751. 

  751. 				      dialog.ex);
    752. 

  752.           }
    753. 

  753. 	| ICON resref numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    754. 

  754. 	    icon_styleexpr cnumexpr cnumexpr opt_control_data
    755. 

  755.           {
    756. 

  756. 	    $$ = define_icon_control ($2, $3, $4, $5, style, $9, $10, $11,
    757. 

  757. 				      dialog.ex);
    758. 

  758.           }
    759. 

  759. 	| IEDIT optresidc
    760. 

  760. 	    {
    761. 

  761. 	      default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    762. 

  762. 	      base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
    763. 

  763. 	      class = CTL_EDIT;
    764. 

  764. 	      res_text_field = $2;	
    765. 

  765. 	    }
    766. 

  766. 	    control_params
    767. 

  767. 	  {
    768. 

  768. 	    $$ = $4;
    769. 

  769. 	    if (dialog.ex == NULL)
    770. 

  770. 	      rcparse_warning (_(&quot;IEDIT requires DIALOGEX&quot;));
    771. 

  771. 	    res_string_to_id (&amp;$$-&gt;class, &quot;IEDIT&quot;);
    772. 

  772. 	  }
    773. 

  773. 	| LISTBOX
    774. 

  774. 	    {
    775. 

  775. 	      default_style = LBS_NOTIFY | WS_BORDER;
    776. 

  776. 	      base_style = LBS_NOTIFY | WS_BORDER;
    777. 

  777. 	      class = CTL_LISTBOX;
    778. 

  778. 	      res_text_field = res_null_text;	
    779. 

  779. 	    }
    780. 

  780. 	    control_params
    781. 

  781. 	  {
    782. 

  782. 	    $$ = $3;
    783. 

  783. 	  }
    784. 

  784. 	| LTEXT optresidc
    785. 

  785. 	    {
    786. 

  786. 	      default_style = SS_LEFT | WS_GROUP;
    787. 

  787. 	      base_style = SS_LEFT;
    788. 

  788. 	      class = CTL_STATIC;
    789. 

  789. 	      res_text_field = $2;	
    790. 

  790. 	    }
    791. 

  791. 	    control_params
    792. 

  792. 	  {
    793. 

  793. 	    $$ = $4;
    794. 

  794. 	  }
    795. 

  795. 	| PUSHBOX optresidc
    796. 

  796. 	    {
    797. 

  797. 	      default_style = BS_PUSHBOX | WS_TABSTOP;
    798. 

  798. 	      base_style = BS_PUSHBOX;
    799. 

  799. 	      class = CTL_BUTTON;
    800. 

  800. 	    }
    801. 

  801. 	    control_params
    802. 

  802. 	  {
    803. 

  803. 	    $$ = $4;
    804. 

  804. 	  }
    805. 

  805. 	| PUSHBUTTON optresidc
    806. 

  806. 	    {
    807. 

  807. 	      default_style = BS_PUSHBUTTON | WS_TABSTOP;
    808. 

  808. 	      base_style = BS_PUSHBUTTON | WS_TABSTOP;
    809. 

  809. 	      class = CTL_BUTTON;
    810. 

  810. 	      res_text_field = $2;	
    811. 

  811. 	    }
    812. 

  812. 	    control_params
    813. 

  813. 	  {
    814. 

  814. 	    $$ = $4;
    815. 

  815. 	  }
    816. 

  816. 	| RADIOBUTTON optresidc
    817. 

  817. 	    {
    818. 

  818. 	      default_style = BS_RADIOBUTTON | WS_TABSTOP;
    819. 

  819. 	      base_style = BS_RADIOBUTTON;
    820. 

  820. 	      class = CTL_BUTTON;
    821. 

  821. 	      res_text_field = $2;	
    822. 

  822. 	    }
    823. 

  823. 	    control_params
    824. 

  824. 	  {
    825. 

  825. 	    $$ = $4;
    826. 

  826. 	  }
    827. 

  827. 	| RTEXT optresidc
    828. 

  828. 	    {
    829. 

  829. 	      default_style = SS_RIGHT | WS_GROUP;
    830. 

  830. 	      base_style = SS_RIGHT;
    831. 

  831. 	      class = CTL_STATIC;
    832. 

  832. 	      res_text_field = $2;	
    833. 

  833. 	    }
    834. 

  834. 	    control_params
    835. 

  835. 	  {
    836. 

  836. 	    $$ = $4;
    837. 

  837. 	  }
    838. 

  838. 	| SCROLLBAR
    839. 

  839. 	    {
    840. 

  840. 	      default_style = SBS_HORZ;
    841. 

  841. 	      base_style = 0;
    842. 

  842. 	      class = CTL_SCROLLBAR;
    843. 

  843. 	      res_text_field = res_null_text;	
    844. 

  844. 	    }
    845. 

  845. 	    control_params
    846. 

  846. 	  {
    847. 

  847. 	    $$ = $3;
    848. 

  848. 	  }
    849. 

  849. 	| STATE3 optresidc
    850. 

  850. 	    {
    851. 

  851. 	      default_style = BS_3STATE | WS_TABSTOP;
    852. 

  852. 	      base_style = BS_3STATE;
    853. 

  853. 	      class = CTL_BUTTON;
    854. 

  854. 	      res_text_field = $2;	
    855. 

  855. 	    }
    856. 

  856. 	    control_params
    857. 

  857. 	  {
    858. 

  858. 	    $$ = $4;
    859. 

  859. 	  }
    860. 

  860. 	| USERBUTTON resref numexpr ',' numexpr ',' numexpr ','
    861. 

  861. 	    numexpr ',' numexpr ',' 
    862. 

  862. 	    { style = WS_CHILD | WS_VISIBLE; }
    863. 

  863. 	    styleexpr optcnumexpr
    864. 

  864. 	  {
    865. 

  865. 	    $$ = define_control ($2, $3, $5, $7, $9, $11, CTL_BUTTON,
    866. 

  866. 				 style, $15);
    867. 

  867. 	  }
    868. 

  868. 	;
    869. 

  869. 

  870. /* Parameters for a control.  The static variables DEFAULT_STYLE,
    871. 

  871.    BASE_STYLE, and CLASS must be initialized before this nonterminal
    872. 

  872.    is used.  DEFAULT_STYLE is the style to use if no style expression
    873. 

  873.    is specified.  BASE_STYLE is the base style to use if a style
    874. 

  874.    expression is specified; the style expression modifies the base
    875. 

  875.    style.  CLASS is the class of the control.  */
    876. 

  876. 

  877. control_params:
    878. 

  878. 	  numexpr cnumexpr cnumexpr cnumexpr cnumexpr opt_control_data
    879. 

  879. 	  {
    880. 

  880. 	    $$ = define_control (res_text_field, $1, $2, $3, $4, $5, class,
    881. 

  881. 				 default_style | WS_CHILD | WS_VISIBLE, 0);
    882. 

  882. 	    if ($6 != NULL)
    883. 

  883. 	      {
    884. 

  884. 		if (dialog.ex == NULL)
    885. 

  885. 		  rcparse_warning (_(&quot;control data requires DIALOGEX&quot;));
    886. 

  886. 		$$-&gt;data = $6;
    887. 

  887. 	      }
    888. 

  888. 	  }
    889. 

  889. 	| numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    890. 

  890. 	    control_params_styleexpr optcnumexpr opt_control_data
    891. 

  891. 	  {
    892. 

  892. 	    $$ = define_control (res_text_field, $1, $2, $3, $4, $5, class, style, $7);
    893. 

  893. 	    if ($8 != NULL)
    894. 

  894. 	      {
    895. 

  895. 		if (dialog.ex == NULL)
    896. 

  896. 		  rcparse_warning (_(&quot;control data requires DIALOGEX&quot;));
    897. 

  897. 		$$-&gt;data = $8;
    898. 

  898. 	      }
    899. 

  899. 	  }
    900. 

  900. 	| numexpr cnumexpr cnumexpr cnumexpr cnumexpr
    901. 

  901. 	    control_params_styleexpr cnumexpr cnumexpr opt_control_data
    902. 

  902. 	  {
    903. 

  903. 	    $$ = define_control (res_text_field, $1, $2, $3, $4, $5, class, style, $7);
    904. 

  904. 	    if (dialog.ex == NULL)
    905. 

  905. 	      rcparse_warning (_(&quot;help ID requires DIALOGEX&quot;));
    906. 

  906. 	    $$-&gt;help = $8;
    907. 

  907. 	    $$-&gt;data = $9;
    908. 

  908. 	  }
    909. 

  909. 	;
    910. 

  910. 

  911. optresidc:
    912. 

  912. 	  /* empty */
    913. 

  913. 	  {
    914. 

  914. 	    res_string_to_id (&amp;$$, &quot;&quot;);
    915. 

  915. 	  }
    916. 

  916. 	| posnumexpr ','
    917. 

  917. 	  {
    918. 

  918. 	    $$.named = 0;
    919. 

  919. 	    $$.u.id = $1;
    920. 

  920. 	  }
    921. 

  921. 	| QUOTEDSTRING
    922. 

  922. 	  {
    923. 

  923. 	    res_string_to_id (&amp;$$, $1);
    924. 

  924. 	  }
    925. 

  925. 	| QUOTEDSTRING ','
    926. 

  926. 	  {
    927. 

  927. 	    res_string_to_id (&amp;$$, $1);
    928. 

  928. 	  }
    929. 

  929. 	;
    930. 

  930. 

  931. opt_control_data:
    932. 

  932. 	  /* empty */
    933. 

  933. 	  {
    934. 

  934. 	    $$ = NULL;
    935. 

  935. 	  }
    936. 

  936. 	| BEG optrcdata_data END
    937. 

  937. 	  {
    938. 

  938. 	    $$ = $2.first;
    939. 

  939. 	  }
    940. 

  940. 	;
    941. 

  941. 

  942. /* These only exist to parse a reduction out of a common case.  */
    943. 

  943. 

  944. control_styleexpr:
    945. 

  945. 	  ','
    946. 

  946. 	  { style = WS_CHILD | WS_VISIBLE; }
    947. 

  947. 	  styleexpr
    948. 

  948. 	;
    949. 

  949. 

  950. icon_styleexpr:
    951. 

  951. 	  ','
    952. 

  952. 	  { style = SS_ICON | WS_CHILD | WS_VISIBLE; }
    953. 

  953. 	  styleexpr
    954. 

  954. 	;
    955. 

  955. 

  956. control_params_styleexpr:
    957. 

  957. 	  ','
    958. 

  958. 	  { style = base_style | WS_CHILD | WS_VISIBLE; }
    959. 

  959. 	  styleexpr
    960. 

  960. 	;
    961. 

  961. 

  962. /* Font resources.  */
    963. 

  963. 

  964. font:
    965. 

  965. 	  id FONT memflags_move_discard file_name
    966. 

  966. 	  {
    967. 

  967. 	    define_font ($1, &amp;$3, $4);
    968. 

  968. 	    if (yychar != YYEMPTY)
    969. 

  969. 	      YYERROR;
    970. 

  970. 	    rcparse_discard_strings ();
    971. 

  971. 	  }
    972. 

  972. 	;
    973. 

  973. 

  974. /* Icon resources.  */
    975. 

  975. 

  976. icon:
    977. 

  977. 	  id ICON memflags_move_discard file_name
    978. 

  978. 	  {
    979. 

  979. 	    define_icon ($1, &amp;$3, $4);
    980. 

  980. 	    if (yychar != YYEMPTY)
    981. 

  981. 	      YYERROR;
    982. 

  982. 	    rcparse_discard_strings ();
    983. 

  983. 	  }
    984. 

  984. 	;
    985. 

  985. 

  986. /* Language command.  This changes the static variable language, which
    987. 

  987.    affects all subsequent resources.  */
    988. 

  988. 

  989. language:
    990. 

  990. 	  LANGUAGE numexpr cnumexpr
    991. 

  991. 	  {
    992. 

  992. 	    language = $2 | ($3 &lt;&lt; SUBLANG_SHIFT);
    993. 

  993. 	  }
    994. 

  994. 	;
    995. 

  995. 

  996. /* Menu resources.  */
    997. 

  997. 

  998. menu:
    999. 

  999. 	  id MENU suboptions BEG menuitems END
    1000. 

  1000. 	  {
    1001. 

  1001. 	    define_menu ($1, &amp;$3, $5);
    1002. 

  1002. 	    if (yychar != YYEMPTY)
    1003. 

  1003. 	      YYERROR;
    1004. 

  1004. 	    rcparse_discard_strings ();
    1005. 

  1005. 	  }
    1006. 

  1006. 	;
    1007. 

  1007. 

  1008. menuitems:
    1009. 

  1009. 	  /* empty */
    1010. 

  1010. 	  {
    1011. 

  1011. 	    $$ = NULL;
    1012. 

  1012. 	  }
    1013. 

  1013. 	| menuitems menuitem
    1014. 

  1014. 	  {
    1015. 

  1015. 	    if ($1 == NULL)
    1016. 

  1016. 	      $$ = $2;
    1017. 

  1017. 	    else
    1018. 

  1018. 	      {
    1019. 

  1019. 		struct menuitem **pp;
    1020. 

  1020. 

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

  1022. 		  ;
    1023. 

  1023. 		*pp = $2;
    1024. 

  1024. 		$$ = $1;
    1025. 

  1025. 	      }
    1026. 

  1026. 	  }
    1027. 

  1027. 	;
    1028. 

  1028. 

  1029. menuitem:
    1030. 

  1030. 	  MENUITEM QUOTEDSTRING cnumexpr menuitem_flags
    1031. 

  1031. 	  {
    1032. 

  1032. 	    $$ = define_menuitem ($2, $3, $4, 0, 0, NULL);
    1033. 

  1033. 	  }
    1034. 

  1034. 	| MENUITEM SEPARATOR
    1035. 

  1035. 	  {
    1036. 

  1036. 	    $$ = define_menuitem (NULL, 0, 0, 0, 0, NULL);
    1037. 

  1037. 	  }
    1038. 

  1038. 	| POPUP QUOTEDSTRING menuitem_flags BEG menuitems END
    1039. 

  1039. 	  {
    1040. 

  1040. 	    $$ = define_menuitem ($2, 0, $3, 0, 0, $5);
    1041. 

  1041. 	  }
    1042. 

  1042. 	;
    1043. 

  1043. 

  1044. menuitem_flags:
    1045. 

  1045. 	  /* empty */
    1046. 

  1046. 	  {
    1047. 

  1047. 	    $$ = 0;
    1048. 

  1048. 	  }
    1049. 

  1049. 	| menuitem_flags ',' menuitem_flag
    1050. 

  1050. 	  {
    1051. 

  1051. 	    $$ = $1 | $3;
    1052. 

  1052. 	  }
    1053. 

  1053. 	| menuitem_flags menuitem_flag
    1054. 

  1054. 	  {
    1055. 

  1055. 	    $$ = $1 | $2;
    1056. 

  1056. 	  }
    1057. 

  1057. 	;
    1058. 

  1058. 

  1059. menuitem_flag:
    1060. 

  1060. 	  CHECKED
    1061. 

  1061. 	  {
    1062. 

  1062. 	    $$ = MENUITEM_CHECKED;
    1063. 

  1063. 	  }
    1064. 

  1064. 	| GRAYED
    1065. 

  1065. 	  {
    1066. 

  1066. 	    $$ = MENUITEM_GRAYED;
    1067. 

  1067. 	  }
    1068. 

  1068. 	| HELP
    1069. 

  1069. 	  {
    1070. 

  1070. 	    $$ = MENUITEM_HELP;
    1071. 

  1071. 	  }
    1072. 

  1072. 	| INACTIVE
    1073. 

  1073. 	  {
    1074. 

  1074. 	    $$ = MENUITEM_INACTIVE;
    1075. 

  1075. 	  }
    1076. 

  1076. 	| MENUBARBREAK
    1077. 

  1077. 	  {
    1078. 

  1078. 	    $$ = MENUITEM_MENUBARBREAK;
    1079. 

  1079. 	  }
    1080. 

  1080. 	| MENUBREAK
    1081. 

  1081. 	  {
    1082. 

  1082. 	    $$ = MENUITEM_MENUBREAK;
    1083. 

  1083. 	  }
    1084. 

  1084. 	;
    1085. 

  1085. 

  1086. /* Menuex resources.  */
    1087. 

  1087. 

  1088. menuex:
    1089. 

  1089. 	  id MENUEX suboptions BEG menuexitems END
    1090. 

  1090. 	  {
    1091. 

  1091. 	    define_menu ($1, &amp;$3, $5);
    1092. 

  1092. 	    if (yychar != YYEMPTY)
    1093. 

  1093. 	      YYERROR;
    1094. 

  1094. 	    rcparse_discard_strings ();
    1095. 

  1095. 	  }
    1096. 

  1096. 	;
    1097. 

  1097. 

  1098. menuexitems:
    1099. 

  1099. 	  /* empty */
    1100. 

  1100. 	  {
    1101. 

  1101. 	    $$ = NULL;
    1102. 

  1102. 	  }
    1103. 

  1103. 	| menuexitems menuexitem
    1104. 

  1104. 	  {
    1105. 

  1105. 	    if ($1 == NULL)
    1106. 

  1106. 	      $$ = $2;
    1107. 

  1107. 	    else
    1108. 

  1108. 	      {
    1109. 

  1109. 		struct menuitem **pp;
    1110. 

  1110. 

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

  1112. 		  ;
    1113. 

  1113. 		*pp = $2;
    1114. 

  1114. 		$$ = $1;
    1115. 

  1115. 	      }
    1116. 

  1116. 	  }
    1117. 

  1117. 	;
    1118. 

  1118. 

  1119. menuexitem:
    1120. 

  1120. 	  MENUITEM QUOTEDSTRING
    1121. 

  1121. 	  {
    1122. 

  1122. 	    $$ = define_menuitem ($2, 0, 0, 0, 0, NULL);
    1123. 

  1123. 	  }
    1124. 

  1124. 	| MENUITEM QUOTEDSTRING cnumexpr
    1125. 

  1125. 	  {
    1126. 

  1126. 	    $$ = define_menuitem ($2, $3, 0, 0, 0, NULL);
    1127. 

  1127. 	  }
    1128. 

  1128. 	| MENUITEM QUOTEDSTRING cnumexpr cnumexpr optcnumexpr
    1129. 

  1129. 	  {
    1130. 

  1130. 	    $$ = define_menuitem ($2, $3, $4, $5, 0, NULL);
    1131. 

  1131. 	  }
    1132. 

  1132.  	| MENUITEM SEPARATOR
    1133. 

  1133.  	  {
    1134. 

  1134.  	    $$ = define_menuitem (NULL, 0, 0, 0, 0, NULL);
    1135. 

  1135.  	  }
    1136. 

  1136. 	| POPUP QUOTEDSTRING BEG menuexitems END
    1137. 

  1137. 	  {
    1138. 

  1138. 	    $$ = define_menuitem ($2, 0, 0, 0, 0, $4);
    1139. 

  1139. 	  }
    1140. 

  1140. 	| POPUP QUOTEDSTRING cnumexpr BEG menuexitems END
    1141. 

  1141. 	  {
    1142. 

  1142. 	    $$ = define_menuitem ($2, $3, 0, 0, 0, $5);
    1143. 

  1143. 	  }
    1144. 

  1144. 	| POPUP QUOTEDSTRING cnumexpr cnumexpr BEG menuexitems END
    1145. 

  1145. 	  {
    1146. 

  1146. 	    $$ = define_menuitem ($2, $3, $4, 0, 0, $6);
    1147. 

  1147. 	  }
    1148. 

  1148. 	| POPUP QUOTEDSTRING cnumexpr cnumexpr cnumexpr optcnumexpr
    1149. 

  1149. 	    BEG menuexitems END
    1150. 

  1150. 	  {
    1151. 

  1151. 	    $$ = define_menuitem ($2, $3, $4, $5, $6, $8);
    1152. 

  1152. 	  }
    1153. 

  1153. 	;
    1154. 

  1154. 

  1155. /* Messagetable resources.  */
    1156. 

  1156. 

  1157. messagetable:
    1158. 

  1158. 	  id MESSAGETABLE memflags_move file_name
    1159. 

  1159. 	  {
    1160. 

  1160. 	    define_messagetable ($1, &amp;$3, $4);
    1161. 

  1161. 	    if (yychar != YYEMPTY)
    1162. 

  1162. 	      YYERROR;
    1163. 

  1163. 	    rcparse_discard_strings ();
    1164. 

  1164. 	  }
    1165. 

  1165. 	;
    1166. 

  1166. 

  1167. /* Rcdata resources.  */
    1168. 

  1168. 

  1169. rcdata:
    1170. 

  1170. 	  id RCDATA suboptions BEG optrcdata_data END
    1171. 

  1171. 	  {
    1172. 

  1172. 	    define_rcdata ($1, &amp;$3, $5.first);
    1173. 

  1173. 	    if (yychar != YYEMPTY)
    1174. 

  1174. 	      YYERROR;
    1175. 

  1175. 	    rcparse_discard_strings ();
    1176. 

  1176. 	  }
    1177. 

  1177. 	;
    1178. 

  1178. 

  1179. /* We use a different lexing algorithm, because rcdata strings may
    1180. 

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

  1181. 

  1182. optrcdata_data:
    1183. 

  1183. 	  {
    1184. 

  1184. 	    rcparse_rcdata ();
    1185. 

  1185. 	  }
    1186. 

  1186. 	  optrcdata_data_int
    1187. 

  1187. 	  {
    1188. 

  1188. 	    rcparse_normal ();
    1189. 

  1189. 	    $$ = $2;
    1190. 

  1190. 	  }
    1191. 

  1191. 	;
    1192. 

  1192. 

  1193. optrcdata_data_int:
    1194. 

  1194. 	  /* empty */
    1195. 

  1195. 	  {
    1196. 

  1196. 	    $$.first = NULL;
    1197. 

  1197. 	    $$.last = NULL;
    1198. 

  1198. 	  }
    1199. 

  1199. 	| rcdata_data
    1200. 

  1200. 	  {
    1201. 

  1201. 	    $$ = $1;
    1202. 

  1202. 	  }
    1203. 

  1203. 	;
    1204. 

  1204. 

  1205. rcdata_data:
    1206. 

  1206. 	  SIZEDSTRING
    1207. 

  1207. 	  {
    1208. 

  1208. 	    struct rcdata_item *ri;
    1209. 

  1209. 

  1210. 	    ri = define_rcdata_string ($1.s, $1.length);
    1211. 

  1211. 	    $$.first = ri;
    1212. 

  1212. 	    $$.last = ri;
    1213. 

  1213. 	  }
    1214. 

  1214. 	| sizednumexpr
    1215. 

  1215. 	  {
    1216. 

  1216. 	    struct rcdata_item *ri;
    1217. 

  1217. 

  1218. 	    ri = define_rcdata_number ($1.val, $1.dword);
    1219. 

  1219. 	    $$.first = ri;
    1220. 

  1220. 	    $$.last = ri;
    1221. 

  1221. 	  }
    1222. 

  1222. 	| rcdata_data ',' SIZEDSTRING
    1223. 

  1223. 	  {
    1224. 

  1224. 	    struct rcdata_item *ri;
    1225. 

  1225. 

  1226. 	    ri = define_rcdata_string ($3.s, $3.length);
    1227. 

  1227. 	    $$.first = $1.first;
    1228. 

  1228. 	    $1.last-&gt;next = ri;
    1229. 

  1229. 	    $$.last = ri;
    1230. 

  1230. 	  }
    1231. 

  1231. 	| rcdata_data ',' sizednumexpr
    1232. 

  1232. 	  {
    1233. 

  1233. 	    struct rcdata_item *ri;
    1234. 

  1234. 

  1235. 	    ri = define_rcdata_number ($3.val, $3.dword);
    1236. 

  1236. 	    $$.first = $1.first;
    1237. 

  1237. 	    $1.last-&gt;next = ri;
    1238. 

  1238. 	    $$.last = ri;
    1239. 

  1239. 	  }
    1240. 

  1240. 	;
    1241. 

  1241. 

  1242. /* Stringtable resources.  */
    1243. 

  1243. 

  1244. stringtable:
    1245. 

  1245. 	  STRINGTABLE suboptions BEG 
    1246. 

  1246. 	    { sub_res_info = $2; }
    1247. 

  1247. 	    string_data END
    1248. 

  1248. 	;
    1249. 

  1249. 

  1250. string_data:
    1251. 

  1251. 	  /* empty */
    1252. 

  1252. 	| string_data numexpr QUOTEDSTRING
    1253. 

  1253. 	  {
    1254. 

  1254. 	    define_stringtable (&amp;sub_res_info, $2, $3);
    1255. 

  1255. 	    if (yychar != YYEMPTY)
    1256. 

  1256. 	      YYERROR;
    1257. 

  1257. 	    rcparse_discard_strings ();
    1258. 

  1258. 	  }
    1259. 

  1259. 	| string_data numexpr ',' QUOTEDSTRING
    1260. 

  1260. 	  {
    1261. 

  1261. 	    define_stringtable (&amp;sub_res_info, $2, $4);
    1262. 

  1262. 	    if (yychar != YYEMPTY)
    1263. 

  1263. 	      YYERROR;
    1264. 

  1264. 	    rcparse_discard_strings ();
    1265. 

  1265. 	  }
    1266. 

  1266. 	;
    1267. 

  1267. 

  1268. /* User defined resources.  We accept general suboptions in the
    1269. 

  1269.    file_name case to keep the parser happy.  */
    1270. 

  1270. 

  1271. user:
    1272. 

  1272. 	  id id suboptions BEG optrcdata_data END
    1273. 

  1273. 	  {
    1274. 

  1274. 	    define_user_data ($1, $2, &amp;$3, $5.first);
    1275. 

  1275. 	    if (yychar != YYEMPTY)
    1276. 

  1276. 	      YYERROR;
    1277. 

  1277. 	    rcparse_discard_strings ();
    1278. 

  1278. 	  }
    1279. 

  1279. 	| id id suboptions file_name
    1280. 

  1280. 	  {
    1281. 

  1281. 	    define_user_file ($1, $2, &amp;$3, $4);
    1282. 

  1282. 	    if (yychar != YYEMPTY)
    1283. 

  1283. 	      YYERROR;
    1284. 

  1284. 	    rcparse_discard_strings ();
    1285. 

  1285. 	  }
    1286. 

  1286. 	;
    1287. 

  1287. 

  1288. /* Versioninfo resources.  */
    1289. 

  1289. 

  1290. versioninfo:
    1291. 

  1291. 	  id VERSIONINFO fixedverinfo BEG verblocks END
    1292. 

  1292. 	  {
    1293. 

  1293. 	    define_versioninfo ($1, language, $3, $5);
    1294. 

  1294. 	    if (yychar != YYEMPTY)
    1295. 

  1295. 	      YYERROR;
    1296. 

  1296. 	    rcparse_discard_strings ();
    1297. 

  1297. 	  }
    1298. 

  1298. 	;
    1299. 

  1299. 

  1300. fixedverinfo:
    1301. 

  1301. 	  /* empty */
    1302. 

  1302. 	  {
    1303. 

  1303. 	    $$ = ((struct fixed_versioninfo *)
    1304. 

  1304. 		  res_alloc (sizeof (struct fixed_versioninfo)));
    1305. 

  1305. 	    memset ($$, 0, sizeof (struct fixed_versioninfo));
    1306. 

  1306. 	  }
    1307. 

  1307. 	| fixedverinfo FILEVERSION numexpr cnumexpr cnumexpr cnumexpr
    1308. 

  1308. 	  {
    1309. 

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

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

  1311. 	    $$ = $1;
    1312. 

  1312. 	  }
    1313. 

  1313. 	| fixedverinfo PRODUCTVERSION numexpr cnumexpr cnumexpr cnumexpr
    1314. 

  1314. 	  {
    1315. 

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

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

  1317. 	    $$ = $1;
    1318. 

  1318. 	  }
    1319. 

  1319. 	| fixedverinfo FILEFLAGSMASK numexpr
    1320. 

  1320. 	  {
    1321. 

  1321. 	    $1-&gt;file_flags_mask = $3;
    1322. 

  1322. 	    $$ = $1;
    1323. 

  1323. 	  }
    1324. 

  1324. 	| fixedverinfo FILEFLAGS numexpr
    1325. 

  1325. 	  {
    1326. 

  1326. 	    $1-&gt;file_flags = $3;
    1327. 

  1327. 	    $$ = $1;
    1328. 

  1328. 	  }
    1329. 

  1329. 	| fixedverinfo FILEOS numexpr
    1330. 

  1330. 	  {
    1331. 

  1331. 	    $1-&gt;file_os = $3;
    1332. 

  1332. 	    $$ = $1;
    1333. 

  1333. 	  }
    1334. 

  1334. 	| fixedverinfo FILETYPE numexpr
    1335. 

  1335. 	  {
    1336. 

  1336. 	    $1-&gt;file_type = $3;
    1337. 

  1337. 	    $$ = $1;
    1338. 

  1338. 	  }
    1339. 

  1339. 	| fixedverinfo FILESUBTYPE numexpr
    1340. 

  1340. 	  {
    1341. 

  1341. 	    $1-&gt;file_subtype = $3;
    1342. 

  1342. 	    $$ = $1;
    1343. 

  1343. 	  }
    1344. 

  1344. 	;
    1345. 

  1345. 

  1346. /* To handle verblocks successfully, the lexer handles BLOCK
    1347. 

  1347.    specially.  A BLOCK &quot;StringFileInfo&quot; is returned as
    1348. 

  1348.    BLOCKSTRINGFILEINFO.  A BLOCK &quot;VarFileInfo&quot; is returned as
    1349. 

  1349.    BLOCKVARFILEINFO.  A BLOCK with some other string returns BLOCK
    1350. 

  1350.    with the string as the value.  */
    1351. 

  1351. 

  1352. verblocks:
    1353. 

  1353. 	  /* empty */
    1354. 

  1354. 	  {
    1355. 

  1355. 	    $$ = NULL;
    1356. 

  1356. 	  }
    1357. 

  1357. 	| verblocks BLOCKSTRINGFILEINFO BEG BLOCK BEG vervals END END
    1358. 

  1358. 	  {
    1359. 

  1359. 	    $$ = append_ver_stringfileinfo ($1, $4, $6);
    1360. 

  1360. 	  }
    1361. 

  1361. 	| verblocks BLOCKVARFILEINFO BEG VALUE QUOTEDSTRING vertrans END
    1362. 

  1362. 	  {
    1363. 

  1363. 	    $$ = append_ver_varfileinfo ($1, $5, $6);
    1364. 

  1364. 	  }
    1365. 

  1365. 	;
    1366. 

  1366. 

  1367. vervals:
    1368. 

  1368. 	  /* empty */
    1369. 

  1369. 	  {
    1370. 

  1370. 	    $$ = NULL;
    1371. 

  1371. 	  }
    1372. 

  1372. 	| vervals VALUE QUOTEDSTRING ',' QUOTEDSTRING
    1373. 

  1373. 	  {
    1374. 

  1374. 	    $$ = append_verval ($1, $3, $5);
    1375. 

  1375. 	  }
    1376. 

  1376. 	;
    1377. 

  1377. 

  1378. vertrans:
    1379. 

  1379. 	  /* empty */
    1380. 

  1380. 	  {
    1381. 

  1381. 	    $$ = NULL;
    1382. 

  1382. 	  }
    1383. 

  1383. 	| vertrans cnumexpr cnumexpr
    1384. 

  1384. 	  {
    1385. 

  1385. 	    $$ = append_vertrans ($1, $2, $3);
    1386. 

  1386. 	  }
    1387. 

  1387. 	;
    1388. 

  1388. 

  1389. /* A resource ID.  */
    1390. 

  1390. 

  1391. id:
    1392. 

  1392. 	  posnumexpr
    1393. 

  1393. 	  {
    1394. 

  1394. 	    $$.named = 0;
    1395. 

  1395. 	    $$.u.id = $1;
    1396. 

  1396. 	  }
    1397. 

  1397. 	| STRING
    1398. 

  1398. 	  {
    1399. 

  1399. 	    char *copy, *s;
    1400. 

  1400. 

  1401. 	    /* It seems that resource ID's are forced to upper case.  */
    1402. 

  1402. 	    copy = xstrdup ($1);
    1403. 

  1403. 	    for (s = copy; *s != '\0'; s++)
    1404. 

  1404. 	      *s = TOUPPER (*s);
    1405. 

  1405. 	    res_string_to_id (&amp;$$, copy);
    1406. 

  1406. 	    free (copy);
    1407. 

  1407. 	  }
    1408. 

  1408. 	;
    1409. 

  1409. 

  1410. /* A resource reference.  */
    1411. 

  1411. 

  1412. resname:
    1413. 

  1413. 	  QUOTEDSTRING
    1414. 

  1414. 	  {
    1415. 

  1415. 	    $$ = $1;
    1416. 

  1416. 	  }
    1417. 

  1417. 	| QUOTEDSTRING ','
    1418. 

  1418. 	  {
    1419. 

  1419. 	    $$ = $1;
    1420. 

  1420. 	  }
    1421. 

  1421. 	| STRING ','
    1422. 

  1422. 	  {
    1423. 

  1423. 	    $$ = $1;
    1424. 

  1424. 	  }
    1425. 

  1425. 	;
    1426. 

  1426. 

  1427. 

  1428. resref:
    1429. 

  1429. 	  posnumexpr ','
    1430. 

  1430. 	  {
    1431. 

  1431. 	    $$.named = 0;
    1432. 

  1432. 	    $$.u.id = $1;
    1433. 

  1433. 	  }
    1434. 

  1434. 	| resname
    1435. 

  1435. 	  {
    1436. 

  1436. 	    char *copy, *s;
    1437. 

  1437. 

  1438. 	    /* It seems that resource ID's are forced to upper case.  */
    1439. 

  1439. 	    copy = xstrdup ($1);
    1440. 

  1440. 	    for (s = copy; *s != '\0'; s++)
    1441. 

  1441. 	      *s = TOUPPER (*s);
    1442. 

  1442. 	    res_string_to_id (&amp;$$, copy);
    1443. 

  1443. 	    free (copy);
    1444. 

  1444. 	  }
    1445. 

  1445. 	;
    1446. 

  1446. 

  1447. /* Generic suboptions.  These may appear before the BEGIN in any
    1448. 

  1448.    multiline statement.  */
    1449. 

  1449. 

  1450. suboptions:
    1451. 

  1451. 	  /* empty */
    1452. 

  1452. 	  {
    1453. 

  1453. 	    memset (&amp;$$, 0, sizeof (struct res_res_info));
    1454. 

  1454. 	    $$.language = language;
    1455. 

  1455. 	    /* FIXME: Is this the right default?  */
    1456. 

  1456. 	    $$.memflags = MEMFLAG_MOVEABLE | MEMFLAG_PURE | MEMFLAG_DISCARDABLE;
    1457. 

  1457. 	  }
    1458. 

  1458. 	| suboptions memflag
    1459. 

  1459. 	  {
    1460. 

  1460. 	    $$ = $1;
    1461. 

  1461. 	    $$.memflags |= $2.on;
    1462. 

  1462. 	    $$.memflags &amp;=~ $2.off;
    1463. 

  1463. 	  }
    1464. 

  1464. 	| suboptions CHARACTERISTICS numexpr
    1465. 

  1465. 	  {
    1466. 

  1466. 	    $$ = $1;
    1467. 

  1467. 	    $$.characteristics = $3;
    1468. 

  1468. 	  }
    1469. 

  1469. 	| suboptions LANGUAGE numexpr cnumexpr
    1470. 

  1470. 	  {
    1471. 

  1471. 	    $$ = $1;
    1472. 

  1472. 	    $$.language = $3 | ($4 &lt;&lt; SUBLANG_SHIFT);
    1473. 

  1473. 	  }
    1474. 

  1474. 	| suboptions VERSIONK numexpr
    1475. 

  1475. 	  {
    1476. 

  1476. 	    $$ = $1;
    1477. 

  1477. 	    $$.version = $3;
    1478. 

  1478. 	  }
    1479. 

  1479. 	;
    1480. 

  1480. 

  1481. /* Memory flags which default to MOVEABLE and DISCARDABLE.  */
    1482. 

  1482. 

  1483. memflags_move_discard:
    1484. 

  1484. 	  /* empty */
    1485. 

  1485. 	  {
    1486. 

  1486. 	    memset (&amp;$$, 0, sizeof (struct res_res_info));
    1487. 

  1487. 	    $$.language = language;
    1488. 

  1488. 	    $$.memflags = MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE;
    1489. 

  1489. 	  }
    1490. 

  1490. 	| memflags_move_discard memflag
    1491. 

  1491. 	  {
    1492. 

  1492. 	    $$ = $1;
    1493. 

  1493. 	    $$.memflags |= $2.on;
    1494. 

  1494. 	    $$.memflags &amp;=~ $2.off;
    1495. 

  1495. 	  }
    1496. 

  1496. 	;
    1497. 

  1497. 

  1498. /* Memory flags which default to MOVEABLE.  */
    1499. 

  1499. 

  1500. memflags_move:
    1501. 

  1501. 	  /* empty */
    1502. 

  1502. 	  {
    1503. 

  1503. 	    memset (&amp;$$, 0, sizeof (struct res_res_info));
    1504. 

  1504. 	    $$.language = language;
    1505. 

  1505. 	    $$.memflags = MEMFLAG_MOVEABLE | MEMFLAG_PURE | MEMFLAG_DISCARDABLE;
    1506. 

  1506. 	  }
    1507. 

  1507. 	| memflags_move memflag
    1508. 

  1508. 	  {
    1509. 

  1509. 	    $$ = $1;
    1510. 

  1510. 	    $$.memflags |= $2.on;
    1511. 

  1511. 	    $$.memflags &amp;=~ $2.off;
    1512. 

  1512. 	  }
    1513. 

  1513. 	;
    1514. 

  1514. 

  1515. /* Memory flags.  This returns a struct with two integers, because we
    1516. 

  1516.    sometimes want to set bits and we sometimes want to clear them.  */
    1517. 

  1517. 

  1518. memflag:
    1519. 

  1519. 	  MOVEABLE
    1520. 

  1520. 	  {
    1521. 

  1521. 	    $$.on = MEMFLAG_MOVEABLE;
    1522. 

  1522. 	    $$.off = 0;
    1523. 

  1523. 	  }
    1524. 

  1524. 	| FIXED
    1525. 

  1525. 	  {
    1526. 

  1526. 	    $$.on = 0;
    1527. 

  1527. 	    $$.off = MEMFLAG_MOVEABLE;
    1528. 

  1528. 	  }
    1529. 

  1529. 	| PURE
    1530. 

  1530. 	  {
    1531. 

  1531. 	    $$.on = MEMFLAG_PURE;
    1532. 

  1532. 	    $$.off = 0;
    1533. 

  1533. 	  }
    1534. 

  1534. 	| IMPURE
    1535. 

  1535. 	  {
    1536. 

  1536. 	    $$.on = 0;
    1537. 

  1537. 	    $$.off = MEMFLAG_PURE;
    1538. 

  1538. 	  }
    1539. 

  1539. 	| PRELOAD
    1540. 

  1540. 	  {
    1541. 

  1541. 	    $$.on = MEMFLAG_PRELOAD;
    1542. 

  1542. 	    $$.off = 0;
    1543. 

  1543. 	  }
    1544. 

  1544. 	| LOADONCALL
    1545. 

  1545. 	  {
    1546. 

  1546. 	    $$.on = 0;
    1547. 

  1547. 	    $$.off = MEMFLAG_PRELOAD;
    1548. 

  1548. 	  }
    1549. 

  1549. 	| DISCARDABLE
    1550. 

  1550. 	  {
    1551. 

  1551. 	    $$.on = MEMFLAG_DISCARDABLE;
    1552. 

  1552. 	    $$.off = 0;
    1553. 

  1553. 	  }
    1554. 

  1554. 	;
    1555. 

  1555. 

  1556. /* A file name.  */
    1557. 

  1557. 

  1558. file_name:
    1559. 

  1559. 	  QUOTEDSTRING
    1560. 

  1560. 	  {
    1561. 

  1561. 	    $$ = $1;
    1562. 

  1562. 	  }
    1563. 

  1563. 	| STRING
    1564. 

  1564. 	  {
    1565. 

  1565. 	    $$ = $1;
    1566. 

  1566. 	  }
    1567. 

  1567. 	;
    1568. 

  1568. 

  1569. /* A style expression.  This changes the static variable STYLE.  We do
    1570. 

  1570.    it this way because rc appears to permit a style to be set to
    1571. 

  1571.    something like
    1572. 

  1572.        WS_GROUP | NOT WS_TABSTOP
    1573. 

  1573.    to mean that a default of WS_TABSTOP should be removed.  Anything
    1574. 

  1574.    which wants to accept a style must first set STYLE to the default
    1575. 

  1575.    value.  The styleexpr nonterminal will change STYLE as specified by
    1576. 

  1576.    the user.  Note that we do not accept arbitrary expressions here,
    1577. 

  1577.    just numbers separated by '|'.  */
    1578. 

  1578. 

  1579. styleexpr:
    1580. 

  1580. 	  parennumber
    1581. 

  1581. 	  {
    1582. 

  1582. 	    style |= $1;
    1583. 

  1583. 	  }
    1584. 

  1584. 	| NOT parennumber
    1585. 

  1585. 	  {
    1586. 

  1586. 	    style &amp;=~ $2;
    1587. 

  1587. 	  }
    1588. 

  1588. 	| styleexpr '|' parennumber
    1589. 

  1589. 	  {
    1590. 

  1590. 	    style |= $3;
    1591. 

  1591. 	  }
    1592. 

  1592. 	| styleexpr '|' NOT parennumber
    1593. 

  1593. 	  {
    1594. 

  1594. 	    style &amp;=~ $4;
    1595. 

  1595. 	  }
    1596. 

  1596. 	;
    1597. 

  1597. 

  1598. parennumber:
    1599. 

  1599. 	  NUMBER
    1600. 

  1600. 	  {
    1601. 

  1601. 	    $$ = $1.val;
    1602. 

  1602. 	  }
    1603. 

  1603. 	| '(' numexpr ')'
    1604. 

  1604. 	  {
    1605. 

  1605. 	    $$ = $2;
    1606. 

  1606. 	  }
    1607. 

  1607. 	;
    1608. 

  1608. 

  1609. /* An optional expression with a leading comma.  */
    1610. 

  1610. 

  1611. optcnumexpr:
    1612. 

  1612. 	  /* empty */
    1613. 

  1613. 	  {
    1614. 

  1614. 	    $$ = 0;
    1615. 

  1615. 	  }
    1616. 

  1616. 	| cnumexpr
    1617. 

  1617. 	  {
    1618. 

  1618. 	    $$ = $1;
    1619. 

  1619. 	  }
    1620. 

  1620. 	;
    1621. 

  1621. 

  1622. /* An expression with a leading comma.  */
    1623. 

  1623. 

  1624. cnumexpr:
    1625. 

  1625. 	  ',' numexpr
    1626. 

  1626. 	  {
    1627. 

  1627. 	    $$ = $2;
    1628. 

  1628. 	  }
    1629. 

  1629. 	;
    1630. 

  1630. 

  1631. /* A possibly negated numeric expression.  */
    1632. 

  1632. 

  1633. numexpr:
    1634. 

  1634. 	  sizednumexpr
    1635. 

  1635. 	  {
    1636. 

  1636. 	    $$ = $1.val;
    1637. 

  1637. 	  }
    1638. 

  1638. 	;
    1639. 

  1639. 

  1640. /* A possibly negated expression with a size.  */
    1641. 

  1641. 

  1642. sizednumexpr:
    1643. 

  1643. 	  NUMBER
    1644. 

  1644. 	  {
    1645. 

  1645. 	    $$ = $1;
    1646. 

  1646. 	  }
    1647. 

  1647. 	| '(' sizednumexpr ')'
    1648. 

  1648. 	  {
    1649. 

  1649. 	    $$ = $2;
    1650. 

  1650. 	  }
    1651. 

  1651. 	| '~' sizednumexpr %prec '~'
    1652. 

  1652. 	  {
    1653. 

  1653. 	    $$.val = ~ $2.val;
    1654. 

  1654. 	    $$.dword = $2.dword;
    1655. 

  1655. 	  }
    1656. 

  1656. 	| '-' sizednumexpr %prec NEG
    1657. 

  1657. 	  {
    1658. 

  1658. 	    $$.val = - $2.val;
    1659. 

  1659. 	    $$.dword = $2.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. 	| sizednumexpr '%' sizednumexpr
    1672. 

  1672. 	  {
    1673. 

  1673. 	    $$.val = $1.val % $3.val;
    1674. 

  1674. 	    $$.dword = $1.dword || $3.dword;
    1675. 

  1675. 	  }
    1676. 

  1676. 	| sizednumexpr '+' sizednumexpr
    1677. 

  1677. 	  {
    1678. 

  1678. 	    $$.val = $1.val + $3.val;
    1679. 

  1679. 	    $$.dword = $1.dword || $3.dword;
    1680. 

  1680. 	  }
    1681. 

  1681. 	| sizednumexpr '-' sizednumexpr
    1682. 

  1682. 	  {
    1683. 

  1683. 	    $$.val = $1.val - $3.val;
    1684. 

  1684. 	    $$.dword = $1.dword || $3.dword;
    1685. 

  1685. 	  }
    1686. 

  1686. 	| sizednumexpr '&amp;' sizednumexpr
    1687. 

  1687. 	  {
    1688. 

  1688. 	    $$.val = $1.val &amp; $3.val;
    1689. 

  1689. 	    $$.dword = $1.dword || $3.dword;
    1690. 

  1690. 	  }
    1691. 

  1691. 	| sizednumexpr '^' sizednumexpr
    1692. 

  1692. 	  {
    1693. 

  1693. 	    $$.val = $1.val ^ $3.val;
    1694. 

  1694. 	    $$.dword = $1.dword || $3.dword;
    1695. 

  1695. 	  }
    1696. 

  1696. 	| sizednumexpr '|' sizednumexpr
    1697. 

  1697. 	  {
    1698. 

  1698. 	    $$.val = $1.val | $3.val;
    1699. 

  1699. 	    $$.dword = $1.dword || $3.dword;
    1700. 

  1700. 	  }
    1701. 

  1701. 	;
    1702. 

  1702. 

  1703. /* An expression with a leading comma which does not use unary
    1704. 

  1704.    negation.  */
    1705. 

  1705. 

  1706. cposnumexpr:
    1707. 

  1707. 	  ',' posnumexpr
    1708. 

  1708. 	  {
    1709. 

  1709. 	    $$ = $2;
    1710. 

  1710. 	  }
    1711. 

  1711. 	;
    1712. 

  1712. 

  1713. /* An expression which does not use unary negation.  */
    1714. 

  1714. 

  1715. posnumexpr:
    1716. 

  1716. 	  sizedposnumexpr
    1717. 

  1717. 	  {
    1718. 

  1718. 	    $$ = $1.val;
    1719. 

  1719. 	  }
    1720. 

  1720. 	;
    1721. 

  1721. 

  1722. /* An expression which does not use unary negation.  We separate unary
    1723. 

  1723.    negation to avoid parsing conflicts when two numeric expressions
    1724. 

  1724.    appear consecutively.  */
    1725. 

  1725. 

  1726. sizedposnumexpr:
    1727. 

  1727. 	  NUMBER
    1728. 

  1728. 	  {
    1729. 

  1729. 	    $$ = $1;
    1730. 

  1730. 	  }
    1731. 

  1731. 	| '(' sizednumexpr ')'
    1732. 

  1732. 	  {
    1733. 

  1733. 	    $$ = $2;
    1734. 

  1734. 	  }
    1735. 

  1735. 	| '~' sizednumexpr %prec '~'
    1736. 

  1736. 	  {
    1737. 

  1737. 	    $$.val = ~ $2.val;
    1738. 

  1738. 	    $$.dword = $2.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. 	| sizedposnumexpr '%' sizednumexpr
    1751. 

  1751. 	  {
    1752. 

  1752. 	    $$.val = $1.val % $3.val;
    1753. 

  1753. 	    $$.dword = $1.dword || $3.dword;
    1754. 

  1754. 	  }
    1755. 

  1755. 	| sizedposnumexpr '+' sizednumexpr
    1756. 

  1756. 	  {
    1757. 

  1757. 	    $$.val = $1.val + $3.val;
    1758. 

  1758. 	    $$.dword = $1.dword || $3.dword;
    1759. 

  1759. 	  }
    1760. 

  1760. 	| sizedposnumexpr '-' sizednumexpr
    1761. 

  1761. 	  {
    1762. 

  1762. 	    $$.val = $1.val - $3.val;
    1763. 

  1763. 	    $$.dword = $1.dword || $3.dword;
    1764. 

  1764. 	  }
    1765. 

  1765. 	| sizedposnumexpr '&amp;' sizednumexpr
    1766. 

  1766. 	  {
    1767. 

  1767. 	    $$.val = $1.val &amp; $3.val;
    1768. 

  1768. 	    $$.dword = $1.dword || $3.dword;
    1769. 

  1769. 	  }
    1770. 

  1770. 	| sizedposnumexpr '^' sizednumexpr
    1771. 

  1771. 	  {
    1772. 

  1772. 	    $$.val = $1.val ^ $3.val;
    1773. 

  1773. 	    $$.dword = $1.dword || $3.dword;
    1774. 

  1774. 	  }
    1775. 

  1775. 	| sizedposnumexpr '|' sizednumexpr
    1776. 

  1776. 	  {
    1777. 

  1777. 	    $$.val = $1.val | $3.val;
    1778. 

  1778. 	    $$.dword = $1.dword || $3.dword;
    1779. 

  1779. 	  }
    1780. 

  1780. 	;
    1781. 

  1781. 

  1782. %%
    1783. 

  1783. 

  1784. /* Set the language from the command line.  */
    1785. 

  1785. 

  1786. void
    1787. 

  1787. rcparse_set_language (int lang)
    1788. 

  1788. {
    1789. 

  1789.   language = lang;
    1790. 

  1790. }
    1791. 

  1791. </pre>
    1792. 

  1792. <hr />
    1793. 

  1793. </body></html>
    1794.