gdb/ada-lex.l

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