gdb/ada-lex.l

   1 /* FLEX lexer for Ada expressions, for GDB.
   2    Copyright (C) 1994-2019 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /*----------------------------------------------------------------------*/
  20
  21 /* The converted version of this file is to be included in ada-exp.y, */
  22 /* the Ada parser for gdb.  The function yylex obtains characters from */
  23 /* the global pointer lexptr.  It returns a syntactic category for */
  24 /* each successive token and places a semantic value into yylval */
  25 /* (ada-lval), defined by the parser.   */
  26
  27 DIG     [0-9]
  28 NUM10   ({DIG}({DIG}|_)*)
  29 HEXDIG  [0-9a-f]
  30 NUM16   ({HEXDIG}({HEXDIG}|_)*)
  31 OCTDIG  [0-7]
  32 LETTER  [a-z_]
  33 ID      ({LETTER}({LETTER}|{DIG})*|"<"{LETTER}({LETTER}|{DIG})*">")
  34 WHITE   [ \t\n]
  35 TICK    ("'"{WHITE}*)
  36 GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
  37 OPER    ([-+*/=<>&]|"<="|">="|"**"|"/="|"and"|"or"|"xor"|"not"|"mod"|"rem"|"abs")
  38
  39 EXP     (e[+-]{NUM10})
  40 POSEXP  (e"+"?{NUM10})
  41
  42 %{
  43
  44 #include "diagnostics.h"
  45
  46 /* Some old versions of flex generate code that uses the "register" keyword,
  47    which clang warns about.  This was observed for example with flex 2.5.35,
  48    as shipped with macOS 10.12.  */
  49 DIAGNOSTIC_PUSH
  50 DIAGNOSTIC_IGNORE_DEPRECATED_REGISTER
  51
  52 #define NUMERAL_WIDTH 256
  53 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
  54
  55 /* Temporary staging for numeric literals.  */
  56 static char numbuf[NUMERAL_WIDTH];
  57  static void canonicalizeNumeral (char *s1, const char *);
  58 static struct stoken processString (const char*, int);
  59 static int processInt (struct parser_state *, const char *, const char *,
  60                        const char *);
  61 static int processReal (struct parser_state *, const char *);
  62 static struct stoken processId (const char *, int);
  63 static int processAttribute (const char *);
  64 static int find_dot_all (const char *);
  65 static void rewind_to_char (int);
  66
  67 #undef YY_DECL
  68 #define YY_DECL static int yylex ( void )
  69
  70 /* Flex generates a static function "input" which is not used.
  71    Defining YY_NO_INPUT comments it out.  */
  72 #define YY_NO_INPUT
  73
  74 #undef YY_INPUT
  75 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
  76     if ( *lexptr == '\000' ) \
  77       (RESULT) = YY_NULL; \
  78     else \
  79       { \
  80         *(BUF) = *lexptr; \
  81         (RESULT) = 1; \
  82         lexptr += 1; \
  83       }
  84
  85 static int find_dot_all (const char *);
  86
  87 %}
  88
  89 %option case-insensitive interactive nodefault
  90
  91 %s BEFORE_QUAL_QUOTE
  92
  93 %%
  94
  95 {WHITE}          { }
  96
  97 "--".*           { yyterminate(); }
  98
  99 {NUM10}{POSEXP}  {
 100                    canonicalizeNumeral (numbuf, yytext);
 101                    return processInt (pstate, NULL, numbuf,
 102                                       strrchr (numbuf, 'e') + 1);
 103                  }
 104
 105 {NUM10}          {
 106                    canonicalizeNumeral (numbuf, yytext);
 107                    return processInt (pstate, NULL, numbuf, NULL);
 108                  }
 109
 110 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
 111                    canonicalizeNumeral (numbuf, yytext);
 112                    return processInt (pstate, numbuf,
 113                                       strchr (numbuf, '#') + 1,
 114                                       strrchr(numbuf, '#') + 1);
 115                  }
 116
 117 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
 118                    canonicalizeNumeral (numbuf, yytext);
 119                    return processInt (pstate, numbuf, strchr (numbuf, '#') + 1,
 120                                       NULL);
 121                  }
 122
 123 "0x"{HEXDIG}+   {
 124                   canonicalizeNumeral (numbuf, yytext+2);
 125                   return processInt (pstate, "16#", numbuf, NULL);
 126                 }
 127
 128
 129 {NUM10}"."{NUM10}{EXP} {
 130                    canonicalizeNumeral (numbuf, yytext);
 131                    return processReal (pstate, numbuf);
 132                 }
 133
 134 {NUM10}"."{NUM10} {
 135                    canonicalizeNumeral (numbuf, yytext);
 136                    return processReal (pstate, numbuf);
 137                 }
 138
 139 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
 140                    error (_("Based real literals not implemented yet."));
 141                 }
 142
 143 {NUM10}"#"{NUM16}"."{NUM16}"#" {
 144                    error (_("Based real literals not implemented yet."));
 145                 }
 146
 147 <INITIAL>"'"({GRAPHIC}|\")"'" {
 148                    yylval.typed_val.type = type_char (pstate);
 149                    yylval.typed_val.val = yytext[1];
 150                    return CHARLIT;
 151                 }
 152
 153 <INITIAL>"'[\""{HEXDIG}{2}"\"]'"   {
 154                    int v;
 155                    yylval.typed_val.type = type_char (pstate);
 156                    sscanf (yytext+3, "%2x", &v);
 157                    yylval.typed_val.val = v;
 158                    return CHARLIT;
 159                 }
 160
 161 \"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\"   {
 162                    yylval.sval = processString (yytext+1, yyleng-2);
 163                    return STRING;
 164                 }
 165
 166 \"              {
 167                    error (_("ill-formed or non-terminated string literal"));
 168                 }
 169
 170
 171 if              {
 172                   rewind_to_char ('i');
 173                   return 0;
 174                 }
 175
 176 task            {
 177                   rewind_to_char ('t');
 178                   return 0;
 179                 }
 180
 181 thread{WHITE}+{DIG} {
 182                   /* This keyword signals the end of the expression and
 183                      will be processed separately.  */
 184                   rewind_to_char ('t');
 185                   return 0;
 186                 }
 187
 188         /* ADA KEYWORDS */
 189
 190 abs             { return ABS; }
 191 and             { return _AND_; }
 192 else            { return ELSE; }
 193 in              { return IN; }
 194 mod             { return MOD; }
 195 new             { return NEW; }
 196 not             { return NOT; }
 197 null            { return NULL_PTR; }
 198 or              { return OR; }
 199 others          { return OTHERS; }
 200 rem             { return REM; }
 201 then            { return THEN; }
 202 xor             { return XOR; }
 203
 204         /* BOOLEAN "KEYWORDS" */
 205
 206  /* True and False are not keywords in Ada, but rather enumeration constants.
 207     However, the boolean type is no longer represented as an enum, so True
 208     and False are no longer defined in symbol tables.  We compromise by
 209     making them keywords (when bare). */
 210
 211 true            { return TRUEKEYWORD; }
 212 false           { return FALSEKEYWORD; }
 213
 214         /* ATTRIBUTES */
 215
 216 {TICK}[a-zA-Z][a-zA-Z]+ { BEGIN INITIAL; return processAttribute (yytext+1); }
 217
 218         /* PUNCTUATION */
 219
 220 "=>"            { return ARROW; }
 221 ".."            { return DOTDOT; }
 222 "**"            { return STARSTAR; }
 223 ":="            { return ASSIGN; }
 224 "/="            { return NOTEQUAL; }
 225 "<="            { return LEQ; }
 226 ">="            { return GEQ; }
 227
 228 <BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
 229
 230 [-&*+./:<>=|;\[\]] { return yytext[0]; }
 231
 232 ","             { if (paren_depth == 0 && comma_terminates)
 233                     {
 234                       rewind_to_char (',');
 235                       return 0;
 236                     }
 237                   else
 238                     return ',';
 239                 }
 240
 241 "("             { paren_depth += 1; return '('; }
 242 ")"             { if (paren_depth == 0)
 243                     {
 244                       rewind_to_char (')');
 245                       return 0;
 246                     }
 247                   else
 248                     {
 249                       paren_depth -= 1;
 250                       return ')';
 251                     }
 252                 }
 253
 254 "."{WHITE}*all  { return DOT_ALL; }
 255
 256 "."{WHITE}*{ID} {
 257                   yylval.sval = processId (yytext+1, yyleng-1);
 258                   return DOT_ID;
 259                 }
 260
 261 {ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")?  {
 262                   int all_posn = find_dot_all (yytext);
 263
 264                   if (all_posn == -1 && yytext[yyleng-1] == '\'')
 265                     {
 266                       BEGIN BEFORE_QUAL_QUOTE;
 267                       yyless (yyleng-1);
 268                     }
 269                   else if (all_posn >= 0)
 270                     yyless (all_posn);
 271                   yylval.sval = processId (yytext, yyleng);
 272                   return NAME;
 273                }
 274
 275
 276         /* GDB EXPRESSION CONSTRUCTS  */
 277
 278 "'"[^']+"'"{WHITE}*:: {
 279                   yyless (yyleng - 2);
 280                   yylval.sval = processId (yytext, yyleng);
 281                   return NAME;
 282                 }
 283
 284 "::"            { return COLONCOLON; }
 285
 286 [{}@]           { return yytext[0]; }
 287
 288         /* REGISTERS AND GDB CONVENIENCE VARIABLES */
 289
 290 "$"({LETTER}|{DIG}|"$")*  {
 291                   yylval.sval.ptr = yytext;
 292                   yylval.sval.length = yyleng;
 293                   return DOLLAR_VARIABLE;
 294                 }
 295
 296         /* CATCH-ALL ERROR CASE */
 297
 298 .               { error (_("Invalid character '%s' in expression."), yytext); }
 299 %%
 300
 301 #include <ctype.h>
 302 /* Initialize the lexer for processing new expression. */
 303
 304 static void
 305 lexer_init (FILE *inp)
 306 {
 307   BEGIN INITIAL;
 308   yyrestart (inp);
 309 }
 310
 311
 312 /* Copy S2 to S1, removing all underscores, and downcasing all letters.  */
 313
 314 static void
 315 canonicalizeNumeral (char *s1, const char *s2)
 316 {
 317   for (; *s2 != '\000'; s2 += 1)
 318     {
 319       if (*s2 != '_')
 320         {
 321           *s1 = tolower(*s2);
 322           s1 += 1;
 323         }
 324     }
 325   s1[0] = '\000';
 326 }
 327
 328 /* Interprets the prefix of NUM that consists of digits of the given BASE
 329    as an integer of that BASE, with the string EXP as an exponent.
 330    Puts value in yylval, and returns INT, if the string is valid.  Causes
 331    an error if the number is improperly formated.   BASE, if NULL, defaults
 332    to "10", and EXP to "1".  The EXP does not contain a leading 'e' or 'E'.
 333  */
 334
 335 static int
 336 processInt (struct parser_state *par_state, const char *base0,
 337             const char *num0, const char *exp0)
 338 {
 339   ULONGEST result;
 340   long exp;
 341   int base;
 342   const char *trailer;
 343
 344   if (base0 == NULL)
 345     base = 10;
 346   else
 347     {
 348       base = strtol (base0, (char **) NULL, 10);
 349       if (base < 2 || base > 16)
 350         error (_("Invalid base: %d."), base);
 351     }
 352
 353   if (exp0 == NULL)
 354     exp = 0;
 355   else
 356     exp = strtol(exp0, (char **) NULL, 10);
 357
 358   errno = 0;
 359   result = strtoulst (num0, &trailer, base);
 360   if (errno == ERANGE)
 361     error (_("Integer literal out of range"));
 362   if (isxdigit(*trailer))
 363     error (_("Invalid digit `%c' in based literal"), *trailer);
 364
 365   while (exp > 0)
 366     {
 367       if (result > (ULONG_MAX / base))
 368         error (_("Integer literal out of range"));
 369       result *= base;
 370       exp -= 1;
 371     }
 372
 373   if ((result >> (gdbarch_int_bit (parse_gdbarch (par_state))-1)) == 0)
 374     yylval.typed_val.type = type_int (par_state);
 375   else if ((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) == 0)
 376     yylval.typed_val.type = type_long (par_state);
 377   else if (((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) >> 1) == 0)
 378     {
 379       /* We have a number representable as an unsigned integer quantity.
 380          For consistency with the C treatment, we will treat it as an
 381          anonymous modular (unsigned) quantity.  Alas, the types are such
 382          that we need to store .val as a signed quantity.  Sorry
 383          for the mess, but C doesn't officially guarantee that a simple
 384          assignment does the trick (no, it doesn't; read the reference manual).
 385        */
 386       yylval.typed_val.type
 387         = builtin_type (parse_gdbarch (par_state))->builtin_unsigned_long;
 388       if (result & LONGEST_SIGN)
 389         yylval.typed_val.val =
 390           (LONGEST) (result & ~LONGEST_SIGN)
 391           - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
 392       else
 393         yylval.typed_val.val = (LONGEST) result;
 394       return INT;
 395     }
 396   else
 397     yylval.typed_val.type = type_long_long (par_state);
 398
 399   yylval.typed_val.val = (LONGEST) result;
 400   return INT;
 401 }
 402
 403 static int
 404 processReal (struct parser_state *par_state, const char *num0)
 405 {
 406   yylval.typed_val_float.type = type_long_double (par_state);
 407
 408   bool parsed = parse_float (num0, strlen (num0),
 409                              yylval.typed_val_float.type,
 410                              yylval.typed_val_float.val);
 411   gdb_assert (parsed);
 412   return FLOAT;
 413 }
 414
 415
 416 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.  The
 417    resulting string is valid until the next call to ada_parse.  If
 418    NAME0 contains the substring "___", it is assumed to be already
 419    encoded and the resulting name is equal to it.  Similarly, if the name
 420    starts with '<', it is copied verbatim.  Otherwise, it differs
 421    from NAME0 in that:
 422     + Characters between '...' are transfered verbatim to yylval.ssym.
 423     + Trailing "'" characters in quoted sequences are removed (a leading quote is
 424       preserved to indicate that the name is not to be GNAT-encoded).
 425     + Unquoted whitespace is removed.
 426     + Unquoted alphabetic characters are mapped to lower case.
 427    Result is returned as a struct stoken, but for convenience, the string
 428    is also null-terminated.  Result string valid until the next call of
 429    ada_parse.
 430  */
 431 static struct stoken
 432 processId (const char *name0, int len)
 433 {
 434   char *name = (char *) obstack_alloc (&temp_parse_space, len + 11);
 435   int i0, i;
 436   struct stoken result;
 437
 438   result.ptr = name;
 439   while (len > 0 && isspace (name0[len-1]))
 440     len -= 1;
 441
 442   if (name0[0] == '<' || strstr (name0, "___") != NULL)
 443     {
 444       strncpy (name, name0, len);
 445       name[len] = '\000';
 446       result.length = len;
 447       return result;
 448     }
 449
 450   i = i0 = 0;
 451   while (i0 < len)
 452     {
 453       if (isalnum (name0[i0]))
 454         {
 455           name[i] = tolower (name0[i0]);
 456           i += 1; i0 += 1;
 457         }
 458       else switch (name0[i0])
 459         {
 460         default:
 461           name[i] = name0[i0];
 462           i += 1; i0 += 1;
 463           break;
 464         case ' ': case '\t':
 465           i0 += 1;
 466           break;
 467         case '\'':
 468           do
 469             {
 470               name[i] = name0[i0];
 471               i += 1; i0 += 1;
 472             }
 473           while (i0 < len && name0[i0] != '\'');
 474           i0 += 1;
 475           break;
 476         }
 477     }
 478   name[i] = '\000';
 479
 480   result.length = i;
 481   return result;
 482 }
 483
 484 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
 485    with special hex character notations replaced with characters.
 486    Result valid until the next call to ada_parse.  */
 487
 488 static struct stoken
 489 processString (const char *text, int len)
 490 {
 491   const char *p;
 492   char *q;
 493   const char *lim = text + len;
 494   struct stoken result;
 495
 496   q = (char *) obstack_alloc (&temp_parse_space, len);
 497   result.ptr = q;
 498   p = text;
 499   while (p < lim)
 500     {
 501       if (p[0] == '[' && p[1] == '"' && p+2 < lim)
 502          {
 503            if (p[2] == '"')  /* "...["""]... */
 504              {
 505                *q = '"';
 506                p += 4;
 507              }
 508            else
 509              {
 510                int chr;
 511                sscanf (p+2, "%2x", &chr);
 512                *q = (char) chr;
 513                p += 5;
 514              }
 515          }
 516        else
 517          *q = *p;
 518        q += 1;
 519        p += 1;
 520      }
 521   result.length = q - result.ptr;
 522   return result;
 523 }
 524
 525 /* Returns the position within STR of the '.' in a
 526    '.{WHITE}*all' component of a dotted name, or -1 if there is none.
 527    Note: we actually don't need this routine, since 'all' can never be an
 528    Ada identifier.  Thus, looking up foo.all or foo.all.x as a name
 529    must fail, and will eventually be interpreted as (foo).all or
 530    (foo).all.x.  However, this does avoid an extraneous lookup. */
 531
 532 static int
 533 find_dot_all (const char *str)
 534 {
 535   int i;
 536
 537   for (i = 0; str[i] != '\000'; i++)
 538     if (str[i] == '.')
 539       {
 540         int i0 = i;
 541
 542         do
 543           i += 1;
 544         while (isspace (str[i]));
 545
 546         if (strncasecmp (str + i, "all", 3) == 0
 547             && !isalnum (str[i + 3]) && str[i + 3] != '_')
 548           return i0;
 549       }
 550   return -1;
 551 }
 552
 553 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
 554    case.  */
 555
 556 static int
 557 subseqMatch (const char *subseq, const char *str)
 558 {
 559   if (subseq[0] == '\0')
 560     return 1;
 561   else if (str[0] == '\0')
 562     return 0;
 563   else if (tolower (subseq[0]) == tolower (str[0]))
 564     return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
 565   else
 566     return subseqMatch (subseq, str+1);
 567 }
 568
 569
 570 static struct { const char *name; int code; }
 571 attributes[] = {
 572   { "address", TICK_ADDRESS },
 573   { "unchecked_access", TICK_ACCESS },
 574   { "unrestricted_access", TICK_ACCESS },
 575   { "access", TICK_ACCESS },
 576   { "first", TICK_FIRST },
 577   { "last", TICK_LAST },
 578   { "length", TICK_LENGTH },
 579   { "max", TICK_MAX },
 580   { "min", TICK_MIN },
 581   { "modulus", TICK_MODULUS },
 582   { "pos", TICK_POS },
 583   { "range", TICK_RANGE },
 584   { "size", TICK_SIZE },
 585   { "tag", TICK_TAG },
 586   { "val", TICK_VAL },
 587   { NULL, -1 }
 588 };
 589
 590 /* Return the syntactic code corresponding to the attribute name or
 591    abbreviation STR.  */
 592
 593 static int
 594 processAttribute (const char *str)
 595 {
 596   int i, k;
 597
 598   for (i = 0; attributes[i].code != -1; i += 1)
 599     if (strcasecmp (str, attributes[i].name) == 0)
 600       return attributes[i].code;
 601
 602   for (i = 0, k = -1; attributes[i].code != -1; i += 1)
 603     if (subseqMatch (str, attributes[i].name))
 604       {
 605         if (k == -1)
 606           k = i;
 607         else
 608           error (_("ambiguous attribute name: `%s'"), str);
 609       }
 610   if (k == -1)
 611     error (_("unrecognized attribute: `%s'"), str);
 612
 613   return attributes[k].code;
 614 }
 615
 616 /* Back up lexptr by yyleng and then to the rightmost occurrence of
 617    character CH, case-folded (there must be one).  WARNING: since
 618    lexptr points to the next input character that Flex has not yet
 619    transferred to its internal buffer, the use of this function
 620    depends on the assumption that Flex calls YY_INPUT only when it is
 621    logically necessary to do so (thus, there is no reading ahead
 622    farther than needed to identify the next token.)  */
 623
 624 static void
 625 rewind_to_char (int ch)
 626 {
 627   lexptr -= yyleng;
 628   while (toupper (*lexptr) != toupper (ch))
 629     lexptr -= 1;
 630   yyrestart (NULL);
 631 }
 632
 633 int
 634 yywrap(void)
 635 {
 636   return 1;
 637 }
 638
 639 /* Dummy definition to suppress warnings about unused static definitions. */
 640 typedef void (*dummy_function) ();
 641 dummy_function ada_flex_use[] =
 642 {
 643   (dummy_function) yyunput
 644 };
 645
 646 DIAGNOSTIC_POP