sdcc/support/sdbinutils/binutils/mclex.c

   1 /* mclex.c -- lexer for Windows mc files parser.
   2    Copyright (C) 2007-2022 Free Software Foundation, Inc.
   3
   4    Written by Kai Tietz, Onevision.
   5
   6    This file is part of GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* This is a lexer used by the Windows rc file parser.
  24    It basically just recognized a bunch of keywords.  */
  25
  26 #include "sysdep.h"
  27 #include "bfd.h"
  28 #include "bucomm.h"
  29 #include "libiberty.h"
  30 #include "safe-ctype.h"
  31 #include "windmc.h"
  32 #include "mcparse.h"
  33
  34 #include <assert.h>
  35
  36 /* Exported globals.  */
  37 bool mclex_want_nl = false;
  38 bool mclex_want_line = false;
  39 bool mclex_want_filename = false;
  40
  41 /* Local globals.  */
  42 static unichar *input_stream = NULL;
  43 static unichar *input_stream_pos = NULL;
  44 static int input_line = 1;
  45 static const char *input_filename = NULL;
  46
  47 void
  48 mc_set_content (const unichar *src)
  49 {
  50   if (!src)
  51     return;
  52   input_stream = input_stream_pos = unichar_dup (src);
  53 }
  54
  55 void
  56 mc_set_inputfile (const char *name)
  57 {
  58   if (! name || *name == 0)
  59     input_filename = "-";
  60   else
  61     {
  62       const char *s1 = strrchr (name, '/');
  63       const char *s2 = strrchr (name, '\\');
  64
  65       if (! s1)
  66         s1 = s2;
  67       if (s1 && s2 && s1 < s2)
  68         s1 = s2;
  69       if (! s1)
  70         s1 = name;
  71       else
  72         s1++;
  73       s1 = xstrdup (s1);
  74       input_filename = s1;
  75     }
  76 }
  77
  78 static void
  79 show_msg (const char *kind, const char *msg, va_list argp)
  80 {
  81   fprintf (stderr, "In %s at line %d: %s: ", input_filename, input_line, kind);
  82   vfprintf (stderr, msg, argp);
  83   fprintf (stderr, ".\n");
  84 }
  85
  86 void
  87 mc_warn (const char *s, ...)
  88 {
  89   va_list argp;
  90   va_start (argp, s);
  91   show_msg ("warning", s, argp);
  92   va_end (argp);
  93 }
  94
  95 void
  96 mc_fatal (const char *s, ...)
  97 {
  98   va_list argp;
  99   va_start (argp, s);
 100   show_msg ("fatal", s, argp);
 101   va_end (argp);
 102   xexit (1);
 103 }
 104
 105
 106 static void
 107 mc_error (const char *s, ...)
 108 {
 109   va_list argp;
 110   va_start (argp, s);
 111   show_msg ("parser", s, argp);
 112   va_end (argp);
 113 }
 114
 115 void
 116 yyerror (const char *s)
 117 {
 118   mc_error (s);
 119 }
 120
 121 static unichar *
 122 get_diff (unichar *end, unichar *start)
 123 {
 124   unichar *ret;
 125   unichar save = *end;
 126
 127   *end = 0;
 128   ret = unichar_dup (start);
 129   *end = save;
 130   return ret;
 131 }
 132
 133 static rc_uint_type
 134 parse_digit (unichar ch)
 135 {
 136   rc_uint_type base = 10, v = 0, c;
 137
 138   if (ch == '0')
 139     {
 140       base = 8;
 141       switch (input_stream_pos[0])
 142         {
 143         case 'x': case 'X': base = 16; input_stream_pos++; break;
 144         case 'o': case 'O': base = 8; input_stream_pos++; break;
 145         case 'b': case 'B': base = 2; input_stream_pos++; break;
 146         }
 147     }
 148   else
 149     v = (rc_uint_type) (ch - '0');
 150
 151   while ((ch = input_stream_pos[0]) != 0)
 152     {
 153       if (ch >= 'A' && ch <= 'F')
 154         c = (rc_uint_type) (ch - 'A') + 10;
 155       else if (ch >= 'a' && ch <= 'f')
 156         c = (rc_uint_type) (ch - 'a') + 10;
 157       else if (ch >= '0' && ch <= '9')
 158         c = (rc_uint_type) (ch - '0');
 159       else
 160         break;
 161       v *= base;
 162       v += c;
 163       ++input_stream_pos;
 164     }
 165   if (input_stream_pos[0] == 'U' || input_stream_pos[0] == 'u')
 166     input_stream_pos++;
 167   if (input_stream_pos[0] == 'L' || input_stream_pos[0] == 'l')
 168     input_stream_pos++;
 169   if (input_stream_pos[0] == 'L' || input_stream_pos[0] == 'l')
 170     input_stream_pos++;
 171   return v;
 172 }
 173
 174 static mc_keyword *keyword_top = NULL;
 175
 176 const mc_keyword *
 177 enum_facility (int e)
 178 {
 179   mc_keyword *h = keyword_top;
 180
 181   while (h != NULL)
 182     {
 183       while (h && strcmp (h->group_name, "facility") != 0)
 184         h = h->next;
 185       if (e == 0)
 186         return h;
 187       --e;
 188       if (h)
 189         h = h->next;
 190     }
 191   return h;
 192 }
 193
 194 const mc_keyword *
 195 enum_severity (int e)
 196 {
 197   mc_keyword *h = keyword_top;
 198
 199   while (h != NULL)
 200     {
 201       while (h && strcmp (h->group_name, "severity") != 0)
 202         h = h->next;
 203       if (e == 0)
 204         return h;
 205       --e;
 206       if (h)
 207         h = h->next;
 208     }
 209   return h;
 210 }
 211
 212 static void
 213 mc_add_keyword_ascii (const char *sz, int rid, const char *grp, rc_uint_type nv, const char *sv)
 214 {
 215   unichar *usz, *usv = NULL;
 216   rc_uint_type usz_len;
 217
 218   unicode_from_codepage (&usz_len, &usz, sz, CP_ACP);
 219   if (sv)
 220     unicode_from_codepage (&usz_len, &usv, sv, CP_ACP);
 221   mc_add_keyword (usz, rid, grp, nv, usv);
 222 }
 223
 224 void
 225 mc_add_keyword (unichar *usz, int rid, const char *grp, rc_uint_type nv, unichar *sv)
 226 {
 227   mc_keyword *p, *c, *n;
 228   size_t len = unichar_len (usz);
 229
 230   c = keyword_top;
 231   p = NULL;
 232   while (c != NULL)
 233     {
 234       if (c->len > len)
 235         break;
 236       if (c->len == len)
 237         {
 238           int e = memcmp (usz, c->usz, len * sizeof (unichar));
 239
 240           if (e < 0)
 241             break;
 242           if (! e)
 243             {
 244               if (! strcmp (grp, "keyword") || strcmp (c->group_name, grp) != 0)
 245                 fatal (_("Duplicate symbol entered into keyword list."));
 246               c->rid = rid;
 247               c->nval = nv;
 248               c->sval = (!sv ? NULL : unichar_dup (sv));
 249               if (! strcmp (grp, "language"))
 250                 {
 251                   const wind_language_t *lag = wind_find_language_by_id ((unsigned) nv);
 252
 253                   if (lag == NULL)
 254                     fatal ("Language ident 0x%lx is not resolvable.\n", (long) nv);
 255                   memcpy (&c->lang_info, lag, sizeof (*lag));
 256                 }
 257               return;
 258             }
 259         }
 260       c = (p = c)->next;
 261     }
 262   n = xmalloc (sizeof (mc_keyword));
 263   n->next = c;
 264   n->len = len;
 265   n->group_name = grp;
 266   n->usz = usz;
 267   n->rid = rid;
 268   n->nval = nv;
 269   n->sval = (!sv ? NULL : unichar_dup (sv));
 270   if (! strcmp (grp, "language"))
 271     {
 272       const wind_language_t *lag = wind_find_language_by_id ((unsigned) nv);
 273       if (lag == NULL)
 274         fatal ("Language ident 0x%lx is not resolvable.\n", (long) nv);
 275       memcpy (&n->lang_info, lag, sizeof (*lag));
 276     }
 277   if (! p)
 278     keyword_top = n;
 279   else
 280     p->next = n;
 281 }
 282
 283 static int
 284 mc_token (const unichar *t, size_t len)
 285 {
 286   static int was_init = 0;
 287   mc_keyword *k;
 288
 289   if (! was_init)
 290     {
 291       was_init = 1;
 292       mc_add_keyword_ascii ("OutputBase", MCOUTPUTBASE, "keyword", 0, NULL);
 293       mc_add_keyword_ascii ("MessageIdTypedef", MCMESSAGEIDTYPEDEF, "keyword", 0, NULL);
 294       mc_add_keyword_ascii ("SeverityNames", MCSEVERITYNAMES, "keyword", 0, NULL);
 295       mc_add_keyword_ascii ("FacilityNames", MCFACILITYNAMES, "keyword", 0, NULL);
 296       mc_add_keyword_ascii ("LanguageNames", MCLANGUAGENAMES, "keyword", 0, NULL);
 297       mc_add_keyword_ascii ("MessageId", MCMESSAGEID, "keyword", 0, NULL);
 298       mc_add_keyword_ascii ("Severity", MCSEVERITY, "keyword", 0, NULL);
 299       mc_add_keyword_ascii ("Facility", MCFACILITY, "keyword", 0, NULL);
 300       mc_add_keyword_ascii ("SymbolicName", MCSYMBOLICNAME, "keyword", 0, NULL);
 301       mc_add_keyword_ascii ("Language", MCLANGUAGE, "keyword", 0, NULL);
 302       mc_add_keyword_ascii ("Success", MCTOKEN, "severity", 0, NULL);
 303       mc_add_keyword_ascii ("Informational", MCTOKEN, "severity", 1, NULL);
 304       mc_add_keyword_ascii ("Warning", MCTOKEN, "severity", 2, NULL);
 305       mc_add_keyword_ascii ("Error", MCTOKEN, "severity", 3, NULL);
 306       mc_add_keyword_ascii ("System", MCTOKEN, "facility", 0xff, NULL);
 307       mc_add_keyword_ascii ("Application", MCTOKEN, "facility", 0xfff, NULL);
 308       mc_add_keyword_ascii ("English", MCTOKEN, "language", 0x409, "MSG00001");
 309   }
 310   k = keyword_top;
 311   if (!len || !t || *t == 0)
 312     return -1;
 313   while (k != NULL)
 314     {
 315       if (k->len > len)
 316         break;
 317       if (k->len == len)
 318         {
 319           if (! memcmp (k->usz, t, len * sizeof (unichar)))
 320             {
 321               if (k->rid == MCTOKEN)
 322                 yylval.tok = k;
 323               return k->rid;
 324             }
 325         }
 326       k = k->next;
 327     }
 328   return -1;
 329 }
 330
 331 /* Skip characters in input_stream_pos up to and including a newline
 332    character.  Returns non-zero if the newline was found, zero otherwise.  */
 333
 334 static int
 335 skip_until_eol (void)
 336 {
 337   while (input_stream_pos[0] != 0 && input_stream_pos[0] != '\n')
 338     ++input_stream_pos;
 339   if (input_stream_pos[0] == 0)
 340     return 0;
 341   if (input_stream_pos[0] == '\n')
 342     {
 343       ++input_stream_pos;
 344       input_line += 1;
 345     }
 346   return 1;
 347 }
 348
 349 int
 350 yylex (void)
 351 {
 352   unichar *start_token;
 353   unichar ch;
 354
 355   if (! input_stream_pos)
 356     {
 357       fatal ("Input stream not setuped.\n");
 358       return -1;
 359     }
 360
 361   if (mclex_want_line)
 362     {
 363       start_token = input_stream_pos;
 364       if (input_stream_pos[0] == 0)
 365         return -1;
 366       /* PR 26082: Reject a period followed by EOF.  */
 367       if (input_stream_pos[0] == '.' && input_stream_pos[1] == 0)
 368         return -1;
 369       if (input_stream_pos[0] == '.'
 370           && (input_stream_pos[1] == '\n'
 371               || (input_stream_pos[1] == '\r' && input_stream_pos[2] == '\n')))
 372         {
 373           mclex_want_line = false;
 374           return skip_until_eol () ? MCENDLINE : -1;
 375         }
 376       if (!skip_until_eol ())
 377         return -1;
 378       yylval.ustr = get_diff (input_stream_pos, start_token);
 379       return MCLINE;
 380     }
 381
 382   while ((ch = input_stream_pos[0]) <= 0x20)
 383     {
 384       if (ch == 0)
 385         return -1;
 386       ++input_stream_pos;
 387       if (ch == '\n')
 388         input_line += 1;
 389       if (mclex_want_nl && ch == '\n')
 390         {
 391           mclex_want_nl = false;
 392           return NL;
 393         }
 394     }
 395   start_token = input_stream_pos;
 396   ++input_stream_pos;
 397   if (mclex_want_filename)
 398     {
 399       mclex_want_filename = false;
 400       if (ch == '"')
 401         {
 402           start_token++;
 403           while ((ch = input_stream_pos[0]) != 0)
 404             {
 405               if (ch == '"')
 406                 break;
 407               ++input_stream_pos;
 408             }
 409           yylval.ustr = get_diff (input_stream_pos, start_token);
 410           if (ch == '"')
 411             ++input_stream_pos;
 412         }
 413       else
 414         {
 415           while ((ch = input_stream_pos[0]) != 0)
 416             {
 417               if (ch <= 0x20 || ch == ')')
 418                 break;
 419               ++input_stream_pos;
 420             }
 421           yylval.ustr = get_diff (input_stream_pos, start_token);
 422         }
 423       return MCFILENAME;
 424     }
 425   switch (ch)
 426   {
 427   case ';':
 428     ++start_token;
 429     if (!skip_until_eol ())
 430       return -1;
 431     yylval.ustr = get_diff (input_stream_pos, start_token);
 432     return MCCOMMENT;
 433   case '=':
 434     return '=';
 435   case '(':
 436     return '(';
 437   case ')':
 438     return ')';
 439   case '+':
 440     return '+';
 441   case ':':
 442     return ':';
 443   case '0': case '1': case '2': case '3': case '4':
 444   case '5': case '6': case '7': case '8': case '9':
 445     yylval.ival = parse_digit (ch);
 446     return MCNUMBER;
 447   default:
 448     if (ch >= 0x40)
 449       {
 450         int ret;
 451         while (input_stream_pos[0] >= 0x40 || (input_stream_pos[0] >= '0' && input_stream_pos[0] <= '9'))
 452           ++input_stream_pos;
 453         ret = mc_token (start_token, (size_t) (input_stream_pos - start_token));
 454         if (ret != -1)
 455           return ret;
 456         yylval.ustr = get_diff (input_stream_pos, start_token);
 457         return MCIDENT;
 458       }
 459     mc_error ("illegal character 0x%x.", ch);
 460   }
 461   return -1;
 462 }