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
  57 #undef YY_DECL
  58 #define YY_DECL static int yylex ( void )
  59
  60 /* Flex generates a static function "input" which is not used.
  61    Defining YY_NO_INPUT comments it out.  */
  62 #define YY_NO_INPUT
  63
  64 #undef YY_INPUT
  65 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
  66     if ( *lexptr == '\000' ) \
  67       (RESULT) = YY_NULL; \
  68     else \
  69       { \
  70         *(BUF) = *lexptr; \
  71         (RESULT) = 1; \
  72         lexptr += 1; \
  73       }
  74
  75 static int find_dot_all (const char *);
  76
  77 %}
  78
  79 %option case-insensitive interactive nodefault
  80
  81 %s BEFORE_QUAL_QUOTE
  82
  83 %%
  84
  85 {WHITE}          { }
  86
  87 "--".*           { yyterminate(); }
  88
  89 {NUM10}{POSEXP}  {
  90                    canonicalizeNumeral (numbuf, yytext);
  91                    return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
  92                  }
  93
  94 {NUM10}          {
  95                    canonicalizeNumeral (numbuf, yytext);
  96                    return processInt (NULL, numbuf, NULL);
  97                  }
  98
  99 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
 100                    canonicalizeNumeral (numbuf, yytext);
 101                    return processInt (numbuf,
 102                                       strchr (numbuf, '#') + 1,
 103                                       strrchr(numbuf, '#') + 1);
 104                  }
 105
 106 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
 107                    canonicalizeNumeral (numbuf, yytext);
 108                    return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
 109                  }
 110
 111 "0x"{HEXDIG}+   {
 112                   canonicalizeNumeral (numbuf, yytext+2);
 113                   return processInt ("16#", numbuf, NULL);
 114                 }
 115
 116
 117 {NUM10}"."{NUM10}{EXP} {
 118                    canonicalizeNumeral (numbuf, yytext);
 119                    return processReal (numbuf);
 120                 }
 121
 122 {NUM10}"."{NUM10} {
 123                    canonicalizeNumeral (numbuf, yytext);
 124                    return processReal (numbuf);
 125                 }
 126
 127 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
 128                    error (_("Based real literals not implemented yet."));
 129                 }
 130
 131 {NUM10}"#"{NUM16}"."{NUM16}"#" {
 132                    error (_("Based real literals not implemented yet."));
 133                 }
 134
 135 <INITIAL>"'"({GRAPHIC}|\")"'" {
 136                    yylval.typed_val.type = type_char ();
 137                    yylval.typed_val.val = yytext[1];
 138                    return CHARLIT;
 139                 }
 140
 141 <INITIAL>"'[\""{HEXDIG}{2}"\"]'"   {
 142                    int v;
 143                    yylval.typed_val.type = type_char ();
 144                    sscanf (yytext+3, "%2x", &v);
 145                    yylval.typed_val.val = v;
 146                    return CHARLIT;
 147                 }
 148
 149 \"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\"   {
 150                    yylval.sval = processString (yytext+1, yyleng-2);
 151                    return STRING;
 152                 }
 153
 154 \"              {
 155                    error (_("ill-formed or non-terminated string literal"));
 156                 }
 157
 158
 159 if              {
 160                   while (*lexptr != 'i' && *lexptr != 'I')
 161                     lexptr -= 1;
 162                   yyrestart(NULL);
 163                   return 0;
 164                 }
 165
 166 (task|thread)   {
 167                   /* This keyword signals the end of the expression and
 168                      will be processed separately.  */
 169                   while (*lexptr != 't' && *lexptr != 'T')
 170                     lexptr--;
 171                   yyrestart(NULL);
 172                   return 0;
 173                 }
 174
 175         /* ADA KEYWORDS */
 176
 177 abs             { return ABS; }
 178 and             { return _AND_; }
 179 else            { return ELSE; }
 180 in              { return IN; }
 181 mod             { return MOD; }
 182 new             { return NEW; }
 183 not             { return NOT; }
 184 null            { return NULL_PTR; }
 185 or              { return OR; }
 186 others          { return OTHERS; }
 187 rem             { return REM; }
 188 then            { return THEN; }
 189 xor             { return XOR; }
 190
 191         /* BOOLEAN "KEYWORDS" */
 192
 193  /* True and False are not keywords in Ada, but rather enumeration constants.
 194     However, the boolean type is no longer represented as an enum, so True
 195     and False are no longer defined in symbol tables.  We compromise by
 196     making them keywords (when bare). */
 197
 198 true            { return TRUEKEYWORD; }
 199 false           { return FALSEKEYWORD; }
 200
 201         /* ATTRIBUTES */
 202
 203 {TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }
 204
 205         /* PUNCTUATION */
 206
 207 "=>"            { return ARROW; }
 208 ".."            { return DOTDOT; }
 209 "**"            { return STARSTAR; }
 210 ":="            { return ASSIGN; }
 211 "/="            { return NOTEQUAL; }
 212 "<="            { return LEQ; }
 213 ">="            { return GEQ; }
 214
 215 <BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
 216
 217 [-&*+./:<>=|;\[\]] { return yytext[0]; }
 218
 219 ","             { if (paren_depth == 0 && comma_terminates)
 220                     {
 221                       lexptr -= 1;
 222                       yyrestart(NULL);
 223                       return 0;
 224                     }
 225                   else
 226                     return ',';
 227                 }
 228
 229 "("             { paren_depth += 1; return '('; }
 230 ")"             { if (paren_depth == 0)
 231                     {
 232                       lexptr -= 1;
 233                       yyrestart(NULL);
 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 int
 620 yywrap(void)
 621 {
 622   return 1;
 623 }
 624
 625 /* Dummy definition to suppress warnings about unused static definitions. */
 626 typedef void (*dummy_function) ();
 627 dummy_function ada_flex_use[] =
 628 {
 629   (dummy_function) yyunput
 630 };