gdb/ada-lex.l

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