1 /* FLEX lexer for Ada expressions, for GDB.
2 Copyright (C) 1994-2021 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
19 /*----------------------------------------------------------------------*/
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. */
28 NUM10 ({DIG}({DIG}|_)*)
30 NUM16 ({HEXDIG}({HEXDIG}|_)*)
33 ID ({LETTER}({LETTER}|{DIG})*|"<"{LETTER}({LETTER}|{DIG})*">")
36 GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
37 OPER ([-+*/=<>&]|"<="|">="|"**"|"/="|"and"|"or"|"xor"|"not"|"mod"|"rem"|"abs")
44 #include "diagnostics.h"
46 /* Some old versions of flex generate code that uses the "register" keyword,
47 which clang warns about. This was observed for example with flex 2.5.35,
48 as shipped with macOS 10.12. The same happens with flex 2.5.37 and g++ 11
49 which defaults to ISO C++17, that does not allow register storage class
52 DIAGNOSTIC_IGNORE_DEPRECATED_REGISTER
54 #define NUMERAL_WIDTH 256
55 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
57 /* Temporary staging for numeric literals. */
58 static char numbuf[NUMERAL_WIDTH];
59 static void canonicalizeNumeral (char *s1, const char *);
60 static struct stoken processString (const char*, int);
61 static int processInt (struct parser_state *, const char *, const char *,
63 static int processReal (struct parser_state *, const char *);
64 static struct stoken processId (const char *, int);
65 static int processAttribute (const char *);
66 static int find_dot_all (const char *);
67 static void rewind_to_char (int);
70 #define YY_DECL static int yylex ( void )
72 /* Flex generates a static function "input" which is not used.
73 Defining YY_NO_INPUT comments it out. */
77 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
78 if ( *pstate->lexptr == '\000' ) \
82 *(BUF) = *pstate->lexptr; \
84 pstate->lexptr += 1; \
87 static int find_dot_all (const char *);
89 /* Depth of parentheses. */
90 static int paren_depth;
94 %option case-insensitive interactive nodefault noyywrap
102 "--".* { yyterminate(); }
105 canonicalizeNumeral (numbuf, yytext);
106 return processInt (pstate, NULL, numbuf,
107 strrchr (numbuf, 'e') + 1);
111 canonicalizeNumeral (numbuf, yytext);
112 return processInt (pstate, NULL, numbuf, NULL);
115 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
116 canonicalizeNumeral (numbuf, yytext);
117 return processInt (pstate, numbuf,
118 strchr (numbuf, '#') + 1,
119 strrchr(numbuf, '#') + 1);
122 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
123 canonicalizeNumeral (numbuf, yytext);
124 return processInt (pstate, numbuf, strchr (numbuf, '#') + 1,
129 canonicalizeNumeral (numbuf, yytext+2);
130 return processInt (pstate, "16#", numbuf, NULL);
134 {NUM10}"."{NUM10}{EXP} {
135 canonicalizeNumeral (numbuf, yytext);
136 return processReal (pstate, numbuf);
140 canonicalizeNumeral (numbuf, yytext);
141 return processReal (pstate, numbuf);
144 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
145 error (_("Based real literals not implemented yet."));
148 {NUM10}"#"{NUM16}"."{NUM16}"#" {
149 error (_("Based real literals not implemented yet."));
152 <INITIAL>"'"({GRAPHIC}|\")"'" {
153 yylval.typed_val.type = type_char (pstate);
154 yylval.typed_val.val = yytext[1];
158 <INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
160 yylval.typed_val.type = type_char (pstate);
161 sscanf (yytext+3, "%2x", &v);
162 yylval.typed_val.val = v;
166 \"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\" {
167 yylval.sval = processString (yytext+1, yyleng-2);
172 error (_("ill-formed or non-terminated string literal"));
177 rewind_to_char ('i');
182 rewind_to_char ('t');
186 thread{WHITE}+{DIG} {
187 /* This keyword signals the end of the expression and
188 will be processed separately. */
189 rewind_to_char ('t');
196 and { return _AND_; }
197 else { return ELSE; }
202 null { return NULL_PTR; }
204 others { return OTHERS; }
206 then { return THEN; }
209 /* BOOLEAN "KEYWORDS" */
211 /* True and False are not keywords in Ada, but rather enumeration constants.
212 However, the boolean type is no longer represented as an enum, so True
213 and False are no longer defined in symbol tables. We compromise by
214 making them keywords (when bare). */
216 true { return TRUEKEYWORD; }
217 false { return FALSEKEYWORD; }
221 {TICK}[a-zA-Z][a-zA-Z_]+ { BEGIN INITIAL; return processAttribute (yytext+1); }
225 "=>" { return ARROW; }
226 ".." { return DOTDOT; }
227 "**" { return STARSTAR; }
228 ":=" { return ASSIGN; }
229 "/=" { return NOTEQUAL; }
233 <BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
235 [-&*+./:<>=|;\[\]] { return yytext[0]; }
237 "," { if (paren_depth == 0 && pstate->comma_terminates)
239 rewind_to_char (',');
246 "(" { paren_depth += 1; return '('; }
247 ")" { if (paren_depth == 0)
249 rewind_to_char (')');
259 "."{WHITE}*all { return DOT_ALL; }
262 yylval.sval = processId (yytext+1, yyleng-1);
266 {ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")? {
267 int all_posn = find_dot_all (yytext);
269 if (all_posn == -1 && yytext[yyleng-1] == '\'')
271 BEGIN BEFORE_QUAL_QUOTE;
274 else if (all_posn >= 0)
276 yylval.sval = processId (yytext, yyleng);
281 /* GDB EXPRESSION CONSTRUCTS */
283 "'"[^']+"'"{WHITE}*:: {
285 yylval.sval = processId (yytext, yyleng);
289 "::" { return COLONCOLON; }
291 [{}@] { return yytext[0]; }
293 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
295 "$"({LETTER}|{DIG}|"$")* {
296 yylval.sval.ptr = yytext;
297 yylval.sval.length = yyleng;
298 return DOLLAR_VARIABLE;
301 /* CATCH-ALL ERROR CASE */
303 . { error (_("Invalid character '%s' in expression."), yytext); }
307 /* Initialize the lexer for processing new expression. */
310 lexer_init (FILE *inp)
318 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */
321 canonicalizeNumeral (char *s1, const char *s2)
323 for (; *s2 != '\000'; s2 += 1)
334 /* Interprets the prefix of NUM that consists of digits of the given BASE
335 as an integer of that BASE, with the string EXP as an exponent.
336 Puts value in yylval, and returns INT, if the string is valid. Causes
337 an error if the number is improperly formated. BASE, if NULL, defaults
338 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
342 processInt (struct parser_state *par_state, const char *base0,
343 const char *num0, const char *exp0)
354 base = strtol (base0, (char **) NULL, 10);
355 if (base < 2 || base > 16)
356 error (_("Invalid base: %d."), base);
362 exp = strtol(exp0, (char **) NULL, 10);
365 result = strtoulst (num0, &trailer, base);
367 error (_("Integer literal out of range"));
368 if (isxdigit(*trailer))
369 error (_("Invalid digit `%c' in based literal"), *trailer);
373 if (result > (ULONG_MAX / base))
374 error (_("Integer literal out of range"));
379 if ((result >> (gdbarch_int_bit (par_state->gdbarch ())-1)) == 0)
380 yylval.typed_val.type = type_int (par_state);
381 else if ((result >> (gdbarch_long_bit (par_state->gdbarch ())-1)) == 0)
382 yylval.typed_val.type = type_long (par_state);
383 else if (((result >> (gdbarch_long_bit (par_state->gdbarch ())-1)) >> 1) == 0)
385 /* We have a number representable as an unsigned integer quantity.
386 For consistency with the C treatment, we will treat it as an
387 anonymous modular (unsigned) quantity. Alas, the types are such
388 that we need to store .val as a signed quantity. Sorry
389 for the mess, but C doesn't officially guarantee that a simple
390 assignment does the trick (no, it doesn't; read the reference manual).
392 yylval.typed_val.type
393 = builtin_type (par_state->gdbarch ())->builtin_unsigned_long;
394 if (result & LONGEST_SIGN)
395 yylval.typed_val.val =
396 (LONGEST) (result & ~LONGEST_SIGN)
397 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
399 yylval.typed_val.val = (LONGEST) result;
403 yylval.typed_val.type = type_long_long (par_state);
405 yylval.typed_val.val = (LONGEST) result;
410 processReal (struct parser_state *par_state, const char *num0)
412 yylval.typed_val_float.type = type_long_double (par_state);
414 bool parsed = parse_float (num0, strlen (num0),
415 yylval.typed_val_float.type,
416 yylval.typed_val_float.val);
422 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
423 resulting string is valid until the next call to ada_parse. If
424 NAME0 contains the substring "___", it is assumed to be already
425 encoded and the resulting name is equal to it. Similarly, if the name
426 starts with '<', it is copied verbatim. Otherwise, it differs
428 + Characters between '...' are transfered verbatim to yylval.ssym.
429 + Trailing "'" characters in quoted sequences are removed (a leading quote is
430 preserved to indicate that the name is not to be GNAT-encoded).
431 + Unquoted whitespace is removed.
432 + Unquoted alphabetic characters are mapped to lower case.
433 Result is returned as a struct stoken, but for convenience, the string
434 is also null-terminated. Result string valid until the next call of
438 processId (const char *name0, int len)
440 char *name = (char *) obstack_alloc (&temp_parse_space, len + 11);
442 struct stoken result;
445 while (len > 0 && isspace (name0[len-1]))
448 if (name0[0] == '<' || strstr (name0, "___") != NULL)
450 strncpy (name, name0, len);
459 if (isalnum (name0[i0]))
461 name[i] = tolower (name0[i0]);
464 else switch (name0[i0])
479 while (i0 < len && name0[i0] != '\'');
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. */
495 processString (const char *text, int len)
499 const char *lim = text + len;
500 struct stoken result;
502 q = (char *) obstack_alloc (&temp_parse_space, len);
507 if (p[0] == '[' && p[1] == '"' && p+2 < lim)
509 if (p[2] == '"') /* "...["""]... */
517 sscanf (p+2, "%2x", &chr);
527 result.length = q - result.ptr;
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. */
539 find_dot_all (const char *str)
543 for (i = 0; str[i] != '\000'; i++)
550 while (isspace (str[i]));
552 if (strncasecmp (str + i, "all", 3) == 0
553 && !isalnum (str[i + 3]) && str[i + 3] != '_')
559 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
563 subseqMatch (const char *subseq, const char *str)
565 if (subseq[0] == '\0')
567 else if (str[0] == '\0')
569 else if (tolower (subseq[0]) == tolower (str[0]))
570 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
572 return subseqMatch (subseq, str+1);
576 static struct { const char *name; int code; }
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 },
587 { "modulus", TICK_MODULUS },
589 { "range", TICK_RANGE },
590 { "size", TICK_SIZE },
596 /* Return the syntactic code corresponding to the attribute name or
600 processAttribute (const char *str)
604 for (i = 0; attributes[i].code != -1; i += 1)
605 if (strcasecmp (str, attributes[i].name) == 0)
606 return attributes[i].code;
608 for (i = 0, k = -1; attributes[i].code != -1; i += 1)
609 if (subseqMatch (str, attributes[i].name))
614 error (_("ambiguous attribute name: `%s'"), str);
617 error (_("unrecognized attribute: `%s'"), str);
619 return attributes[k].code;
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.) */
631 rewind_to_char (int ch)
633 pstate->lexptr -= yyleng;
634 while (toupper (*pstate->lexptr) != toupper (ch))
639 /* Dummy definition to suppress warnings about unused static definitions. */
640 typedef void (*dummy_function) ();
641 dummy_function ada_flex_use[] =
643 (dummy_function) yyunput