binutils/rcparse.y

   1 %{ /* rcparse.y -- parser for Windows rc files
   2    Copyright 1997, 1998 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 /* This is a parser for Windows rc files.  It is based on the parser
  23    by Gunther Ebert <gunther.ebert@ixos-leipzig.de>.  */
  24
  25 #include "bfd.h"
  26 #include "bucomm.h"
  27 #include "libiberty.h"
  28 #include "windres.h"
  29
  30 #include <ctype.h>
  31
  32 /* The current language.  */
  33
  34 static unsigned short language;
  35
  36 /* The resource information during a sub statement.  */
  37
  38 static struct res_res_info sub_res_info;
  39
  40 /* Dialog information.  This is built by the nonterminals styles and
  41    controls.  */
  42
  43 static struct dialog dialog;
  44
  45 /* This is used when building a style.  It is modified by the
  46    nonterminal styleexpr.  */
  47
  48 static unsigned long style;
  49
  50 /* These are used when building a control.  They are set before using
  51    control_params.  */
  52
  53 static unsigned long base_style;
  54 static unsigned long default_style;
  55 static unsigned long class;
  56
  57 %}
  58
  59 %union
  60 {
  61   struct accelerator acc;
  62   struct accelerator *pacc;
  63   struct dialog_control *dialog_control;
  64   struct menuitem *menuitem;
  65   struct
  66   {
  67     struct rcdata_item *first;
  68     struct rcdata_item *last;
  69   } rcdata;
  70   struct rcdata_item *rcdata_item;
  71   struct stringtable_data *stringtable;
  72   struct fixed_versioninfo *fixver;
  73   struct ver_info *verinfo;
  74   struct ver_stringinfo *verstring;
  75   struct ver_varinfo *vervar;
  76   struct res_id id;
  77   struct res_res_info res_info;
  78   struct
  79   {
  80     unsigned short on;
  81     unsigned short off;
  82   } memflags;
  83   struct
  84   {
  85     unsigned long val;
  86     /* Nonzero if this number was explicitly specified as long.  */
  87     int dword;
  88   } i;
  89   unsigned long il;
  90   unsigned short is;
  91   const char *s;
  92   struct
  93   {
  94     unsigned long length;
  95     const char *s;
  96   } ss;
  97 };
  98
  99 %token BEG END
 100 %token ACCELERATORS VIRTKEY ASCII NOINVERT SHIFT CONTROL ALT
 101 %token BITMAP
 102 %token CURSOR
 103 %token DIALOG DIALOGEX EXSTYLE CAPTION CLASS STYLE
 104 %token AUTO3STATE AUTOCHECKBOX AUTORADIOBUTTON CHECKBOX COMBOBOX CTEXT
 105 %token DEFPUSHBUTTON EDITTEXT GROUPBOX LISTBOX LTEXT PUSHBOX PUSHBUTTON
 106 %token RADIOBUTTON RTEXT SCROLLBAR STATE3 USERBUTTON
 107 %token BEDIT HEDIT IEDIT
 108 %token FONT
 109 %token ICON
 110 %token LANGUAGE CHARACTERISTICS VERSIONK
 111 %token MENU MENUEX MENUITEM SEPARATOR POPUP CHECKED GRAYED HELP INACTIVE
 112 %token MENUBARBREAK MENUBREAK
 113 %token MESSAGETABLE
 114 %token RCDATA
 115 %token STRINGTABLE
 116 %token VERSIONINFO FILEVERSION PRODUCTVERSION FILEFLAGSMASK FILEFLAGS
 117 %token FILEOS FILETYPE FILESUBTYPE BLOCKSTRINGFILEINFO BLOCKVARFILEINFO
 118 %token VALUE
 119 %token <s> BLOCK
 120 %token MOVEABLE FIXED PURE IMPURE PRELOAD LOADONCALL DISCARDABLE
 121 %token NOT
 122 %token <s> QUOTEDSTRING STRING
 123 %token <i> NUMBER
 124 %token <ss> SIZEDSTRING
 125 %token IGNORED_TOKEN
 126
 127 %type <pacc> acc_entries
 128 %type <acc> acc_entry acc_event
 129 %type <dialog_control> control control_params
 130 %type <menuitem> menuitems menuitem menuexitems menuexitem
 131 %type <rcdata> optrcdata_data optrcdata_data_int rcdata_data
 132 %type <rcdata_item> opt_control_data
 133 %type <fixver> fixedverinfo
 134 %type <verinfo> verblocks
 135 %type <verstring> vervals
 136 %type <vervar> vertrans
 137 %type <res_info> suboptions memflags_move_discard memflags_move
 138 %type <memflags> memflag
 139 %type <id> id
 140 %type <il> exstyle parennumber
 141 %type <il> numexpr posnumexpr cnumexpr optcnumexpr cposnumexpr
 142 %type <is> acc_options acc_option menuitem_flags menuitem_flag
 143 %type <s> optstringc file_name
 144 %type <i> sizednumexpr sizedposnumexpr
 145
 146 %left '|'
 147 %left '^'
 148 %left '&'
 149 %left '+' '-'
 150 %left '*' '/' '%'
 151 %right '~' NEG
 152
 153 %%
 154
 155 input:
 156           /* empty */
 157         | input newcmd accelerator
 158         | input newcmd bitmap
 159         | input newcmd cursor
 160         | input newcmd dialog
 161         | input newcmd font
 162         | input newcmd icon
 163         | input newcmd language
 164         | input newcmd menu
 165         | input newcmd menuex
 166         | input newcmd messagetable
 167         | input newcmd rcdata
 168         | input newcmd stringtable
 169         | input newcmd user
 170         | input newcmd versioninfo
 171         | input newcmd IGNORED_TOKEN
 172         ;
 173
 174 newcmd:
 175           /* empty */
 176           {
 177             rcparse_discard_strings ();
 178           }
 179         ;
 180
 181 /* Accelerator resources.  */
 182
 183 accelerator:
 184           id ACCELERATORS suboptions BEG acc_entries END
 185           {
 186             define_accelerator ($1, &$3, $5);
 187           }
 188         ;
 189
 190 acc_entries:
 191           /* empty */
 192           {
 193             $$ = NULL;
 194           }
 195         | acc_entries acc_entry
 196           {
 197             struct accelerator *a;
 198
 199             a = (struct accelerator *) res_alloc (sizeof *a);
 200             *a = $2;
 201             if ($1 == NULL)
 202               $$ = a;
 203             else
 204               {
 205                 struct accelerator **pp;
 206
 207                 for (pp = &$1->next; *pp != NULL; pp = &(*pp)->next)
 208                   ;
 209                 *pp = a;
 210                 $$ = $1;
 211               }
 212           }
 213         ;
 214
 215 acc_entry:
 216           acc_event cposnumexpr
 217           {
 218             $$ = $1;
 219             $$.id = $2;
 220           }
 221         | acc_event cposnumexpr ',' acc_options
 222           {
 223             $$ = $1;
 224             $$.id = $2;
 225             $$.flags |= $4;
 226             if (($$.flags & ACC_VIRTKEY) == 0
 227                 && ($$.flags & (ACC_SHIFT | ACC_CONTROL | ACC_ALT)) != 0)
 228               rcparse_warning (_("inappropriate modifiers for non-VIRTKEY"));
 229           }
 230         ;
 231
 232 acc_event:
 233           QUOTEDSTRING
 234           {
 235             const char *s = $1;
 236             char ch;
 237
 238             $$.next = NULL;
 239             $$.id = 0;
 240             ch = *s;
 241             if (ch != '^')
 242               $$.flags = 0;
 243             else
 244               {
 245                 $$.flags = ACC_CONTROL | ACC_VIRTKEY;
 246                 ++s;
 247                 ch = *s;
 248                 ch = toupper ((unsigned char) ch);
 249               }
 250             $$.key = ch;
 251             if (s[1] != '\0')
 252               rcparse_warning (_("accelerator should only be one character"));
 253           }
 254         | posnumexpr
 255           {
 256             $$.next = NULL;
 257             $$.flags = 0;
 258             $$.id = 0;
 259             $$.key = $1;
 260           }
 261         ;
 262
 263 acc_options:
 264           acc_option
 265           {
 266             $$ = $1;
 267           }
 268         | acc_options ',' acc_option
 269           {
 270             $$ = $1 | $3;
 271           }
 272         /* I've had one report that the comma is optional.  */
 273         | acc_options acc_option
 274           {
 275             $$ = $1 | $2;
 276           }
 277         ;
 278
 279 acc_option:
 280           VIRTKEY
 281           {
 282             $$ = ACC_VIRTKEY;
 283           }
 284         | ASCII
 285           {
 286             /* This is just the absence of VIRTKEY.  */
 287             $$ = 0;
 288           }
 289         | NOINVERT
 290           {
 291             $$ = ACC_NOINVERT;
 292           }
 293         | SHIFT
 294           {
 295             $$ = ACC_SHIFT;
 296           }
 297         | CONTROL
 298           {
 299             $$ = ACC_CONTROL;
 300           }
 301         | ALT
 302           {
 303             $$ = ACC_ALT;
 304           }
 305         ;
 306
 307 /* Bitmap resources.  */
 308
 309 bitmap:
 310           id BITMAP memflags_move file_name
 311           {
 312             define_bitmap ($1, &$3, $4);
 313           }
 314         ;
 315
 316 /* Cursor resources.  */
 317
 318 cursor:
 319           id CURSOR memflags_move_discard file_name
 320           {
 321             define_cursor ($1, &$3, $4);
 322           }
 323         ;
 324
 325 /* Dialog resources.  */
 326
 327 dialog:
 328           id DIALOG memflags_move exstyle posnumexpr cnumexpr cnumexpr
 329             cnumexpr
 330             {
 331               memset (&dialog, 0, sizeof dialog);
 332               dialog.x = $5;
 333               dialog.y = $6;
 334               dialog.width = $7;
 335               dialog.height = $8;
 336               dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
 337               dialog.exstyle = $4;
 338               dialog.menu.named = 1;
 339               dialog.class.named = 1;
 340               dialog.font = NULL;
 341               dialog.ex = NULL;
 342               dialog.controls = NULL;
 343               sub_res_info = $3;
 344             }
 345             styles BEG controls END
 346           {
 347             define_dialog ($1, &sub_res_info, &dialog);
 348           }
 349         | id DIALOGEX memflags_move exstyle posnumexpr cnumexpr cnumexpr
 350             cnumexpr
 351             {
 352               memset (&dialog, 0, sizeof dialog);
 353               dialog.x = $5;
 354               dialog.y = $6;
 355               dialog.width = $7;
 356               dialog.height = $8;
 357               dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
 358               dialog.exstyle = $4;
 359               dialog.menu.named = 1;
 360               dialog.class.named = 1;
 361               dialog.font = NULL;
 362               dialog.ex = ((struct dialog_ex *)
 363                            res_alloc (sizeof (struct dialog_ex)));
 364               memset (dialog.ex, 0, sizeof (struct dialog_ex));
 365               dialog.controls = NULL;
 366               sub_res_info = $3;
 367             }
 368             styles BEG controls END
 369           {
 370             define_dialog ($1, &sub_res_info, &dialog);
 371           }
 372         | id DIALOGEX memflags_move exstyle posnumexpr cnumexpr cnumexpr
 373             cnumexpr cnumexpr
 374             {
 375               memset (&dialog, 0, sizeof dialog);
 376               dialog.x = $5;
 377               dialog.y = $6;
 378               dialog.width = $7;
 379               dialog.height = $8;
 380               dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
 381               dialog.exstyle = $4;
 382               dialog.menu.named = 1;
 383               dialog.class.named = 1;
 384               dialog.font = NULL;
 385               dialog.ex = ((struct dialog_ex *)
 386                            res_alloc (sizeof (struct dialog_ex)));
 387               memset (dialog.ex, 0, sizeof (struct dialog_ex));
 388               dialog.ex->help = $9;
 389               dialog.controls = NULL;
 390               sub_res_info = $3;
 391             }
 392             styles BEG controls END
 393           {
 394             define_dialog ($1, &sub_res_info, &dialog);
 395           }
 396         ;
 397
 398 exstyle:
 399           /* empty */
 400           {
 401             $$ = 0;
 402           }
 403         | EXSTYLE '=' numexpr
 404           {
 405             $$ = $3;
 406           }
 407         ;
 408
 409 styles:
 410           /* empty */
 411         | styles CAPTION QUOTEDSTRING
 412           {
 413             unicode_from_ascii ((int *) NULL, &dialog.caption, $3);
 414           }
 415         | styles CLASS id
 416           {
 417             dialog.class = $3;
 418           }
 419         | styles STYLE
 420             { style = dialog.style; }
 421             styleexpr
 422           {
 423             dialog.style = style;
 424           }
 425         | styles EXSTYLE numexpr
 426           {
 427             dialog.exstyle = $3;
 428           }
 429         | styles FONT numexpr ',' QUOTEDSTRING
 430           {
 431             dialog.style |= DS_SETFONT;
 432             dialog.pointsize = $3;
 433             unicode_from_ascii ((int *) NULL, &dialog.font, $5);
 434           }
 435         | styles FONT numexpr ',' QUOTEDSTRING cnumexpr cnumexpr
 436           {
 437             dialog.style |= DS_SETFONT;
 438             dialog.pointsize = $3;
 439             unicode_from_ascii ((int *) NULL, &dialog.font, $5);
 440             if (dialog.ex == NULL)
 441               rcparse_warning (_("extended FONT requires DIALOGEX"));
 442             else
 443               {
 444                 dialog.ex->weight = $6;
 445                 dialog.ex->italic = $7;
 446               }
 447           }
 448         | styles MENU id
 449           {
 450             dialog.menu = $3;
 451           }
 452         | styles CHARACTERISTICS numexpr
 453           {
 454             sub_res_info.characteristics = $3;
 455           }
 456         | styles LANGUAGE numexpr cnumexpr
 457           {
 458             sub_res_info.language = $3 | ($4 << 8);
 459           }
 460         | styles VERSIONK numexpr
 461           {
 462             sub_res_info.version = $3;
 463           }
 464         ;
 465
 466 controls:
 467           /* empty */
 468         | controls control
 469           {
 470             struct dialog_control **pp;
 471
 472             for (pp = &dialog.controls; *pp != NULL; pp = &(*pp)->next)
 473               ;
 474             *pp = $2;
 475           }
 476         ;
 477
 478 control:
 479           AUTO3STATE
 480             {
 481               default_style = BS_AUTO3STATE | WS_TABSTOP;
 482               base_style = BS_AUTO3STATE;
 483               class = CTL_BUTTON;
 484             }
 485             control_params
 486           {
 487             $$ = $3;
 488           }
 489         | AUTOCHECKBOX
 490             {
 491               default_style = BS_AUTOCHECKBOX | WS_TABSTOP;
 492               base_style = BS_AUTOCHECKBOX;
 493               class = CTL_BUTTON;
 494             }
 495             control_params
 496           {
 497             $$ = $3;
 498           }
 499         | AUTORADIOBUTTON
 500             {
 501               default_style = BS_AUTORADIOBUTTON | WS_TABSTOP;
 502               base_style = BS_AUTORADIOBUTTON;
 503               class = CTL_BUTTON;
 504             }
 505             control_params
 506           {
 507             $$ = $3;
 508           }
 509         | BEDIT
 510             {
 511               default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 512               base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 513               class = CTL_EDIT;
 514             }
 515             control_params
 516           {
 517             $$ = $3;
 518             if (dialog.ex == NULL)
 519               rcparse_warning (_("IEDIT requires DIALOGEX"));
 520             res_string_to_id (&$$->class, "BEDIT");
 521           }
 522         | CHECKBOX
 523             {
 524               default_style = BS_CHECKBOX | WS_TABSTOP;
 525               base_style = BS_CHECKBOX | WS_TABSTOP;
 526               class = CTL_BUTTON;
 527             }
 528             control_params
 529           {
 530             $$ = $3;
 531           }
 532         | COMBOBOX
 533             {
 534               default_style = CBS_SIMPLE | WS_TABSTOP;
 535               base_style = 0;
 536               class = CTL_COMBOBOX;
 537             }
 538             control_params
 539           {
 540             $$ = $3;
 541           }
 542         | CONTROL optstringc numexpr cnumexpr control_styleexpr cnumexpr
 543             cnumexpr cnumexpr cnumexpr optcnumexpr opt_control_data
 544           {
 545             $$ = define_control ($2, $3, $6, $7, $8, $9, $4, style, $10);
 546             if ($11 != NULL)
 547               {
 548                 if (dialog.ex == NULL)
 549                   rcparse_warning (_("control data requires DIALOGEX"));
 550                 $$->data = $11;
 551               }
 552           }
 553         | CONTROL optstringc numexpr cnumexpr control_styleexpr cnumexpr
 554             cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr opt_control_data
 555           {
 556             $$ = define_control ($2, $3, $6, $7, $8, $9, $4, style, $10);
 557             if (dialog.ex == NULL)
 558               rcparse_warning (_("help ID requires DIALOGEX"));
 559             $$->help = $11;
 560             $$->data = $12;
 561           }
 562         | CONTROL optstringc numexpr ',' QUOTEDSTRING control_styleexpr
 563             cnumexpr cnumexpr cnumexpr cnumexpr optcnumexpr opt_control_data
 564           {
 565             $$ = define_control ($2, $3, $7, $8, $9, $10, 0, style, $11);
 566             if ($12 != NULL)
 567               {
 568                 if (dialog.ex == NULL)
 569                   rcparse_warning ("control data requires DIALOGEX");
 570                 $$->data = $12;
 571               }
 572             $$->class.named = 1;
 573             unicode_from_ascii(&$$->class.u.n.length, &$$->class.u.n.name, $5);
 574           }
 575         | CONTROL optstringc numexpr ',' QUOTEDSTRING control_styleexpr
 576             cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr opt_control_data
 577           {
 578             $$ = define_control ($2, $3, $7, $8, $9, $10, 0, style, $11);
 579             if (dialog.ex == NULL)
 580               rcparse_warning ("help ID requires DIALOGEX");
 581             $$->help = $12;
 582             $$->data = $13;
 583             $$->class.named = 1;
 584             unicode_from_ascii(&$$->class.u.n.length, &$$->class.u.n.name, $5);
 585           }
 586         | CTEXT
 587             {
 588               default_style = SS_CENTER | WS_GROUP;
 589               base_style = SS_CENTER;
 590               class = CTL_STATIC;
 591             }
 592             control_params
 593           {
 594             $$ = $3;
 595           }
 596         | DEFPUSHBUTTON
 597             {
 598               default_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
 599               base_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
 600               class = CTL_BUTTON;
 601             }
 602             control_params
 603           {
 604             $$ = $3;
 605           }
 606         | EDITTEXT
 607             {
 608               default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 609               base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 610               class = CTL_EDIT;
 611             }
 612             control_params
 613           {
 614             $$ = $3;
 615           }
 616         | GROUPBOX
 617             {
 618               default_style = BS_GROUPBOX;
 619               base_style = BS_GROUPBOX;
 620               class = CTL_BUTTON;
 621             }
 622             control_params
 623           {
 624             $$ = $3;
 625           }
 626         | HEDIT
 627             {
 628               default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 629               base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 630               class = CTL_EDIT;
 631             }
 632             control_params
 633           {
 634             $$ = $3;
 635             if (dialog.ex == NULL)
 636               rcparse_warning (_("IEDIT requires DIALOGEX"));
 637             res_string_to_id (&$$->class, "HEDIT");
 638           }
 639         | ICON id cnumexpr cnumexpr cnumexpr opt_control_data
 640           {
 641             $$ = define_icon_control ($2, $3, $4, $5, 0, 0, 0, $6,
 642                                       dialog.ex);
 643           }
 644         | ICON id cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr
 645             opt_control_data
 646           {
 647             $$ = define_icon_control ($2, $3, $4, $5, 0, 0, 0, $8,
 648                                       dialog.ex);
 649           }
 650         | ICON id cnumexpr cnumexpr cnumexpr cnumexpr cnumexpr
 651             icon_styleexpr optcnumexpr opt_control_data
 652           {
 653             $$ = define_icon_control ($2, $3, $4, $5, style, $9, 0, $10,
 654                                       dialog.ex);
 655           }
 656         | ICON id numexpr cnumexpr cnumexpr cnumexpr cnumexpr
 657             icon_styleexpr cnumexpr cnumexpr opt_control_data
 658           {
 659             $$ = define_icon_control ($2, $3, $4, $5, style, $9, $10, $11,
 660                                       dialog.ex);
 661           }
 662         | IEDIT
 663             {
 664               default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 665               base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
 666               class = CTL_EDIT;
 667             }
 668             control_params
 669           {
 670             $$ = $3;
 671             if (dialog.ex == NULL)
 672               rcparse_warning (_("IEDIT requires DIALOGEX"));
 673             res_string_to_id (&$$->class, "IEDIT");
 674           }
 675         | LISTBOX
 676             {
 677               default_style = LBS_NOTIFY | WS_BORDER;
 678               base_style = LBS_NOTIFY | WS_BORDER;
 679               class = CTL_LISTBOX;
 680             }
 681             control_params
 682           {
 683             $$ = $3;
 684           }
 685         | LTEXT
 686             {
 687               default_style = SS_LEFT | WS_GROUP;
 688               base_style = SS_LEFT;
 689               class = CTL_STATIC;
 690             }
 691             control_params
 692           {
 693             $$ = $3;
 694           }
 695         | PUSHBOX
 696             {
 697               default_style = BS_PUSHBOX | WS_TABSTOP;
 698               base_style = BS_PUSHBOX;
 699               class = CTL_BUTTON;
 700             }
 701             control_params
 702           {
 703             $$ = $3;
 704           }
 705         | PUSHBUTTON
 706             {
 707               default_style = BS_PUSHBUTTON | WS_TABSTOP;
 708               base_style = BS_PUSHBUTTON | WS_TABSTOP;
 709               class = CTL_BUTTON;
 710             }
 711             control_params
 712           {
 713             $$ = $3;
 714           }
 715         | RADIOBUTTON
 716             {
 717               default_style = BS_RADIOBUTTON | WS_TABSTOP;
 718               base_style = BS_RADIOBUTTON;
 719               class = CTL_BUTTON;
 720             }
 721             control_params
 722           {
 723             $$ = $3;
 724           }
 725         | RTEXT
 726             {
 727               default_style = SS_RIGHT | WS_GROUP;
 728               base_style = SS_RIGHT;
 729               class = CTL_STATIC;
 730             }
 731             control_params
 732           {
 733             $$ = $3;
 734           }
 735         | SCROLLBAR
 736             {
 737               default_style = SBS_HORZ;
 738               base_style = 0;
 739               class = CTL_SCROLLBAR;
 740             }
 741             control_params
 742           {
 743             $$ = $3;
 744           }
 745         | STATE3
 746             {
 747               default_style = BS_3STATE | WS_TABSTOP;
 748               base_style = BS_3STATE;
 749               class = CTL_BUTTON;
 750             }
 751             control_params
 752           {
 753             $$ = $3;
 754           }
 755         | USERBUTTON QUOTEDSTRING ',' numexpr ',' numexpr ',' numexpr ','
 756             numexpr ',' numexpr ','
 757             { style = WS_CHILD | WS_VISIBLE; }
 758             styleexpr optcnumexpr
 759           {
 760             $$ = define_control ($2, $4, $6, $8, $10, $12, CTL_BUTTON,
 761                                  style, $16);
 762           }
 763         ;
 764
 765 /* Parameters for a control.  The static variables DEFAULT_STYLE,
 766    BASE_STYLE, and CLASS must be initialized before this nonterminal
 767    is used.  DEFAULT_STYLE is the style to use if no style expression
 768    is specified.  BASE_STYLE is the base style to use if a style
 769    expression is specified; the style expression modifies the base
 770    style.  CLASS is the class of the control.  */
 771
 772 control_params:
 773           optstringc numexpr cnumexpr cnumexpr cnumexpr cnumexpr
 774             opt_control_data
 775           {
 776             $$ = define_control ($1, $2, $3, $4, $5, $6, class,
 777                                  default_style | WS_CHILD | WS_VISIBLE, 0);
 778             if ($7 != NULL)
 779               {
 780                 if (dialog.ex == NULL)
 781                   rcparse_warning (_("control data requires DIALOGEX"));
 782                 $$->data = $7;
 783               }
 784           }
 785         | optstringc numexpr cnumexpr cnumexpr cnumexpr cnumexpr
 786             control_params_styleexpr optcnumexpr opt_control_data
 787           {
 788             $$ = define_control ($1, $2, $3, $4, $5, $6, class, style, $8);
 789             if ($9 != NULL)
 790               {
 791                 if (dialog.ex == NULL)
 792                   rcparse_warning (_("control data requires DIALOGEX"));
 793                 $$->data = $9;
 794               }
 795           }
 796         | optstringc numexpr cnumexpr cnumexpr cnumexpr cnumexpr
 797             control_params_styleexpr cnumexpr cnumexpr opt_control_data
 798           {
 799             $$ = define_control ($1, $2, $3, $4, $5, $6, class, style, $8);
 800             if (dialog.ex == NULL)
 801               rcparse_warning (_("help ID requires DIALOGEX"));
 802             $$->help = $9;
 803             $$->data = $10;
 804           }
 805         ;
 806
 807 optstringc:
 808           /* empty */
 809           {
 810             $$ = NULL;
 811           }
 812         | QUOTEDSTRING ','
 813           {
 814             $$ = $1;
 815           }
 816         ;
 817
 818 opt_control_data:
 819           /* empty */
 820           {
 821             $$ = NULL;
 822           }
 823         | BEG optrcdata_data END
 824           {
 825             $$ = $2.first;
 826           }
 827         ;
 828
 829 /* These only exist to parse a reduction out of a common case.  */
 830
 831 control_styleexpr:
 832           ','
 833           { style = WS_CHILD | WS_VISIBLE; }
 834           styleexpr
 835         ;
 836
 837 icon_styleexpr:
 838           ','
 839           { style = SS_ICON | WS_CHILD | WS_VISIBLE; }
 840           styleexpr
 841         ;
 842
 843 control_params_styleexpr:
 844           ','
 845           { style = base_style | WS_CHILD | WS_VISIBLE; }
 846           styleexpr
 847         ;
 848
 849 /* Font resources.  */
 850
 851 font:
 852           id FONT memflags_move_discard file_name
 853           {
 854             define_font ($1, &$3, $4);
 855           }
 856         ;
 857
 858 /* Icon resources.  */
 859
 860 icon:
 861           id ICON memflags_move_discard file_name
 862           {
 863             define_icon ($1, &$3, $4);
 864           }
 865         ;
 866
 867 /* Language command.  This changes the static variable language, which
 868    affects all subsequent resources.  */
 869
 870 language:
 871           LANGUAGE numexpr cnumexpr
 872           {
 873             language = $2 | ($3 << 8);
 874           }
 875         ;
 876
 877 /* Menu resources.  */
 878
 879 menu:
 880           id MENU suboptions BEG menuitems END
 881           {
 882             define_menu ($1, &$3, $5);
 883           }
 884         ;
 885
 886 menuitems:
 887           /* empty */
 888           {
 889             $$ = NULL;
 890           }
 891         | menuitems menuitem
 892           {
 893             if ($1 == NULL)
 894               $$ = $2;
 895             else
 896               {
 897                 struct menuitem **pp;
 898
 899                 for (pp = &$1->next; *pp != NULL; pp = &(*pp)->next)
 900                   ;
 901                 *pp = $2;
 902                 $$ = $1;
 903               }
 904           }
 905         ;
 906
 907 menuitem:
 908           MENUITEM QUOTEDSTRING cnumexpr menuitem_flags
 909           {
 910             $$ = define_menuitem ($2, $3, $4, 0, 0, NULL);
 911           }
 912         | MENUITEM SEPARATOR
 913           {
 914             $$ = define_menuitem (NULL, 0, 0, 0, 0, NULL);
 915           }
 916         | POPUP QUOTEDSTRING menuitem_flags BEG menuitems END
 917           {
 918             $$ = define_menuitem ($2, 0, $3, 0, 0, $5);
 919           }
 920         ;
 921
 922 menuitem_flags:
 923           /* empty */
 924           {
 925             $$ = 0;
 926           }
 927         | menuitem_flags ',' menuitem_flag
 928           {
 929             $$ = $1 | $3;
 930           }
 931         | menuitem_flags menuitem_flag
 932           {
 933             $$ = $1 | $2;
 934           }
 935         ;
 936
 937 menuitem_flag:
 938           CHECKED
 939           {
 940             $$ = MENUITEM_CHECKED;
 941           }
 942         | GRAYED
 943           {
 944             $$ = MENUITEM_GRAYED;
 945           }
 946         | HELP
 947           {
 948             $$ = MENUITEM_HELP;
 949           }
 950         | INACTIVE
 951           {
 952             $$ = MENUITEM_INACTIVE;
 953           }
 954         | MENUBARBREAK
 955           {
 956             $$ = MENUITEM_MENUBARBREAK;
 957           }
 958         | MENUBREAK
 959           {
 960             $$ = MENUITEM_MENUBREAK;
 961           }
 962         ;
 963
 964 /* Menuex resources.  */
 965
 966 menuex:
 967           id MENUEX suboptions BEG menuexitems END
 968           {
 969             define_menu ($1, &$3, $5);
 970           }
 971         ;
 972
 973 menuexitems:
 974           /* empty */
 975           {
 976             $$ = NULL;
 977           }
 978         | menuexitems menuexitem
 979           {
 980             if ($1 == NULL)
 981               $$ = $2;
 982             else
 983               {
 984                 struct menuitem **pp;
 985
 986                 for (pp = &$1->next; *pp != NULL; pp = &(*pp)->next)
 987                   ;
 988                 *pp = $2;
 989                 $$ = $1;
 990               }
 991           }
 992         ;
 993
 994 menuexitem:
 995           MENUITEM QUOTEDSTRING
 996           {
 997             $$ = define_menuitem ($2, 0, 0, 0, 0, NULL);
 998           }
 999         | MENUITEM QUOTEDSTRING cnumexpr
1000           {
1001             $$ = define_menuitem ($2, $3, 0, 0, 0, NULL);
1002           }
1003         | MENUITEM QUOTEDSTRING cnumexpr cnumexpr optcnumexpr
1004           {
1005             $$ = define_menuitem ($2, $3, $4, $5, 0, NULL);
1006           }
1007         | MENUITEM SEPARATOR
1008           {
1009             $$ = define_menuitem (NULL, 0, 0, 0, 0, NULL);
1010           }
1011         | POPUP QUOTEDSTRING BEG menuexitems END
1012           {
1013             $$ = define_menuitem ($2, 0, 0, 0, 0, $4);
1014           }
1015         | POPUP QUOTEDSTRING cnumexpr BEG menuexitems END
1016           {
1017             $$ = define_menuitem ($2, $3, 0, 0, 0, $5);
1018           }
1019         | POPUP QUOTEDSTRING cnumexpr cnumexpr BEG menuexitems END
1020           {
1021             $$ = define_menuitem ($2, $3, $4, 0, 0, $6);
1022           }
1023         | POPUP QUOTEDSTRING cnumexpr cnumexpr cnumexpr optcnumexpr
1024             BEG menuexitems END
1025           {
1026             $$ = define_menuitem ($2, $3, $4, $5, $6, $8);
1027           }
1028         ;
1029
1030 /* Messagetable resources.  */
1031
1032 messagetable:
1033           id MESSAGETABLE memflags_move file_name
1034           {
1035             define_messagetable ($1, &$3, $4);
1036           }
1037         ;
1038
1039 /* Rcdata resources.  */
1040
1041 rcdata:
1042           id RCDATA suboptions BEG optrcdata_data END
1043           {
1044             define_rcdata ($1, &$3, $5.first);
1045           }
1046         ;
1047
1048 /* We use a different lexing algorithm, because rcdata strings may
1049    contain embedded null bytes, and we need to know the length to use.  */
1050
1051 optrcdata_data:
1052           {
1053             rcparse_rcdata ();
1054           }
1055           optrcdata_data_int
1056           {
1057             rcparse_normal ();
1058             $$ = $2;
1059           }
1060         ;
1061
1062 optrcdata_data_int:
1063           /* empty */
1064           {
1065             $$.first = NULL;
1066             $$.last = NULL;
1067           }
1068         | rcdata_data
1069           {
1070             $$ = $1;
1071           }
1072         ;
1073
1074 rcdata_data:
1075           SIZEDSTRING
1076           {
1077             struct rcdata_item *ri;
1078
1079             ri = define_rcdata_string ($1.s, $1.length);
1080             $$.first = ri;
1081             $$.last = ri;
1082           }
1083         | sizednumexpr
1084           {
1085             struct rcdata_item *ri;
1086
1087             ri = define_rcdata_number ($1.val, $1.dword);
1088             $$.first = ri;
1089             $$.last = ri;
1090           }
1091         | rcdata_data ',' SIZEDSTRING
1092           {
1093             struct rcdata_item *ri;
1094
1095             ri = define_rcdata_string ($3.s, $3.length);
1096             $$.first = $1.first;
1097             $1.last->next = ri;
1098             $$.last = ri;
1099           }
1100         | rcdata_data ',' sizednumexpr
1101           {
1102             struct rcdata_item *ri;
1103
1104             ri = define_rcdata_number ($3.val, $3.dword);
1105             $$.first = $1.first;
1106             $1.last->next = ri;
1107             $$.last = ri;
1108           }
1109         ;
1110
1111 /* Stringtable resources.  */
1112
1113 stringtable:
1114           STRINGTABLE suboptions BEG
1115             { sub_res_info = $2; }
1116             string_data END
1117         ;
1118
1119 string_data:
1120           /* empty */
1121         | string_data numexpr QUOTEDSTRING
1122           {
1123             define_stringtable (&sub_res_info, $2, $3);
1124           }
1125         | string_data numexpr ',' QUOTEDSTRING
1126           {
1127             define_stringtable (&sub_res_info, $2, $4);
1128           }
1129         ;
1130
1131 /* User defined resources.  We accept general suboptions in the
1132    file_name case to keep the parser happy.  */
1133
1134 user:
1135           id id suboptions BEG optrcdata_data END
1136           {
1137             define_user_data ($1, $2, &$3, $5.first);
1138           }
1139         | id id suboptions file_name
1140           {
1141             define_user_file ($1, $2, &$3, $4);
1142           }
1143         ;
1144
1145 /* Versioninfo resources.  */
1146
1147 versioninfo:
1148           id VERSIONINFO fixedverinfo BEG verblocks END
1149           {
1150             define_versioninfo ($1, language, $3, $5);
1151           }
1152         ;
1153
1154 fixedverinfo:
1155           /* empty */
1156           {
1157             $$ = ((struct fixed_versioninfo *)
1158                   res_alloc (sizeof (struct fixed_versioninfo)));
1159             memset ($$, 0, sizeof (struct fixed_versioninfo));
1160           }
1161         | fixedverinfo FILEVERSION numexpr cnumexpr cnumexpr cnumexpr
1162           {
1163             $1->file_version_ms = ($3 << 16) | $4;
1164             $1->file_version_ls = ($5 << 16) | $6;
1165             $$ = $1;
1166           }
1167         | fixedverinfo PRODUCTVERSION numexpr cnumexpr cnumexpr cnumexpr
1168           {
1169             $1->product_version_ms = ($3 << 16) | $4;
1170             $1->product_version_ls = ($5 << 16) | $6;
1171             $$ = $1;
1172           }
1173         | fixedverinfo FILEFLAGSMASK numexpr
1174           {
1175             $1->file_flags_mask = $3;
1176             $$ = $1;
1177           }
1178         | fixedverinfo FILEFLAGS numexpr
1179           {
1180             $1->file_flags = $3;
1181             $$ = $1;
1182           }
1183         | fixedverinfo FILEOS numexpr
1184           {
1185             $1->file_os = $3;
1186             $$ = $1;
1187           }
1188         | fixedverinfo FILETYPE numexpr
1189           {
1190             $1->file_type = $3;
1191             $$ = $1;
1192           }
1193         | fixedverinfo FILESUBTYPE numexpr
1194           {
1195             $1->file_subtype = $3;
1196             $$ = $1;
1197           }
1198         ;
1199
1200 /* To handle verblocks successfully, the lexer handles BLOCK
1201    specially.  A BLOCK "StringFileInfo" is returned as
1202    BLOCKSTRINGFILEINFO.  A BLOCK "VarFileInfo" is returned as
1203    BLOCKVARFILEINFO.  A BLOCK with some other string returns BLOCK
1204    with the string as the value.  */
1205
1206 verblocks:
1207           /* empty */
1208           {
1209             $$ = NULL;
1210           }
1211         | verblocks BLOCKSTRINGFILEINFO BEG BLOCK BEG vervals END END
1212           {
1213             $$ = append_ver_stringfileinfo ($1, $4, $6);
1214           }
1215         | verblocks BLOCKVARFILEINFO BEG VALUE QUOTEDSTRING vertrans END
1216           {
1217             $$ = append_ver_varfileinfo ($1, $5, $6);
1218           }
1219         ;
1220
1221 vervals:
1222           /* empty */
1223           {
1224             $$ = NULL;
1225           }
1226         | vervals VALUE QUOTEDSTRING ',' QUOTEDSTRING
1227           {
1228             $$ = append_verval ($1, $3, $5);
1229           }
1230         ;
1231
1232 vertrans:
1233           /* empty */
1234           {
1235             $$ = NULL;
1236           }
1237         | vertrans cnumexpr cnumexpr
1238           {
1239             $$ = append_vertrans ($1, $2, $3);
1240           }
1241         ;
1242
1243 /* A resource ID.  */
1244
1245 id:
1246           posnumexpr
1247           {
1248             $$.named = 0;
1249             $$.u.id = $1;
1250           }
1251         | STRING
1252           {
1253             char *copy, *s;
1254
1255             /* It seems that resource ID's are forced to upper case.  */
1256             copy = xstrdup ($1);
1257             for (s = copy; *s != '\0'; s++)
1258               if (islower ((unsigned char) *s))
1259                 *s = toupper ((unsigned char) *s);
1260             res_string_to_id (&$$, copy);
1261             free (copy);
1262           }
1263         ;
1264
1265 /* Generic suboptions.  These may appear before the BEGIN in any
1266    multiline statement.  */
1267
1268 suboptions:
1269           /* empty */
1270           {
1271             memset (&$$, 0, sizeof (struct res_res_info));
1272             $$.language = language;
1273             /* FIXME: Is this the right default?  */
1274             $$.memflags = MEMFLAG_MOVEABLE;
1275           }
1276         | suboptions memflag
1277           {
1278             $$ = $1;
1279             $$.memflags |= $2.on;
1280             $$.memflags &=~ $2.off;
1281           }
1282         | suboptions CHARACTERISTICS numexpr
1283           {
1284             $$ = $1;
1285             $$.characteristics = $3;
1286           }
1287         | suboptions LANGUAGE numexpr cnumexpr
1288           {
1289             $$ = $1;
1290             $$.language = $3 | ($4 << 8);
1291           }
1292         | suboptions VERSIONK numexpr
1293           {
1294             $$ = $1;
1295             $$.version = $3;
1296           }
1297         ;
1298
1299 /* Memory flags which default to MOVEABLE and DISCARDABLE.  */
1300
1301 memflags_move_discard:
1302           /* empty */
1303           {
1304             memset (&$$, 0, sizeof (struct res_res_info));
1305             $$.language = language;
1306             $$.memflags = MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE;
1307           }
1308         | memflags_move_discard memflag
1309           {
1310             $$ = $1;
1311             $$.memflags |= $2.on;
1312             $$.memflags &=~ $2.off;
1313           }
1314         ;
1315
1316 /* Memory flags which default to MOVEABLE.  */
1317
1318 memflags_move:
1319           /* empty */
1320           {
1321             memset (&$$, 0, sizeof (struct res_res_info));
1322             $$.language = language;
1323             $$.memflags = MEMFLAG_MOVEABLE;
1324           }
1325         | memflags_move memflag
1326           {
1327             $$ = $1;
1328             $$.memflags |= $2.on;
1329             $$.memflags &=~ $2.off;
1330           }
1331         ;
1332
1333 /* Memory flags.  This returns a struct with two integers, because we
1334    sometimes want to set bits and we sometimes want to clear them.  */
1335
1336 memflag:
1337           MOVEABLE
1338           {
1339             $$.on = MEMFLAG_MOVEABLE;
1340             $$.off = 0;
1341           }
1342         | FIXED
1343           {
1344             $$.on = 0;
1345             $$.off = MEMFLAG_MOVEABLE;
1346           }
1347         | PURE
1348           {
1349             $$.on = MEMFLAG_PURE;
1350             $$.off = 0;
1351           }
1352         | IMPURE
1353           {
1354             $$.on = 0;
1355             $$.off = MEMFLAG_PURE;
1356           }
1357         | PRELOAD
1358           {
1359             $$.on = MEMFLAG_PRELOAD;
1360             $$.off = 0;
1361           }
1362         | LOADONCALL
1363           {
1364             $$.on = 0;
1365             $$.off = MEMFLAG_PRELOAD;
1366           }
1367         | DISCARDABLE
1368           {
1369             $$.on = MEMFLAG_DISCARDABLE;
1370             $$.off = 0;
1371           }
1372         ;
1373
1374 /* A file name.  */
1375
1376 file_name:
1377           QUOTEDSTRING
1378           {
1379             $$ = $1;
1380           }
1381         | STRING
1382           {
1383             $$ = $1;
1384           }
1385         ;
1386
1387 /* A style expression.  This changes the static variable STYLE.  We do
1388    it this way because rc appears to permit a style to be set to
1389    something like
1390        WS_GROUP | NOT WS_TABSTOP
1391    to mean that a default of WS_TABSTOP should be removed.  Anything
1392    which wants to accept a style must first set STYLE to the default
1393    value.  The styleexpr nonterminal will change STYLE as specified by
1394    the user.  Note that we do not accept arbitrary expressions here,
1395    just numbers separated by '|'.  */
1396
1397 styleexpr:
1398           parennumber
1399           {
1400             style |= $1;
1401           }
1402         | NOT parennumber
1403           {
1404             style &=~ $2;
1405           }
1406         | styleexpr '|' parennumber
1407           {
1408             style |= $3;
1409           }
1410         | styleexpr '|' NOT parennumber
1411           {
1412             style &=~ $4;
1413           }
1414         ;
1415
1416 parennumber:
1417           NUMBER
1418           {
1419             $$ = $1.val;
1420           }
1421         | '(' numexpr ')'
1422           {
1423             $$ = $2;
1424           }
1425         ;
1426
1427 /* An optional expression with a leading comma.  */
1428
1429 optcnumexpr:
1430           /* empty */
1431           {
1432             $$ = 0;
1433           }
1434         | cnumexpr
1435           {
1436             $$ = $1;
1437           }
1438         ;
1439
1440 /* An expression with a leading comma.  */
1441
1442 cnumexpr:
1443           ',' numexpr
1444           {
1445             $$ = $2;
1446           }
1447         ;
1448
1449 /* A possibly negated numeric expression.  */
1450
1451 numexpr:
1452           sizednumexpr
1453           {
1454             $$ = $1.val;
1455           }
1456         ;
1457
1458 /* A possibly negated expression with a size.  */
1459
1460 sizednumexpr:
1461           NUMBER
1462           {
1463             $$ = $1;
1464           }
1465         | '(' sizednumexpr ')'
1466           {
1467             $$ = $2;
1468           }
1469         | '~' sizednumexpr %prec '~'
1470           {
1471             $$.val = ~ $2.val;
1472             $$.dword = $2.dword;
1473           }
1474         | '-' sizednumexpr %prec NEG
1475           {
1476             $$.val = - $2.val;
1477             $$.dword = $2.dword;
1478           }
1479         | sizednumexpr '*' sizednumexpr
1480           {
1481             $$.val = $1.val * $3.val;
1482             $$.dword = $1.dword || $3.dword;
1483           }
1484         | sizednumexpr '/' sizednumexpr
1485           {
1486             $$.val = $1.val / $3.val;
1487             $$.dword = $1.dword || $3.dword;
1488           }
1489         | sizednumexpr '%' sizednumexpr
1490           {
1491             $$.val = $1.val % $3.val;
1492             $$.dword = $1.dword || $3.dword;
1493           }
1494         | sizednumexpr '+' sizednumexpr
1495           {
1496             $$.val = $1.val + $3.val;
1497             $$.dword = $1.dword || $3.dword;
1498           }
1499         | sizednumexpr '-' sizednumexpr
1500           {
1501             $$.val = $1.val - $3.val;
1502             $$.dword = $1.dword || $3.dword;
1503           }
1504         | sizednumexpr '&' sizednumexpr
1505           {
1506             $$.val = $1.val & $3.val;
1507             $$.dword = $1.dword || $3.dword;
1508           }
1509         | sizednumexpr '^' sizednumexpr
1510           {
1511             $$.val = $1.val ^ $3.val;
1512             $$.dword = $1.dword || $3.dword;
1513           }
1514         | sizednumexpr '|' sizednumexpr
1515           {
1516             $$.val = $1.val | $3.val;
1517             $$.dword = $1.dword || $3.dword;
1518           }
1519         ;
1520
1521 /* An expression with a leading comma which does not use unary
1522    negation.  */
1523
1524 cposnumexpr:
1525           ',' posnumexpr
1526           {
1527             $$ = $2;
1528           }
1529         ;
1530
1531 /* An expression which does not use unary negation.  */
1532
1533 posnumexpr:
1534           sizedposnumexpr
1535           {
1536             $$ = $1.val;
1537           }
1538         ;
1539
1540 /* An expression which does not use unary negation.  We separate unary
1541    negation to avoid parsing conflicts when two numeric expressions
1542    appear consecutively.  */
1543
1544 sizedposnumexpr:
1545           NUMBER
1546           {
1547             $$ = $1;
1548           }
1549         | '(' sizednumexpr ')'
1550           {
1551             $$ = $2;
1552           }
1553         | '~' sizednumexpr %prec '~'
1554           {
1555             $$.val = ~ $2.val;
1556             $$.dword = $2.dword;
1557           }
1558         | sizedposnumexpr '*' sizednumexpr
1559           {
1560             $$.val = $1.val * $3.val;
1561             $$.dword = $1.dword || $3.dword;
1562           }
1563         | sizedposnumexpr '/' sizednumexpr
1564           {
1565             $$.val = $1.val / $3.val;
1566             $$.dword = $1.dword || $3.dword;
1567           }
1568         | sizedposnumexpr '%' sizednumexpr
1569           {
1570             $$.val = $1.val % $3.val;
1571             $$.dword = $1.dword || $3.dword;
1572           }
1573         | sizedposnumexpr '+' sizednumexpr
1574           {
1575             $$.val = $1.val + $3.val;
1576             $$.dword = $1.dword || $3.dword;
1577           }
1578         | sizedposnumexpr '-' sizednumexpr
1579           {
1580             $$.val = $1.val - $3.val;
1581             $$.dword = $1.dword || $3.dword;
1582           }
1583         | sizedposnumexpr '&' sizednumexpr
1584           {
1585             $$.val = $1.val & $3.val;
1586             $$.dword = $1.dword || $3.dword;
1587           }
1588         | sizedposnumexpr '^' sizednumexpr
1589           {
1590             $$.val = $1.val ^ $3.val;
1591             $$.dword = $1.dword || $3.dword;
1592           }
1593         | sizedposnumexpr '|' sizednumexpr
1594           {
1595             $$.val = $1.val | $3.val;
1596             $$.dword = $1.dword || $3.dword;
1597           }
1598         ;
1599
1600 %%
1601
1602 /* Set the language from the command line.  */
1603
1604 void
1605 rcparse_set_language (lang)
1606      int lang;
1607 {
1608   language = lang;
1609 }