1 /* FLEX lexer for Ada expressions, for GDB.
2 Copyright (C) 1994-2013 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 #define NUMERAL_WIDTH 256
45 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
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 static void rewind_to_char (int);
59 #define YY_DECL static int yylex ( void )
61 /* Flex generates a static function "input" which is not used.
62 Defining YY_NO_INPUT comments it out. */
66 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
67 if ( *lexptr == '\000' ) \
76 static int find_dot_all (const char *);
80 %option case-insensitive interactive nodefault
88 "--".* { yyterminate(); }
91 canonicalizeNumeral (numbuf, yytext);
92 return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
96 canonicalizeNumeral (numbuf, yytext);
97 return processInt (NULL, numbuf, NULL);
100 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
101 canonicalizeNumeral (numbuf, yytext);
102 return processInt (numbuf,
103 strchr (numbuf, '#') + 1,
104 strrchr(numbuf, '#') + 1);
107 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
108 canonicalizeNumeral (numbuf, yytext);
109 return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
113 canonicalizeNumeral (numbuf, yytext+2);
114 return processInt ("16#", numbuf, NULL);
118 {NUM10}"."{NUM10}{EXP} {
119 canonicalizeNumeral (numbuf, yytext);
120 return processReal (numbuf);
124 canonicalizeNumeral (numbuf, yytext);
125 return processReal (numbuf);
128 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
129 error (_("Based real literals not implemented yet."));
132 {NUM10}"#"{NUM16}"."{NUM16}"#" {
133 error (_("Based real literals not implemented yet."));
136 <INITIAL>"'"({GRAPHIC}|\")"'" {
137 yylval.typed_val.type = type_char ();
138 yylval.typed_val.val = yytext[1];
142 <INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
144 yylval.typed_val.type = type_char ();
145 sscanf (yytext+3, "%2x", &v);
146 yylval.typed_val.val = v;
150 \"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\" {
151 yylval.sval = processString (yytext+1, yyleng-2);
156 error (_("ill-formed or non-terminated string literal"));
161 rewind_to_char ('i');
166 rewind_to_char ('t');
170 thread{WHITE}+{DIG} {
171 /* This keyword signals the end of the expression and
172 will be processed separately. */
173 rewind_to_char ('t');
180 and { return _AND_; }
181 else { return ELSE; }
186 null { return NULL_PTR; }
188 others { return OTHERS; }
190 then { return THEN; }
193 /* BOOLEAN "KEYWORDS" */
195 /* True and False are not keywords in Ada, but rather enumeration constants.
196 However, the boolean type is no longer represented as an enum, so True
197 and False are no longer defined in symbol tables. We compromise by
198 making them keywords (when bare). */
200 true { return TRUEKEYWORD; }
201 false { return FALSEKEYWORD; }
205 {TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }
209 "=>" { return ARROW; }
210 ".." { return DOTDOT; }
211 "**" { return STARSTAR; }
212 ":=" { return ASSIGN; }
213 "/=" { return NOTEQUAL; }
217 <BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
219 [-&*+./:<>=|;\[\]] { return yytext[0]; }
221 "," { if (paren_depth == 0 && comma_terminates)
223 rewind_to_char (',');
230 "(" { paren_depth += 1; return '('; }
231 ")" { if (paren_depth == 0)
233 rewind_to_char (')');
243 "."{WHITE}*all { return DOT_ALL; }
246 yylval.sval = processId (yytext+1, yyleng-1);
250 {ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")? {
251 int all_posn = find_dot_all (yytext);
253 if (all_posn == -1 && yytext[yyleng-1] == '\'')
255 BEGIN BEFORE_QUAL_QUOTE;
258 else if (all_posn >= 0)
260 yylval.sval = processId (yytext, yyleng);
265 /* GDB EXPRESSION CONSTRUCTS */
267 "'"[^']+"'"{WHITE}*:: {
269 yylval.sval = processId (yytext, yyleng);
273 "::" { return COLONCOLON; }
275 [{}@] { return yytext[0]; }
277 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
279 "$"({LETTER}|{DIG}|"$")* {
280 yylval.sval.ptr = yytext;
281 yylval.sval.length = yyleng;
282 return SPECIAL_VARIABLE;
285 /* CATCH-ALL ERROR CASE */
287 . { error (_("Invalid character '%s' in expression."), yytext); }
291 #include "gdb_string.h"
293 /* Initialize the lexer for processing new expression. */
296 lexer_init (FILE *inp)
303 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */
306 canonicalizeNumeral (char *s1, const char *s2)
308 for (; *s2 != '\000'; s2 += 1)
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'.
327 processInt (const char *base0, const char *num0, const char *exp0)
339 base = strtol (base0, (char **) NULL, 10);
340 if (base < 2 || base > 16)
341 error (_("Invalid base: %d."), base);
347 exp = strtol(exp0, (char **) NULL, 10);
350 result = strtoulst (num0, (const char **) &trailer, base);
352 error (_("Integer literal out of range"));
353 if (isxdigit(*trailer))
354 error (_("Invalid digit `%c' in based literal"), *trailer);
358 if (result > (ULONG_MAX / base))
359 error (_("Integer literal out of range"));
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)
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).
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);
384 yylval.typed_val.val = (LONGEST) result;
388 yylval.typed_val.type = type_long_long ();
390 yylval.typed_val.val = (LONGEST) result;
395 processReal (const char *num0)
397 sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
399 yylval.typed_val_float.type = type_float ();
400 if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
402 yylval.typed_val_float.type = type_double ();
403 if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
405 yylval.typed_val_float.type = type_long_double ();
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
416 + Characters between '...' or <...> are transfered verbatim to
418 + <, >, and trailing "'" characters in quoted sequences are removed
419 (a leading quote is preserved to indicate that the name is not to be
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
428 processId (const char *name0, int len)
430 char *name = obstack_alloc (&temp_parse_space, len + 11);
432 struct stoken result;
435 while (len > 0 && isspace (name0[len-1]))
438 if (strstr (name0, "___") != NULL)
440 strncpy (name, name0, len);
449 if (isalnum (name0[i0]))
451 name[i] = tolower (name0[i0]);
454 else switch (name0[i0])
469 while (i0 < len && name0[i0] != '\'');
474 while (i0 < len && name0[i0] != '>')
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. */
494 processString (const char *text, int len)
498 const char *lim = text + len;
499 struct stoken result;
501 q = result.ptr = obstack_alloc (&temp_parse_space, len);
505 if (p[0] == '[' && p[1] == '"' && p+2 < lim)
507 if (p[2] == '"') /* "...["""]... */
515 sscanf (p+2, "%2x", &chr);
525 result.length = q - result.ptr;
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. */
537 find_dot_all (const char *str)
540 for (i = 0; str[i] != '\000'; i += 1)
547 while (isspace (str[i]));
548 if (strncmp (str+i, "all", 3) == 0
549 && ! isalnum (str[i+3]) && str[i+3] != '_')
556 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
560 subseqMatch (const char *subseq, const char *str)
562 if (subseq[0] == '\0')
564 else if (str[0] == '\0')
566 else if (tolower (subseq[0]) == tolower (str[0]))
567 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
569 return subseqMatch (subseq, str+1);
573 static struct { const char *name; int code; }
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 },
584 { "modulus", TICK_MODULUS },
586 { "range", TICK_RANGE },
587 { "size", TICK_SIZE },
593 /* Return the syntactic code corresponding to the attribute name or
597 processAttribute (const char *str)
601 for (i = 0; attributes[i].code != -1; i += 1)
602 if (strcasecmp (str, attributes[i].name) == 0)
603 return attributes[i].code;
605 for (i = 0, k = -1; attributes[i].code != -1; i += 1)
606 if (subseqMatch (str, attributes[i].name))
611 error (_("ambiguous attribute name: `%s'"), str);
614 error (_("unrecognized attribute: `%s'"), str);
616 return attributes[k].code;
619 /* Back up lexptr by yyleng and then to the rightmost occurrence of
620 character CH, case-folded (there must be one). WARNING: since
621 lexptr points to the next input character that Flex has not yet
622 transferred to its internal buffer, the use of this function
623 depends on the assumption that Flex calls YY_INPUT only when it is
624 logically necessary to do so (thus, there is no reading ahead
625 farther than needed to identify the next token.) */
628 rewind_to_char (int ch)
631 while (toupper (*lexptr) != toupper (ch))
642 /* Dummy definition to suppress warnings about unused static definitions. */
643 typedef void (*dummy_function) ();
644 dummy_function ada_flex_use[] =
646 (dummy_function) yyunput