1 /* FLEX lexer for Ada expressions, for GDB.
2 Copyright (C) 1994-2017 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 "common/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. */
50 DIAGNOSTIC_IGNORE_DEPRECATED_REGISTER
52 #define NUMERAL_WIDTH 256
53 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
55 /* Temporary staging for numeric literals. */
56 static char numbuf[NUMERAL_WIDTH];
57 static void canonicalizeNumeral (char *s1, const char *);
58 static struct stoken processString (const char*, int);
59 static int processInt (struct parser_state *, const char *, const char *,
61 static int processReal (struct parser_state *, const char *);
62 static struct stoken processId (const char *, int);
63 static int processAttribute (const char *);
64 static int find_dot_all (const char *);
65 static void rewind_to_char (int);
68 #define YY_DECL static int yylex ( void )
70 /* Flex generates a static function "input" which is not used.
71 Defining YY_NO_INPUT comments it out. */
75 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
76 if ( *lexptr == '\000' ) \
85 static int find_dot_all (const char *);
89 %option case-insensitive interactive nodefault
97 "--".* { yyterminate(); }
100 canonicalizeNumeral (numbuf, yytext);
101 return processInt (pstate, NULL, numbuf,
102 strrchr (numbuf, 'e') + 1);
106 canonicalizeNumeral (numbuf, yytext);
107 return processInt (pstate, NULL, numbuf, NULL);
110 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
111 canonicalizeNumeral (numbuf, yytext);
112 return processInt (pstate, numbuf,
113 strchr (numbuf, '#') + 1,
114 strrchr(numbuf, '#') + 1);
117 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
118 canonicalizeNumeral (numbuf, yytext);
119 return processInt (pstate, numbuf, strchr (numbuf, '#') + 1,
124 canonicalizeNumeral (numbuf, yytext+2);
125 return processInt (pstate, "16#", numbuf, NULL);
129 {NUM10}"."{NUM10}{EXP} {
130 canonicalizeNumeral (numbuf, yytext);
131 return processReal (pstate, numbuf);
135 canonicalizeNumeral (numbuf, yytext);
136 return processReal (pstate, numbuf);
139 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
140 error (_("Based real literals not implemented yet."));
143 {NUM10}"#"{NUM16}"."{NUM16}"#" {
144 error (_("Based real literals not implemented yet."));
147 <INITIAL>"'"({GRAPHIC}|\")"'" {
148 yylval.typed_val.type = type_char (pstate);
149 yylval.typed_val.val = yytext[1];
153 <INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
155 yylval.typed_val.type = type_char (pstate);
156 sscanf (yytext+3, "%2x", &v);
157 yylval.typed_val.val = v;
161 \"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\" {
162 yylval.sval = processString (yytext+1, yyleng-2);
167 error (_("ill-formed or non-terminated string literal"));
172 rewind_to_char ('i');
177 rewind_to_char ('t');
181 thread{WHITE}+{DIG} {
182 /* This keyword signals the end of the expression and
183 will be processed separately. */
184 rewind_to_char ('t');
191 and { return _AND_; }
192 else { return ELSE; }
197 null { return NULL_PTR; }
199 others { return OTHERS; }
201 then { return THEN; }
204 /* BOOLEAN "KEYWORDS" */
206 /* True and False are not keywords in Ada, but rather enumeration constants.
207 However, the boolean type is no longer represented as an enum, so True
208 and False are no longer defined in symbol tables. We compromise by
209 making them keywords (when bare). */
211 true { return TRUEKEYWORD; }
212 false { return FALSEKEYWORD; }
216 {TICK}[a-zA-Z][a-zA-Z]+ { BEGIN INITIAL; return processAttribute (yytext+1); }
220 "=>" { return ARROW; }
221 ".." { return DOTDOT; }
222 "**" { return STARSTAR; }
223 ":=" { return ASSIGN; }
224 "/=" { return NOTEQUAL; }
228 <BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
230 [-&*+./:<>=|;\[\]] { return yytext[0]; }
232 "," { if (paren_depth == 0 && comma_terminates)
234 rewind_to_char (',');
241 "(" { paren_depth += 1; return '('; }
242 ")" { if (paren_depth == 0)
244 rewind_to_char (')');
254 "."{WHITE}*all { return DOT_ALL; }
257 yylval.sval = processId (yytext+1, yyleng-1);
261 {ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")? {
262 int all_posn = find_dot_all (yytext);
264 if (all_posn == -1 && yytext[yyleng-1] == '\'')
266 BEGIN BEFORE_QUAL_QUOTE;
269 else if (all_posn >= 0)
271 yylval.sval = processId (yytext, yyleng);
276 /* GDB EXPRESSION CONSTRUCTS */
278 "'"[^']+"'"{WHITE}*:: {
280 yylval.sval = processId (yytext, yyleng);
284 "::" { return COLONCOLON; }
286 [{}@] { return yytext[0]; }
288 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
290 "$"({LETTER}|{DIG}|"$")* {
291 yylval.sval.ptr = yytext;
292 yylval.sval.length = yyleng;
293 return SPECIAL_VARIABLE;
296 /* CATCH-ALL ERROR CASE */
298 . { error (_("Invalid character '%s' in expression."), yytext); }
302 /* Initialize the lexer for processing new expression. */
305 lexer_init (FILE *inp)
312 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */
315 canonicalizeNumeral (char *s1, const char *s2)
317 for (; *s2 != '\000'; s2 += 1)
328 /* Interprets the prefix of NUM that consists of digits of the given BASE
329 as an integer of that BASE, with the string EXP as an exponent.
330 Puts value in yylval, and returns INT, if the string is valid. Causes
331 an error if the number is improperly formated. BASE, if NULL, defaults
332 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
336 processInt (struct parser_state *par_state, const char *base0,
337 const char *num0, const char *exp0)
348 base = strtol (base0, (char **) NULL, 10);
349 if (base < 2 || base > 16)
350 error (_("Invalid base: %d."), base);
356 exp = strtol(exp0, (char **) NULL, 10);
359 result = strtoulst (num0, &trailer, base);
361 error (_("Integer literal out of range"));
362 if (isxdigit(*trailer))
363 error (_("Invalid digit `%c' in based literal"), *trailer);
367 if (result > (ULONG_MAX / base))
368 error (_("Integer literal out of range"));
373 if ((result >> (gdbarch_int_bit (parse_gdbarch (par_state))-1)) == 0)
374 yylval.typed_val.type = type_int (par_state);
375 else if ((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) == 0)
376 yylval.typed_val.type = type_long (par_state);
377 else if (((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) >> 1) == 0)
379 /* We have a number representable as an unsigned integer quantity.
380 For consistency with the C treatment, we will treat it as an
381 anonymous modular (unsigned) quantity. Alas, the types are such
382 that we need to store .val as a signed quantity. Sorry
383 for the mess, but C doesn't officially guarantee that a simple
384 assignment does the trick (no, it doesn't; read the reference manual).
386 yylval.typed_val.type
387 = builtin_type (parse_gdbarch (par_state))->builtin_unsigned_long;
388 if (result & LONGEST_SIGN)
389 yylval.typed_val.val =
390 (LONGEST) (result & ~LONGEST_SIGN)
391 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
393 yylval.typed_val.val = (LONGEST) result;
397 yylval.typed_val.type = type_long_long (par_state);
399 yylval.typed_val.val = (LONGEST) result;
404 processReal (struct parser_state *par_state, const char *num0)
406 sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
408 yylval.typed_val_float.type = type_float (par_state);
409 if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch (par_state))
411 yylval.typed_val_float.type = type_double (par_state);
412 if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch (par_state))
414 yylval.typed_val_float.type = type_long_double (par_state);
420 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
421 resulting string is valid until the next call to ada_parse. If
422 NAME0 contains the substring "___", it is assumed to be already
423 encoded and the resulting name is equal to it. Otherwise, it differs
425 + Characters between '...' or <...> are transfered verbatim to
427 + <, >, and trailing "'" characters in quoted sequences are removed
428 (a leading quote is preserved to indicate that the name is not to be
430 + Unquoted whitespace is removed.
431 + Unquoted alphabetic characters are mapped to lower case.
432 Result is returned as a struct stoken, but for convenience, the string
433 is also null-terminated. Result string valid until the next call of
437 processId (const char *name0, int len)
439 char *name = (char *) obstack_alloc (&temp_parse_space, len + 11);
441 struct stoken result;
444 while (len > 0 && isspace (name0[len-1]))
447 if (strstr (name0, "___") != NULL)
449 strncpy (name, name0, len);
458 if (isalnum (name0[i0]))
460 name[i] = tolower (name0[i0]);
463 else switch (name0[i0])
478 while (i0 < len && name0[i0] != '\'');
483 while (i0 < len && name0[i0] != '>')
498 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
499 with special hex character notations replaced with characters.
500 Result valid until the next call to ada_parse. */
503 processString (const char *text, int len)
507 const char *lim = text + len;
508 struct stoken result;
510 q = (char *) obstack_alloc (&temp_parse_space, len);
515 if (p[0] == '[' && p[1] == '"' && p+2 < lim)
517 if (p[2] == '"') /* "...["""]... */
525 sscanf (p+2, "%2x", &chr);
535 result.length = q - result.ptr;
539 /* Returns the position within STR of the '.' in a
540 '.{WHITE}*all' component of a dotted name, or -1 if there is none.
541 Note: we actually don't need this routine, since 'all' can never be an
542 Ada identifier. Thus, looking up foo.all or foo.all.x as a name
543 must fail, and will eventually be interpreted as (foo).all or
544 (foo).all.x. However, this does avoid an extraneous lookup. */
547 find_dot_all (const char *str)
551 for (i = 0; str[i] != '\000'; i++)
558 while (isspace (str[i]));
560 if (strncasecmp (str + i, "all", 3) == 0
561 && !isalnum (str[i + 3]) && str[i + 3] != '_')
567 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
571 subseqMatch (const char *subseq, const char *str)
573 if (subseq[0] == '\0')
575 else if (str[0] == '\0')
577 else if (tolower (subseq[0]) == tolower (str[0]))
578 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
580 return subseqMatch (subseq, str+1);
584 static struct { const char *name; int code; }
586 { "address", TICK_ADDRESS },
587 { "unchecked_access", TICK_ACCESS },
588 { "unrestricted_access", TICK_ACCESS },
589 { "access", TICK_ACCESS },
590 { "first", TICK_FIRST },
591 { "last", TICK_LAST },
592 { "length", TICK_LENGTH },
595 { "modulus", TICK_MODULUS },
597 { "range", TICK_RANGE },
598 { "size", TICK_SIZE },
604 /* Return the syntactic code corresponding to the attribute name or
608 processAttribute (const char *str)
612 for (i = 0; attributes[i].code != -1; i += 1)
613 if (strcasecmp (str, attributes[i].name) == 0)
614 return attributes[i].code;
616 for (i = 0, k = -1; attributes[i].code != -1; i += 1)
617 if (subseqMatch (str, attributes[i].name))
622 error (_("ambiguous attribute name: `%s'"), str);
625 error (_("unrecognized attribute: `%s'"), str);
627 return attributes[k].code;
630 /* Back up lexptr by yyleng and then to the rightmost occurrence of
631 character CH, case-folded (there must be one). WARNING: since
632 lexptr points to the next input character that Flex has not yet
633 transferred to its internal buffer, the use of this function
634 depends on the assumption that Flex calls YY_INPUT only when it is
635 logically necessary to do so (thus, there is no reading ahead
636 farther than needed to identify the next token.) */
639 rewind_to_char (int ch)
642 while (toupper (*lexptr) != toupper (ch))
653 /* Dummy definition to suppress warnings about unused static definitions. */
654 typedef void (*dummy_function) ();
655 dummy_function ada_flex_use[] =
657 (dummy_function) yyunput