gdb/ada-lex.l

   1 /* FLEX lexer for Ada expressions, for GDB. -*- c++ -*-
   2    Copyright (C) 1994-2023 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}|[\x80-\xff])*|"<"{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 /* This must agree with COMPLETION_CHAR below.  See the comment there
  43    for the explanation.  */
  44 COMPLETE "\001"
  45 NOT_COMPLETE [^\001]
  46
  47 %{
  48
  49 #include "diagnostics.h"
  50
  51 /* Some old versions of flex generate code that uses the "register" keyword,
  52    which clang warns about.  This was observed for example with flex 2.5.35,
  53    as shipped with macOS 10.12.  The same happens with flex 2.5.37 and g++ 11
  54    which defaults to ISO C++17, that does not allow register storage class
  55    specifiers.  */
  56 DIAGNOSTIC_PUSH
  57 DIAGNOSTIC_IGNORE_DEPRECATED_REGISTER
  58
  59 #define NUMERAL_WIDTH 256
  60 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
  61
  62 /* Temporary staging for numeric literals.  */
  63 static char numbuf[NUMERAL_WIDTH];
  64  static void canonicalizeNumeral (char *s1, const char *);
  65 static struct stoken processString (const char*, int);
  66 static int processInt (struct parser_state *, const char *, const char *,
  67                        const char *);
  68 static int processReal (struct parser_state *, const char *);
  69 static struct stoken processId (const char *, int);
  70 static int processAttribute (const char *);
  71 static int find_dot_all (const char *);
  72 static void rewind_to_char (int);
  73
  74 #undef YY_DECL
  75 #define YY_DECL static int yylex ( void )
  76
  77 /* Flex generates a static function "input" which is not used.
  78    Defining YY_NO_INPUT comments it out.  */
  79 #define YY_NO_INPUT
  80
  81 /* When completing, we'll return a special character at the end of the
  82    input, to signal the completion position to the lexer.  This is
  83    done because flex does not have a generally useful way to detect
  84    EOF in a pattern.  This variable records whether the special
  85    character has been emitted.  */
  86 static bool returned_complete = false;
  87
  88 /* The character we use to represent the completion point.  */
  89 #define COMPLETE_CHAR '\001'
  90
  91 #undef YY_INPUT
  92 #define YY_INPUT(BUF, RESULT, MAX_SIZE)                                 \
  93   if ( *pstate->lexptr == '\000' )                                      \
  94     {                                                                   \
  95       if (pstate->parse_completion && !returned_complete)               \
  96         {                                                               \
  97           returned_complete = true;                                     \
  98           *(BUF) = COMPLETE_CHAR;                                       \
  99           (RESULT) = 1;                                                 \
 100         }                                                               \
 101       else                                                              \
 102         (RESULT) = YY_NULL;                                             \
 103     }                                                                   \
 104   else                                                                  \
 105     {                                                                   \
 106       *(BUF) = *pstate->lexptr == COMPLETE_CHAR ? ' ' : *pstate->lexptr; \
 107       (RESULT) = 1;                                                     \
 108       pstate->lexptr += 1;                                              \
 109     }
 110
 111 /* Depth of parentheses.  */
 112 static int paren_depth;
 113
 114 %}
 115
 116 %option case-insensitive interactive nodefault noyywrap
 117
 118 %s BEFORE_QUAL_QUOTE
 119
 120 %%
 121
 122 {WHITE}          { }
 123
 124 "--".*           { yyterminate(); }
 125
 126 {NUM10}{POSEXP}  {
 127                    canonicalizeNumeral (numbuf, yytext);
 128                    char *e_ptr = strrchr (numbuf, 'e');
 129                    *e_ptr = '\0';
 130                    return processInt (pstate, nullptr, numbuf, e_ptr + 1);
 131                  }
 132
 133 {NUM10}          {
 134                    canonicalizeNumeral (numbuf, yytext);
 135                    return processInt (pstate, NULL, numbuf, NULL);
 136                  }
 137
 138 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
 139                    canonicalizeNumeral (numbuf, yytext);
 140                    char *e_ptr = strrchr (numbuf, 'e');
 141                    *e_ptr = '\0';
 142                    return processInt (pstate, numbuf,
 143                                       strchr (numbuf, '#') + 1,
 144                                       e_ptr + 1);
 145                  }
 146
 147         /* The "llf" is a gdb extension to allow a floating-point
 148            constant to be written in some other base.  The
 149            floating-point number is formed by reinterpreting the
 150            bytes, allowing direct control over the bits.  */
 151 {NUM10}(l{0,2}f)?"#"{HEXDIG}({HEXDIG}|_)*"#" {
 152                    canonicalizeNumeral (numbuf, yytext);
 153                    return processInt (pstate, numbuf, strchr (numbuf, '#') + 1,
 154                                       NULL);
 155                  }
 156
 157 "0x"{HEXDIG}+   {
 158                   canonicalizeNumeral (numbuf, yytext+2);
 159                   return processInt (pstate, "16#", numbuf, NULL);
 160                 }
 161
 162
 163 {NUM10}"."{NUM10}{EXP} {
 164                    canonicalizeNumeral (numbuf, yytext);
 165                    return processReal (pstate, numbuf);
 166                 }
 167
 168 {NUM10}"."{NUM10} {
 169                    canonicalizeNumeral (numbuf, yytext);
 170                    return processReal (pstate, numbuf);
 171                 }
 172
 173 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
 174                    error (_("Based real literals not implemented yet."));
 175                 }
 176
 177 {NUM10}"#"{NUM16}"."{NUM16}"#" {
 178                    error (_("Based real literals not implemented yet."));
 179                 }
 180
 181 <INITIAL>"'"({GRAPHIC}|\")"'" {
 182                    yylval.typed_val.val = yytext[1];
 183                    yylval.typed_val.type = type_for_char (pstate, yytext[1]);
 184                    return CHARLIT;
 185                 }
 186
 187 <INITIAL>"'[\""{HEXDIG}{2,}"\"]'"   {
 188                    ULONGEST v = strtoulst (yytext+3, nullptr, 16);
 189                    yylval.typed_val.val = v;
 190                    yylval.typed_val.type = type_for_char (pstate, v);
 191                    return CHARLIT;
 192                 }
 193
 194         /* Note that we don't handle bracket sequences of more than 2
 195            digits here.  Currently there's no support for wide or
 196            wide-wide strings.  */
 197 \"({GRAPHIC}|"[\""({HEXDIG}{2,}|\")"\"]")*\"   {
 198                    yylval.sval = processString (yytext+1, yyleng-2);
 199                    return STRING;
 200                 }
 201
 202 \"              {
 203                    error (_("ill-formed or non-terminated string literal"));
 204                 }
 205
 206
 207 if              {
 208                   rewind_to_char ('i');
 209                   return 0;
 210                 }
 211
 212 task            {
 213                   rewind_to_char ('t');
 214                   return 0;
 215                 }
 216
 217 thread{WHITE}+{DIG} {
 218                   /* This keyword signals the end of the expression and
 219                      will be processed separately.  */
 220                   rewind_to_char ('t');
 221                   return 0;
 222                 }
 223
 224         /* ADA KEYWORDS */
 225
 226 abs             { return ABS; }
 227 and             { return _AND_; }
 228 else            { return ELSE; }
 229 in              { return IN; }
 230 mod             { return MOD; }
 231 new             { return NEW; }
 232 not             { return NOT; }
 233 null            { return NULL_PTR; }
 234 or              { return OR; }
 235 others          { return OTHERS; }
 236 rem             { return REM; }
 237 then            { return THEN; }
 238 xor             { return XOR; }
 239
 240         /* BOOLEAN "KEYWORDS" */
 241
 242  /* True and False are not keywords in Ada, but rather enumeration constants.
 243     However, the boolean type is no longer represented as an enum, so True
 244     and False are no longer defined in symbol tables.  We compromise by
 245     making them keywords (when bare). */
 246
 247 true            { return TRUEKEYWORD; }
 248 false           { return FALSEKEYWORD; }
 249
 250         /* ATTRIBUTES */
 251
 252 {TICK}([a-z][a-z_]*)?{COMPLETE}? { BEGIN INITIAL; return processAttribute (yytext); }
 253
 254         /* PUNCTUATION */
 255
 256 "=>"            { return ARROW; }
 257 ".."            { return DOTDOT; }
 258 "**"            { return STARSTAR; }
 259 ":="            { return ASSIGN; }
 260 "/="            { return NOTEQUAL; }
 261 "<="            { return LEQ; }
 262 ">="            { return GEQ; }
 263
 264 <BEFORE_QUAL_QUOTE>"'"/{NOT_COMPLETE} { BEGIN INITIAL; return '\''; }
 265
 266 [-&*+{}@/:<>=|;\[\]] { return yytext[0]; }
 267
 268 ","             { if (paren_depth == 0 && pstate->comma_terminates)
 269                     {
 270                       rewind_to_char (',');
 271                       return 0;
 272                     }
 273                   else
 274                     return ',';
 275                 }
 276
 277 "("             { paren_depth += 1; return '('; }
 278 ")"             { if (paren_depth == 0)
 279                     {
 280                       rewind_to_char (')');
 281                       return 0;
 282                     }
 283                   else
 284                     {
 285                       paren_depth -= 1;
 286                       return ')';
 287                     }
 288                 }
 289
 290 "."{WHITE}*{ID}{COMPLETE}? {
 291                   yylval.sval = processId (yytext+1, yyleng-1);
 292                   if (yytext[yyleng - 1] == COMPLETE_CHAR)
 293                     return DOT_COMPLETE;
 294                   return DOT_ID;
 295                 }
 296
 297 "."{WHITE}*{COMPLETE} {
 298                   yylval.sval.ptr = "";
 299                   yylval.sval.length = 0;
 300                   return DOT_COMPLETE;
 301                 }
 302
 303 {ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'"|{COMPLETE})?  {
 304                   int all_posn = find_dot_all (yytext);
 305
 306                   if (all_posn == -1 && yytext[yyleng-1] == '\'')
 307                     {
 308                       BEGIN BEFORE_QUAL_QUOTE;
 309                       yyless (yyleng-1);
 310                     }
 311                   else if (all_posn >= 0)
 312                     yyless (all_posn);
 313                   bool is_completion = yytext[yyleng - 1] == COMPLETE_CHAR;
 314                   yylval.sval = processId (yytext, yyleng);
 315                   return is_completion ? NAME_COMPLETE : NAME;
 316                }
 317
 318
 319         /* GDB EXPRESSION CONSTRUCTS  */
 320
 321 "'"[^']+"'"{WHITE}*:: {
 322                   yyless (yyleng - 2);
 323                   yylval.sval = processId (yytext, yyleng);
 324                   return NAME;
 325                 }
 326
 327 "::"            { return COLONCOLON; }
 328
 329         /* REGISTERS AND GDB CONVENIENCE VARIABLES */
 330
 331 "$"({LETTER}|{DIG}|"$")*  {
 332                   yylval.sval.ptr = yytext;
 333                   yylval.sval.length = yyleng;
 334                   return DOLLAR_VARIABLE;
 335                 }
 336
 337         /* CATCH-ALL ERROR CASE */
 338
 339 .               { error (_("Invalid character '%s' in expression."), yytext); }
 340 %%
 341
 342 #include <ctype.h>
 343 /* Initialize the lexer for processing new expression. */
 344
 345 static void
 346 lexer_init (FILE *inp)
 347 {
 348   BEGIN INITIAL;
 349   paren_depth = 0;
 350   returned_complete = false;
 351   yyrestart (inp);
 352 }
 353
 354
 355 /* Copy S2 to S1, removing all underscores, and downcasing all letters.  */
 356
 357 static void
 358 canonicalizeNumeral (char *s1, const char *s2)
 359 {
 360   for (; *s2 != '\000'; s2 += 1)
 361     {
 362       if (*s2 != '_')
 363         {
 364           *s1 = tolower(*s2);
 365           s1 += 1;
 366         }
 367     }
 368   s1[0] = '\000';
 369 }
 370
 371 /* Interprets the prefix of NUM that consists of digits of the given BASE
 372    as an integer of that BASE, with the string EXP as an exponent.
 373    Puts value in yylval, and returns INT, if the string is valid.  Causes
 374    an error if the number is improperly formated.   BASE, if NULL, defaults
 375    to "10", and EXP to "1".  The EXP does not contain a leading 'e' or 'E'.
 376  */
 377
 378 static int
 379 processInt (struct parser_state *par_state, const char *base0,
 380             const char *num0, const char *exp0)
 381 {
 382   long exp;
 383   int base;
 384   /* For the based literal with an "f" prefix, we'll return a
 385      floating-point number.  This counts the the number of "l"s seen,
 386      to decide the width of the floating-point number to return.  -1
 387      means no "f".  */
 388   int floating_point_l_count = -1;
 389
 390   if (base0 == NULL)
 391     base = 10;
 392   else
 393     {
 394       char *end_of_base;
 395       base = strtol (base0, &end_of_base, 10);
 396       if (base < 2 || base > 16)
 397         error (_("Invalid base: %d."), base);
 398       while (*end_of_base == 'l')
 399         {
 400           ++floating_point_l_count;
 401           ++end_of_base;
 402         }
 403       /* This assertion is ensured by the pattern.  */
 404       gdb_assert (floating_point_l_count == -1 || *end_of_base == 'f');
 405       if (*end_of_base == 'f')
 406         {
 407           ++end_of_base;
 408           ++floating_point_l_count;
 409         }
 410       /* This assertion is ensured by the pattern.  */
 411       gdb_assert (*end_of_base == '#');
 412     }
 413
 414   if (exp0 == NULL)
 415     exp = 0;
 416   else
 417     exp = strtol(exp0, (char **) NULL, 10);
 418
 419   gdb_mpz result;
 420   while (isxdigit (*num0))
 421     {
 422       int dig = fromhex (*num0);
 423       if (dig >= base)
 424         error (_("Invalid digit `%c' in based literal"), *num0);
 425       mpz_mul_ui (result.val, result.val, base);
 426       mpz_add_ui (result.val, result.val, dig);
 427       ++num0;
 428     }
 429
 430   while (exp > 0)
 431     {
 432       mpz_mul_ui (result.val, result.val, base);
 433       exp -= 1;
 434     }
 435
 436   if (floating_point_l_count > -1)
 437     {
 438       struct type *fp_type;
 439       if (floating_point_l_count == 0)
 440         fp_type = language_lookup_primitive_type (par_state->language (),
 441                                                   par_state->gdbarch (),
 442                                                   "float");
 443       else if (floating_point_l_count == 1)
 444         fp_type = language_lookup_primitive_type (par_state->language (),
 445                                                   par_state->gdbarch (),
 446                                                   "long_float");
 447       else
 448         {
 449           /* This assertion is ensured by the pattern.  */
 450           gdb_assert (floating_point_l_count == 2);
 451           fp_type = language_lookup_primitive_type (par_state->language (),
 452                                                     par_state->gdbarch (),
 453                                                     "long_long_float");
 454         }
 455
 456       yylval.typed_val_float.type = fp_type;
 457       result.write (gdb::make_array_view (yylval.typed_val_float.val,
 458                                           fp_type->length ()),
 459                     type_byte_order (fp_type),
 460                     true);
 461
 462       return FLOAT;
 463     }
 464
 465   gdb_mpz maxval (ULONGEST_MAX);
 466   if (mpz_cmp (result.val, maxval.val) > 0)
 467     error (_("Integer literal out of range"));
 468
 469   int int_bits = gdbarch_int_bit (par_state->gdbarch ());
 470   int long_bits = gdbarch_long_bit (par_state->gdbarch ());
 471   int long_long_bits = gdbarch_long_long_bit (par_state->gdbarch ());
 472
 473   ULONGEST value = result.as_integer<ULONGEST> ();
 474   if (fits_in_type (1, value, int_bits, true))
 475     yylval.typed_val.type = type_int (par_state);
 476   else if (fits_in_type (1, value, long_bits, true))
 477     yylval.typed_val.type = type_long (par_state);
 478   else if (fits_in_type (1, value, long_bits, false))
 479     {
 480       /* We have a number representable as an unsigned integer quantity.
 481          For consistency with the C treatment, we will treat it as an
 482          anonymous modular (unsigned) quantity.  Alas, the types are such
 483          that we need to store .val as a signed quantity.  Sorry
 484          for the mess, but C doesn't officially guarantee that a simple
 485          assignment does the trick (no, it doesn't; read the reference manual).
 486        */
 487       yylval.typed_val.type
 488         = builtin_type (par_state->gdbarch ())->builtin_unsigned_long;
 489       if (value & LONGEST_SIGN)
 490         yylval.typed_val.val =
 491           (LONGEST) (value & ~LONGEST_SIGN)
 492           - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
 493       else
 494         yylval.typed_val.val = (LONGEST) value;
 495       return INT;
 496     }
 497   else if (fits_in_type (1, value, long_long_bits, true))
 498     yylval.typed_val.type = type_long_long (par_state);
 499   else if (fits_in_type (1, value, long_long_bits, false))
 500     {
 501       yylval.typed_val.type
 502         = builtin_type (par_state->gdbarch ())->builtin_unsigned_long_long;
 503       /* See unsigned long case above.  */
 504       if (value & LONGEST_SIGN)
 505         yylval.typed_val.val =
 506           (LONGEST) (value & ~LONGEST_SIGN)
 507           - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
 508       else
 509         yylval.typed_val.val = (LONGEST) value;
 510       return INT;
 511     }
 512   else
 513     error (_("Integer literal out of range"));
 514
 515   yylval.typed_val.val = value;
 516   return INT;
 517 }
 518
 519 static int
 520 processReal (struct parser_state *par_state, const char *num0)
 521 {
 522   yylval.typed_val_float.type = type_long_double (par_state);
 523
 524   bool parsed = parse_float (num0, strlen (num0),
 525                              yylval.typed_val_float.type,
 526                              yylval.typed_val_float.val);
 527   gdb_assert (parsed);
 528   return FLOAT;
 529 }
 530
 531
 532 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.  The
 533    resulting string is valid until the next call to ada_parse.  If
 534    NAME0 contains the substring "___", it is assumed to be already
 535    encoded and the resulting name is equal to it.  Similarly, if the name
 536    starts with '<', it is copied verbatim.  Otherwise, it differs
 537    from NAME0 in that:
 538     + Characters between '...' are transfered verbatim to yylval.ssym.
 539     + Trailing "'" characters in quoted sequences are removed (a leading quote is
 540       preserved to indicate that the name is not to be GNAT-encoded).
 541     + Unquoted whitespace is removed.
 542     + Unquoted alphabetic characters are mapped to lower case.
 543    Result is returned as a struct stoken, but for convenience, the string
 544    is also null-terminated.  Result string valid until the next call of
 545    ada_parse.
 546  */
 547 static struct stoken
 548 processId (const char *name0, int len)
 549 {
 550   char *name = (char *) obstack_alloc (&temp_parse_space, len + 11);
 551   int i0, i;
 552   struct stoken result;
 553
 554   result.ptr = name;
 555   while (len > 0 && isspace (name0[len-1]))
 556     len -= 1;
 557
 558   if (name0[0] == '<' || strstr (name0, "___") != NULL)
 559     {
 560       strncpy (name, name0, len);
 561       name[len] = '\000';
 562       result.length = len;
 563       return result;
 564     }
 565
 566   bool in_quotes = false;
 567   i = i0 = 0;
 568   while (i0 < len)
 569     {
 570       if (name0[i0] == COMPLETE_CHAR)
 571         {
 572           /* Just ignore.  */
 573           ++i0;
 574         }
 575       else if (in_quotes)
 576         name[i++] = name0[i0++];
 577       else if (isalnum (name0[i0]))
 578         {
 579           name[i] = tolower (name0[i0]);
 580           i += 1; i0 += 1;
 581         }
 582       else if (isspace (name0[i0]))
 583         i0 += 1;
 584       else if (name0[i0] == '\'')
 585         {
 586           /* Copy the starting quote, but not the ending quote.  */
 587           if (!in_quotes)
 588             name[i++] = name0[i0++];
 589           in_quotes = !in_quotes;
 590         }
 591       else
 592         name[i++] = name0[i0++];
 593     }
 594   name[i] = '\000';
 595
 596   result.length = i;
 597   return result;
 598 }
 599
 600 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
 601    with special hex character notations replaced with characters.
 602    Result valid until the next call to ada_parse.  */
 603
 604 static struct stoken
 605 processString (const char *text, int len)
 606 {
 607   const char *p;
 608   char *q;
 609   const char *lim = text + len;
 610   struct stoken result;
 611
 612   q = (char *) obstack_alloc (&temp_parse_space, len);
 613   result.ptr = q;
 614   p = text;
 615   while (p < lim)
 616     {
 617       if (p[0] == '[' && p[1] == '"' && p+2 < lim)
 618          {
 619            if (p[2] == '"')  /* "...["""]... */
 620              {
 621                *q = '"';
 622                p += 4;
 623              }
 624            else
 625              {
 626                const char *end;
 627                ULONGEST chr = strtoulst (p + 2, &end, 16);
 628                if (chr > 0xff)
 629                  error (_("wide strings are not yet supported"));
 630                *q = (char) chr;
 631                p = end + 1;
 632              }
 633          }
 634        else
 635          *q = *p;
 636        q += 1;
 637        p += 1;
 638      }
 639   result.length = q - result.ptr;
 640   return result;
 641 }
 642
 643 /* Returns the position within STR of the '.' in a
 644    '.{WHITE}*all' component of a dotted name, or -1 if there is none.
 645    Note: we actually don't need this routine, since 'all' can never be an
 646    Ada identifier.  Thus, looking up foo.all or foo.all.x as a name
 647    must fail, and will eventually be interpreted as (foo).all or
 648    (foo).all.x.  However, this does avoid an extraneous lookup. */
 649
 650 static int
 651 find_dot_all (const char *str)
 652 {
 653   int i;
 654
 655   for (i = 0; str[i] != '\000'; i++)
 656     if (str[i] == '.')
 657       {
 658         int i0 = i;
 659
 660         do
 661           i += 1;
 662         while (isspace (str[i]));
 663
 664         if (strncasecmp (str + i, "all", 3) == 0
 665             && !isalnum (str[i + 3]) && str[i + 3] != '_')
 666           return i0;
 667       }
 668   return -1;
 669 }
 670
 671 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
 672    case.  */
 673
 674 static int
 675 subseqMatch (const char *subseq, const char *str)
 676 {
 677   if (subseq[0] == '\0')
 678     return 1;
 679   else if (str[0] == '\0')
 680     return 0;
 681   else if (tolower (subseq[0]) == tolower (str[0]))
 682     return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
 683   else
 684     return subseqMatch (subseq, str+1);
 685 }
 686
 687
 688 static struct { const char *name; int code; }
 689 attributes[] = {
 690   { "address", TICK_ADDRESS },
 691   { "unchecked_access", TICK_ACCESS },
 692   { "unrestricted_access", TICK_ACCESS },
 693   { "access", TICK_ACCESS },
 694   { "first", TICK_FIRST },
 695   { "last", TICK_LAST },
 696   { "length", TICK_LENGTH },
 697   { "max", TICK_MAX },
 698   { "min", TICK_MIN },
 699   { "modulus", TICK_MODULUS },
 700   { "pos", TICK_POS },
 701   { "range", TICK_RANGE },
 702   { "size", TICK_SIZE },
 703   { "tag", TICK_TAG },
 704   { "val", TICK_VAL },
 705 };
 706
 707 /* Return the syntactic code corresponding to the attribute name or
 708    abbreviation STR.  */
 709
 710 static int
 711 processAttribute (const char *str)
 712 {
 713   gdb_assert (*str == '\'');
 714   ++str;
 715   while (isspace (*str))
 716     ++str;
 717
 718   int len = strlen (str);
 719   if (len > 0 && str[len - 1] == COMPLETE_CHAR)
 720     {
 721       /* This is enforced by YY_INPUT.  */
 722       gdb_assert (pstate->parse_completion);
 723       yylval.sval.ptr = obstack_strndup (&temp_parse_space, str, len - 1);
 724       yylval.sval.length = len - 1;
 725       return TICK_COMPLETE;
 726     }
 727
 728   for (const auto &item : attributes)
 729     if (strcasecmp (str, item.name) == 0)
 730       return item.code;
 731
 732   gdb::optional<int> found;
 733   for (const auto &item : attributes)
 734     if (subseqMatch (str, item.name))
 735       {
 736         if (!found.has_value ())
 737           found = item.code;
 738         else
 739           error (_("ambiguous attribute name: `%s'"), str);
 740       }
 741   if (!found.has_value ())
 742     error (_("unrecognized attribute: `%s'"), str);
 743
 744   return *found;
 745 }
 746
 747 bool
 748 ada_tick_completer::complete (struct expression *exp,
 749                               completion_tracker &tracker)
 750 {
 751   completion_list output;
 752   for (const auto &item : attributes)
 753     {
 754       if (strncasecmp (item.name, m_name.c_str (), m_name.length ()) == 0)
 755         output.emplace_back (xstrdup (item.name));
 756     }
 757   tracker.add_completions (std::move (output));
 758   return true;
 759 }
 760
 761 /* Back up lexptr by yyleng and then to the rightmost occurrence of
 762    character CH, case-folded (there must be one).  WARNING: since
 763    lexptr points to the next input character that Flex has not yet
 764    transferred to its internal buffer, the use of this function
 765    depends on the assumption that Flex calls YY_INPUT only when it is
 766    logically necessary to do so (thus, there is no reading ahead
 767    farther than needed to identify the next token.)  */
 768
 769 static void
 770 rewind_to_char (int ch)
 771 {
 772   pstate->lexptr -= yyleng;
 773   while (toupper (*pstate->lexptr) != toupper (ch))
 774     pstate->lexptr -= 1;
 775   yyrestart (NULL);
 776 }
 777
 778 /* Dummy definition to suppress warnings about unused static definitions. */
 779 typedef void (*dummy_function) ();
 780 dummy_function ada_flex_use[] =
 781 {
 782   (dummy_function) yyunput
 783 };
 784
 785 DIAGNOSTIC_POP