binutils/rclex.l

   1 %{ /* rclex.l -- lexer for Windows rc files parser  */
   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 lex input file which generates a lexer used by the
  23    Windows rc file parser.  It basically just recognized a bunch of
  24    keywords.  */
  25
  26 #include "bfd.h"
  27 #include "bucomm.h"
  28 #include "libiberty.h"
  29 #include "windres.h"
  30 #include "rcparse.h"
  31
  32 #include <ctype.h>
  33 #include <assert.h>
  34
  35 /* Whether we are in rcdata mode, in which we returns the lengths of
  36    strings.  */
  37
  38 static int rcdata_mode;
  39
  40 /* List of allocated strings.  */
  41
  42 struct alloc_string
  43 {
  44   struct alloc_string *next;
  45   char *s;
  46 };
  47
  48 static struct alloc_string *strings;
  49
  50 /* Local functions.  */
  51
  52 static void cpp_line PARAMS ((const char *));
  53 static char *handle_quotes PARAMS ((const char *, unsigned long *));
  54 static char *get_string PARAMS ((int));
  55
  56 %}
  57
  58 %%
  59
  60 "BEGIN"                 { return BEG; }
  61 "{"                     { return BEG; }
  62 "END"                   { return END; }
  63 "}"                     { return END; }
  64 "ACCELERATORS"          { return ACCELERATORS; }
  65 "VIRTKEY"               { return VIRTKEY; }
  66 "ASCII"                 { return ASCII; }
  67 "NOINVERT"              { return NOINVERT; }
  68 "SHIFT"                 { return SHIFT; }
  69 "CONTROL"               { return CONTROL; }
  70 "ALT"                   { return ALT; }
  71 "BITMAP"                { return BITMAP; }
  72 "CURSOR"                { return CURSOR; }
  73 "DIALOG"                { return DIALOG; }
  74 "DIALOGEX"              { return DIALOGEX; }
  75 "EXSTYLE"               { return EXSTYLE; }
  76 "CAPTION"               { return CAPTION; }
  77 "CLASS"                 { return CLASS; }
  78 "STYLE"                 { return STYLE; }
  79 "AUTO3STATE"            { return AUTO3STATE; }
  80 "AUTOCHECKBOX"          { return AUTOCHECKBOX; }
  81 "AUTORADIOBUTTON"       { return AUTORADIOBUTTON; }
  82 "CHECKBOX"              { return CHECKBOX; }
  83 "COMBOBOX"              { return COMBOBOX; }
  84 "CTEXT"                 { return CTEXT; }
  85 "DEFPUSHBUTTON"         { return DEFPUSHBUTTON; }
  86 "EDITTEXT"              { return EDITTEXT; }
  87 "GROUPBOX"              { return GROUPBOX; }
  88 "LISTBOX"               { return LISTBOX; }
  89 "LTEXT"                 { return LTEXT; }
  90 "PUSHBOX"               { return PUSHBOX; }
  91 "PUSHBUTTON"            { return PUSHBUTTON; }
  92 "RADIOBUTTON"           { return RADIOBUTTON; }
  93 "RTEXT"                 { return RTEXT; }
  94 "SCROLLBAR"             { return SCROLLBAR; }
  95 "STATE3"                { return STATE3; }
  96 "USERBUTTON"            { return USERBUTTON; }
  97 "BEDIT"                 { return BEDIT; }
  98 "HEDIT"                 { return HEDIT; }
  99 "IEDIT"                 { return IEDIT; }
 100 "FONT"                  { return FONT; }
 101 "ICON"                  { return ICON; }
 102 "LANGUAGE"              { return LANGUAGE; }
 103 "CHARACTERISTICS"       { return CHARACTERISTICS; }
 104 "VERSION"               { return VERSIONK; }
 105 "MENU"                  { return MENU; }
 106 "MENUEX"                { return MENUEX; }
 107 "MENUITEM"              { return MENUITEM; }
 108 "SEPARATOR"             { return SEPARATOR; }
 109 "POPUP"                 { return POPUP; }
 110 "CHECKED"               { return CHECKED; }
 111 "GRAYED"                { return GRAYED; }
 112 "HELP"                  { return HELP; }
 113 "INACTIVE"              { return INACTIVE; }
 114 "MENUBARBREAK"          { return MENUBARBREAK; }
 115 "MENUBREAK"             { return MENUBREAK; }
 116 "MESSAGETABLE"          { return MESSAGETABLE; }
 117 "RCDATA"                { return RCDATA; }
 118 "STRINGTABLE"           { return STRINGTABLE; }
 119 "VERSIONINFO"           { return VERSIONINFO; }
 120 "FILEVERSION"           { return FILEVERSION; }
 121 "PRODUCTVERSION"        { return PRODUCTVERSION; }
 122 "FILEFLAGSMASK"         { return FILEFLAGSMASK; }
 123 "FILEFLAGS"             { return FILEFLAGS; }
 124 "FILEOS"                { return FILEOS; }
 125 "FILETYPE"              { return FILETYPE; }
 126 "FILESUBTYPE"           { return FILESUBTYPE; }
 127 "VALUE"                 { return VALUE; }
 128 "MOVEABLE"              { return MOVEABLE; }
 129 "FIXED"                 { return FIXED; }
 130 "PURE"                  { return PURE; }
 131 "IMPURE"                { return IMPURE; }
 132 "PRELOAD"               { return PRELOAD; }
 133 "LOADONCALL"            { return LOADONCALL; }
 134 "DISCARDABLE"           { return DISCARDABLE; }
 135 "NOT"                   { return NOT; }
 136
 137 "BLOCK"[ \t\n]*"\""[^\#\n]*"\"" {
 138                           char *s, *send;
 139
 140                           /* This is a hack to let us parse version
 141                              information easily.  */
 142
 143                           s = strchr (yytext, '"');
 144                           ++s;
 145                           send = strchr (s, '"');
 146                           if (strncmp (s, "StringFileInfo",
 147                                        sizeof "StringFileInfo" - 1) == 0
 148                               && s + sizeof "StringFileInfo" - 1 == send)
 149                             return BLOCKSTRINGFILEINFO;
 150                           else if (strncmp (s, "VarFileInfo",
 151                                             sizeof "VarFileInfo" - 1) == 0
 152                                    && s + sizeof "VarFileInfo" - 1 == send)
 153                             return BLOCKVARFILEINFO;
 154                           else
 155                             {
 156                               char *r;
 157
 158                               r = get_string (send - s + 1);
 159                               strncpy (r, s, send - s);
 160                               r[send - s] = '\0';
 161                               yylval.s = r;
 162                               return BLOCK;
 163                             }
 164                         }
 165
 166 "#"[^\n]*               {
 167                           cpp_line (yytext);
 168                         }
 169
 170 [0-9][x0-9A-Fa-f]*L     {
 171                           yylval.i.val = strtoul (yytext, 0, 0);
 172                           yylval.i.dword = 1;
 173                           return NUMBER;
 174                         }
 175
 176 [0-9][x0-9A-Fa-f]*      {
 177                           yylval.i.val = strtoul (yytext, 0, 0);
 178                           yylval.i.dword = 0;
 179                           return NUMBER;
 180                         }
 181
 182 ("\""[^\"\n]*"\""[ \t]*)+ {
 183                           char *s;
 184                           unsigned long length;
 185
 186                           s = handle_quotes (yytext, &length);
 187                           if (! rcdata_mode)
 188                             {
 189                               yylval.s = s;
 190                               return QUOTEDSTRING;
 191                             }
 192                           else
 193                             {
 194                               yylval.ss.length = length;
 195                               yylval.ss.s = s;
 196                               return SIZEDSTRING;
 197                             }
 198                         }
 199
 200 [A-Za-z][^ ,\t\r\n]*    {
 201                           char *s;
 202
 203                           /* I rejected comma in a string in order to
 204                              handle VIRTKEY, CONTROL in an accelerator
 205                              resource.  This means that an unquoted
 206                              file name can not contain a comma.  I
 207                              don't know what rc permits.  */
 208
 209                           s = get_string (strlen (yytext) + 1);
 210                           strcpy (s, yytext);
 211                           yylval.s = s;
 212                           return STRING;
 213                         }
 214
 215 [\n]                    { ++rc_lineno; }
 216 [ \t\r]+                { /* ignore whitespace */ }
 217 .                       { return *yytext; }
 218
 219 %%
 220 #ifndef yywrap
 221 /* This is needed for some versions of lex.  */
 222 int yywrap ()
 223 {
 224   return 1;
 225 }
 226 #endif
 227
 228 /* Handle a C preprocessor line.  */
 229
 230 static void
 231 cpp_line (s)
 232      const char *s;
 233 {
 234   int line;
 235   char *send, *fn;
 236
 237   ++s;
 238   while (isspace ((unsigned char) *s))
 239     ++s;
 240
 241   line = strtol (s, &send, 0);
 242   if (*send != '\0' && ! isspace ((unsigned char) *send))
 243     return;
 244
 245   /* Subtract 1 because we are about to count the newline.  */
 246   rc_lineno = line - 1;
 247
 248   s = send;
 249   while (isspace ((unsigned char) *s))
 250     ++s;
 251
 252   if (*s != '"')
 253     return;
 254
 255   ++s;
 256   send = strchr (s, '"');
 257   if (send == NULL)
 258     return;
 259
 260   fn = (char *) xmalloc (send - s + 1);
 261   strncpy (fn, s, send - s);
 262   fn[send - s] = '\0';
 263
 264   free (rc_filename);
 265   rc_filename = fn;
 266 }
 267
 268 /* Handle a quoted string.  The quotes are stripped.  A pair of quotes
 269    in a string are turned into a single quote.  Adjacent strings are
 270    merged separated by whitespace are merged, as in C.  */
 271
 272 static char *
 273 handle_quotes (input, len)
 274      const char *input;
 275      unsigned long *len;
 276 {
 277   char *ret, *s;
 278   const char *t;
 279   int ch;
 280
 281   ret = get_string (strlen (input) + 1);
 282
 283   s = ret;
 284   t = input;
 285   if (*t == '"')
 286     ++t;
 287   while (*t != '\0')
 288     {
 289       if (*t == '\\')
 290         {
 291           ++t;
 292           switch (*t)
 293             {
 294             case '\0':
 295               rcparse_warning ("backslash at end of string");
 296               break;
 297
 298             case '\"':
 299               rcparse_warning ("use \"\" to put \" in a string");
 300               break;
 301
 302             case 'a':
 303               *s++ = ESCAPE_A;
 304               ++t;
 305               break;
 306
 307             case 'b':
 308               *s++ = ESCAPE_B;
 309               ++t;
 310               break;
 311
 312             case 'f':
 313               *s++ = ESCAPE_F;
 314               ++t;
 315               break;
 316
 317             case 'n':
 318               *s++ = ESCAPE_N;
 319               ++t;
 320               break;
 321
 322             case 'r':
 323               *s++ = ESCAPE_R;
 324               ++t;
 325               break;
 326
 327             case 't':
 328               *s++ = ESCAPE_T;
 329               ++t;
 330               break;
 331
 332             case 'v':
 333               *s++ = ESCAPE_V;
 334               ++t;
 335               break;
 336
 337             case '\\':
 338               *s++ = *t++;
 339               break;
 340
 341             case '0': case '1': case '2': case '3':
 342             case '4': case '5': case '6': case '7':
 343               ch = *t - '0';
 344               ++t;
 345               if (*t >= '0' && *t <= '7')
 346                 {
 347                   ch = (ch << 3) | (*t - '0');
 348                   ++t;
 349                   if (*t >= '0' && *t <= '7')
 350                     {
 351                       ch = (ch << 3) | (*t - '0');
 352                       ++t;
 353                     }
 354                 }
 355               *s++ = ch;
 356               break;
 357
 358             case 'x':
 359               ++t;
 360               ch = 0;
 361               while (1)
 362                 {
 363                   if (*t >= '0' && *t <= '9')
 364                     ch = (ch << 4) | (*t - '0');
 365                   else if (*t >= 'a' && *t <= 'f')
 366                     ch = (ch << 4) | (*t - 'a');
 367                   else if (*t >= 'A' && *t <= 'F')
 368                     ch = (ch << 4) | (*t - 'A');
 369                   else
 370                     break;
 371                   ++t;
 372                 }
 373               *s++ = ch;
 374               break;
 375
 376             default:
 377               rcparse_warning ("unrecognized escape sequence");
 378               *s++ = '\\';
 379               *s++ = *t++;
 380               break;
 381             }
 382         }
 383       else if (*t != '"')
 384         *s++ = *t++;
 385       else if (t[1] == '\0')
 386         break;
 387       else if (t[1] == '"')
 388         {
 389           *s++ = '"';
 390           t += 2;
 391         }
 392       else
 393         {
 394           ++t;
 395           assert (isspace ((unsigned char) *t));
 396           while (isspace ((unsigned char) *t))
 397             ++t;
 398           if (*t == '\0')
 399             break;
 400           assert (*t == '"');
 401           ++t;
 402         }
 403     }
 404
 405   *s = '\0';
 406
 407   *len = s - ret;
 408
 409   return ret;
 410 }
 411
 412 /* Allocate a string of a given length.  */
 413
 414 static char *
 415 get_string (len)
 416      int len;
 417 {
 418   struct alloc_string *as;
 419
 420   as = (struct alloc_string *) xmalloc (sizeof *as);
 421   as->s = xmalloc (len);
 422
 423   as->next = strings;
 424   strings = as->next;
 425
 426   return as->s;
 427 }
 428
 429 /* Discard all the strings we have allocated.  The parser calls this
 430    when it no longer needs them.  */
 431
 432 void
 433 rcparse_discard_strings ()
 434 {
 435   struct alloc_string *as;
 436
 437   as = strings;
 438   while (as != NULL)
 439     {
 440       struct alloc_string *n;
 441
 442       free (as->s);
 443       n = as->next;
 444       free (as);
 445       as = n;
 446     }
 447
 448   strings = NULL;
 449 }
 450
 451 /* Enter rcdata mode.  */
 452
 453 void
 454 rcparse_rcdata ()
 455 {
 456   rcdata_mode = 1;
 457 }
 458
 459 /* Go back to normal mode from rcdata mode.  */
 460
 461 void
 462 rcparse_normal ()
 463 {
 464   rcdata_mode = 0;
 465 }