1 /* FLEX lexer for Ada expressions, for GDB.
2 Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /*----------------------------------------------------------------------*/
24 /* The converted version of this file is to be included in ada-exp.y, */
25 /* the Ada parser for gdb. The function yylex obtains characters from */
26 /* the global pointer lexptr. It returns a syntactic category for */
27 /* each successive token and places a semantic value into yylval */
28 /* (ada-lval), defined by the parser. */
31 NUM10 ({DIG}({DIG}|_)*)
33 NUM16 ({HEXDIG}({HEXDIG}|_)*)
36 ID ({LETTER}({LETTER}|{DIG})*|"<"{LETTER}({LETTER}|{DIG})*">")
39 GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
40 OPER ([-+*/=<>&]|"<="|">="|"**"|"/="|"and"|"or"|"xor"|"not"|"mod"|"rem"|"abs")
47 #define NUMERAL_WIDTH 256
48 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
50 /* Temporary staging for numeric literals. */
51 static char numbuf[NUMERAL_WIDTH];
52 static void canonicalizeNumeral (char *s1, const char *);
53 static struct stoken processString (const char*, int);
54 static int processInt (const char *, const char *, const char *);
55 static int processReal (const char *);
56 static struct stoken processId (const char *, int);
57 static int processAttribute (const char *);
58 static int find_dot_all (const char *);
61 #define YY_DECL static int yylex ( void )
64 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
65 if ( *lexptr == '\000' ) \
74 static int find_dot_all (const char *);
78 %option case-insensitive interactive nodefault
86 "--".* { yyterminate(); }
89 canonicalizeNumeral (numbuf, yytext);
90 return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
94 canonicalizeNumeral (numbuf, yytext);
95 return processInt (NULL, numbuf, NULL);
98 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
99 canonicalizeNumeral (numbuf, yytext);
100 return processInt (numbuf,
101 strchr (numbuf, '#') + 1,
102 strrchr(numbuf, '#') + 1);
105 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
106 canonicalizeNumeral (numbuf, yytext);
107 return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
111 canonicalizeNumeral (numbuf, yytext+2);
112 return processInt ("16#", numbuf, NULL);
116 {NUM10}"."{NUM10}{EXP} {
117 canonicalizeNumeral (numbuf, yytext);
118 return processReal (numbuf);
122 canonicalizeNumeral (numbuf, yytext);
123 return processReal (numbuf);
126 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
127 error (_("Based real literals not implemented yet."));
130 {NUM10}"#"{NUM16}"."{NUM16}"#" {
131 error (_("Based real literals not implemented yet."));
134 <INITIAL>"'"({GRAPHIC}|\")"'" {
135 yylval.typed_val.type = type_char ();
136 yylval.typed_val.val = yytext[1];
140 <INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
142 yylval.typed_val.type = type_char ();
143 sscanf (yytext+3, "%2x", &v);
144 yylval.typed_val.val = v;
148 \"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\" {
149 yylval.sval = processString (yytext+1, yyleng-2);
154 error (_("ill-formed or non-terminated string literal"));
159 while (*lexptr != 'i' && *lexptr != 'I')
168 and { return _AND_; }
169 else { return ELSE; }
174 null { return NULL_PTR; }
176 others { return OTHERS; }
178 then { return THEN; }
181 /* BOOLEAN "KEYWORDS" */
183 /* True and False are not keywords in Ada, but rather enumeration constants.
184 However, the boolean type is no longer represented as an enum, so True
185 and False are no longer defined in symbol tables. We compromise by
186 making them keywords (when bare). */
188 true { return TRUEKEYWORD; }
189 false { return FALSEKEYWORD; }
193 {TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }
197 "=>" { return ARROW; }
198 ".." { return DOTDOT; }
199 "**" { return STARSTAR; }
200 ":=" { return ASSIGN; }
201 "/=" { return NOTEQUAL; }
205 <BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
207 [-&*+./:<>=|;\[\]] { return yytext[0]; }
209 "," { if (paren_depth == 0 && comma_terminates)
219 "(" { paren_depth += 1; return '('; }
220 ")" { if (paren_depth == 0)
233 "."{WHITE}*all { return DOT_ALL; }
236 yylval.sval = processId (yytext+1, yyleng-1);
240 {ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")? {
241 int all_posn = find_dot_all (yytext);
243 if (all_posn == -1 && yytext[yyleng-1] == '\'')
245 BEGIN BEFORE_QUAL_QUOTE;
248 else if (all_posn >= 0)
250 yylval.sval = processId (yytext, yyleng);
255 /* GDB EXPRESSION CONSTRUCTS */
257 "'"[^']+"'"{WHITE}*:: {
259 yylval.sval = processId (yytext, yyleng);
263 "::" { return COLONCOLON; }
265 [{}@] { return yytext[0]; }
267 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
269 "$"({LETTER}|{DIG}|"$")* {
270 yylval.sval.ptr = yytext;
271 yylval.sval.length = yyleng;
272 return SPECIAL_VARIABLE;
275 /* CATCH-ALL ERROR CASE */
277 . { error (_("Invalid character '%s' in expression."), yytext); }
281 #include "gdb_string.h"
283 /* Initialize the lexer for processing new expression. */
286 lexer_init (FILE *inp)
293 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */
296 canonicalizeNumeral (char *s1, const char *s2)
298 for (; *s2 != '\000'; s2 += 1)
309 /* Interprets the prefix of NUM that consists of digits of the given BASE
310 as an integer of that BASE, with the string EXP as an exponent.
311 Puts value in yylval, and returns INT, if the string is valid. Causes
312 an error if the number is improperly formated. BASE, if NULL, defaults
313 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
317 processInt (const char *base0, const char *num0, const char *exp0)
329 base = strtol (base0, (char **) NULL, 10);
330 if (base < 2 || base > 16)
331 error (_("Invalid base: %d."), base);
337 exp = strtol(exp0, (char **) NULL, 10);
340 result = strtoulst (num0, (const char **) &trailer, base);
342 error (_("Integer literal out of range"));
343 if (isxdigit(*trailer))
344 error (_("Invalid digit `%c' in based literal"), *trailer);
348 if (result > (ULONG_MAX / base))
349 error (_("Integer literal out of range"));
354 if ((result >> (gdbarch_int_bit (current_gdbarch)-1)) == 0)
355 yylval.typed_val.type = type_int ();
356 else if ((result >> (gdbarch_long_bit (current_gdbarch)-1)) == 0)
357 yylval.typed_val.type = type_long ();
358 else if (((result >> (gdbarch_long_bit (current_gdbarch)-1)) >> 1) == 0)
360 /* We have a number representable as an unsigned integer quantity.
361 For consistency with the C treatment, we will treat it as an
362 anonymous modular (unsigned) quantity. Alas, the types are such
363 that we need to store .val as a signed quantity. Sorry
364 for the mess, but C doesn't officially guarantee that a simple
365 assignment does the trick (no, it doesn't; read the reference manual).
367 yylval.typed_val.type = builtin_type_unsigned_long;
368 if (result & LONGEST_SIGN)
369 yylval.typed_val.val =
370 (LONGEST) (result & ~LONGEST_SIGN)
371 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
373 yylval.typed_val.val = (LONGEST) result;
377 yylval.typed_val.type = type_long_long ();
379 yylval.typed_val.val = (LONGEST) result;
384 processReal (const char *num0)
386 sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
388 yylval.typed_val_float.type = type_float ();
389 if (sizeof(DOUBLEST) >= gdbarch_double_bit (current_gdbarch)
391 yylval.typed_val_float.type = type_double ();
392 if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (current_gdbarch)
394 yylval.typed_val_float.type = type_long_double ();
400 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
401 resulting string is valid until the next call to ada_parse. It differs
403 + Characters between '...' or <...> are transfered verbatim to
405 + <, >, and trailing "'" characters in quoted sequences are removed
406 (a leading quote is preserved to indicate that the name is not to be
408 + Unquoted whitespace is removed.
409 + Unquoted alphabetic characters are mapped to lower case.
410 Result is returned as a struct stoken, but for convenience, the string
411 is also null-terminated. Result string valid until the next call of
415 processId (const char *name0, int len)
417 char *name = obstack_alloc (&temp_parse_space, len + 11);
419 struct stoken result;
421 while (len > 0 && isspace (name0[len-1]))
426 if (isalnum (name0[i0]))
428 name[i] = tolower (name0[i0]);
431 else switch (name0[i0])
446 while (i0 < len && name0[i0] != '\'');
451 while (i0 < len && name0[i0] != '>')
467 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
468 with special hex character notations replaced with characters.
469 Result valid until the next call to ada_parse. */
472 processString (const char *text, int len)
476 const char *lim = text + len;
477 struct stoken result;
479 q = result.ptr = obstack_alloc (&temp_parse_space, len);
483 if (p[0] == '[' && p[1] == '"' && p+2 < lim)
485 if (p[2] == '"') /* "...["""]... */
493 sscanf (p+2, "%2x", &chr);
503 result.length = q - result.ptr;
507 /* Returns the position within STR of the '.' in a
508 '.{WHITE}*all' component of a dotted name, or -1 if there is none.
509 Note: we actually don't need this routine, since 'all' can never be an
510 Ada identifier. Thus, looking up foo.all or foo.all.x as a name
511 must fail, and will eventually be interpreted as (foo).all or
512 (foo).all.x. However, this does avoid an extraneous lookup. */
515 find_dot_all (const char *str)
518 for (i = 0; str[i] != '\000'; i += 1)
525 while (isspace (str[i]));
526 if (strncmp (str+i, "all", 3) == 0
527 && ! isalnum (str[i+3]) && str[i+3] != '_')
534 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
538 subseqMatch (const char *subseq, const char *str)
540 if (subseq[0] == '\0')
542 else if (str[0] == '\0')
544 else if (tolower (subseq[0]) == tolower (str[0]))
545 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
547 return subseqMatch (subseq, str+1);
551 static struct { const char *name; int code; }
553 { "address", TICK_ADDRESS },
554 { "unchecked_access", TICK_ACCESS },
555 { "unrestricted_access", TICK_ACCESS },
556 { "access", TICK_ACCESS },
557 { "first", TICK_FIRST },
558 { "last", TICK_LAST },
559 { "length", TICK_LENGTH },
562 { "modulus", TICK_MODULUS },
564 { "range", TICK_RANGE },
565 { "size", TICK_SIZE },
571 /* Return the syntactic code corresponding to the attribute name or
575 processAttribute (const char *str)
579 for (i = 0; attributes[i].code != -1; i += 1)
580 if (strcasecmp (str, attributes[i].name) == 0)
581 return attributes[i].code;
583 for (i = 0, k = -1; attributes[i].code != -1; i += 1)
584 if (subseqMatch (str, attributes[i].name))
589 error (_("ambiguous attribute name: `%s'"), str);
592 error (_("unrecognized attribute: `%s'"), str);
594 return attributes[k].code;
603 /* Dummy definition to suppress warnings about unused static definitions. */
604 typedef void (*dummy_function) ();
605 dummy_function ada_flex_use[] =
607 (dummy_function) yyunput