gdb/ada-lex.l

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