1 /* FLEX lexer for Ada expressions, for GDB.
2 Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008, 2009
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 3 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, see <http://www.gnu.org/licenses/>. */
20 /*----------------------------------------------------------------------*/
22 /* The converted version of this file is to be included in ada-exp.y, */
23 /* the Ada parser for gdb. The function yylex obtains characters from */
24 /* the global pointer lexptr. It returns a syntactic category for */
25 /* each successive token and places a semantic value into yylval */
26 /* (ada-lval), defined by the parser. */
29 NUM10 ({DIG}({DIG}|_)*)
31 NUM16 ({HEXDIG}({HEXDIG}|_)*)
34 ID ({LETTER}({LETTER}|{DIG})*|"<"{LETTER}({LETTER}|{DIG})*">")
37 GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
38 OPER ([-+*/=<>&]|"<="|">="|"**"|"/="|"and"|"or"|"xor"|"not"|"mod"|"rem"|"abs")
45 #define NUMERAL_WIDTH 256
46 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
48 /* Temporary staging for numeric literals. */
49 static char numbuf[NUMERAL_WIDTH];
50 static void canonicalizeNumeral (char *s1, const char *);
51 static struct stoken processString (const char*, int);
52 static int processInt (const char *, const char *, const char *);
53 static int processReal (const char *);
54 static struct stoken processId (const char *, int);
55 static int processAttribute (const char *);
56 static int find_dot_all (const char *);
59 #define YY_DECL static int yylex ( void )
62 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
63 if ( *lexptr == '\000' ) \
72 static int find_dot_all (const char *);
76 %option case-insensitive interactive nodefault
84 "--".* { yyterminate(); }
87 canonicalizeNumeral (numbuf, yytext);
88 return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
92 canonicalizeNumeral (numbuf, yytext);
93 return processInt (NULL, numbuf, NULL);
96 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
97 canonicalizeNumeral (numbuf, yytext);
98 return processInt (numbuf,
99 strchr (numbuf, '#') + 1,
100 strrchr(numbuf, '#') + 1);
103 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
104 canonicalizeNumeral (numbuf, yytext);
105 return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
109 canonicalizeNumeral (numbuf, yytext+2);
110 return processInt ("16#", numbuf, NULL);
114 {NUM10}"."{NUM10}{EXP} {
115 canonicalizeNumeral (numbuf, yytext);
116 return processReal (numbuf);
120 canonicalizeNumeral (numbuf, yytext);
121 return processReal (numbuf);
124 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
125 error (_("Based real literals not implemented yet."));
128 {NUM10}"#"{NUM16}"."{NUM16}"#" {
129 error (_("Based real literals not implemented yet."));
132 <INITIAL>"'"({GRAPHIC}|\")"'" {
133 yylval.typed_val.type = type_char ();
134 yylval.typed_val.val = yytext[1];
138 <INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
140 yylval.typed_val.type = type_char ();
141 sscanf (yytext+3, "%2x", &v);
142 yylval.typed_val.val = v;
146 \"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\" {
147 yylval.sval = processString (yytext+1, yyleng-2);
152 error (_("ill-formed or non-terminated string literal"));
157 while (*lexptr != 'i' && *lexptr != 'I')
166 and { return _AND_; }
167 else { return ELSE; }
172 null { return NULL_PTR; }
174 others { return OTHERS; }
176 then { return THEN; }
179 /* BOOLEAN "KEYWORDS" */
181 /* True and False are not keywords in Ada, but rather enumeration constants.
182 However, the boolean type is no longer represented as an enum, so True
183 and False are no longer defined in symbol tables. We compromise by
184 making them keywords (when bare). */
186 true { return TRUEKEYWORD; }
187 false { return FALSEKEYWORD; }
191 {TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }
195 "=>" { return ARROW; }
196 ".." { return DOTDOT; }
197 "**" { return STARSTAR; }
198 ":=" { return ASSIGN; }
199 "/=" { return NOTEQUAL; }
203 <BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
205 [-&*+./:<>=|;\[\]] { return yytext[0]; }
207 "," { if (paren_depth == 0 && comma_terminates)
217 "(" { paren_depth += 1; return '('; }
218 ")" { if (paren_depth == 0)
231 "."{WHITE}*all { return DOT_ALL; }
234 yylval.sval = processId (yytext+1, yyleng-1);
238 {ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")? {
239 int all_posn = find_dot_all (yytext);
241 if (all_posn == -1 && yytext[yyleng-1] == '\'')
243 BEGIN BEFORE_QUAL_QUOTE;
246 else if (all_posn >= 0)
248 yylval.sval = processId (yytext, yyleng);
253 /* GDB EXPRESSION CONSTRUCTS */
255 "'"[^']+"'"{WHITE}*:: {
257 yylval.sval = processId (yytext, yyleng);
261 "::" { return COLONCOLON; }
263 [{}@] { return yytext[0]; }
265 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
267 "$"({LETTER}|{DIG}|"$")* {
268 yylval.sval.ptr = yytext;
269 yylval.sval.length = yyleng;
270 return SPECIAL_VARIABLE;
273 /* CATCH-ALL ERROR CASE */
275 . { error (_("Invalid character '%s' in expression."), yytext); }
279 #include "gdb_string.h"
281 /* Initialize the lexer for processing new expression. */
284 lexer_init (FILE *inp)
291 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */
294 canonicalizeNumeral (char *s1, const char *s2)
296 for (; *s2 != '\000'; s2 += 1)
307 /* Interprets the prefix of NUM that consists of digits of the given BASE
308 as an integer of that BASE, with the string EXP as an exponent.
309 Puts value in yylval, and returns INT, if the string is valid. Causes
310 an error if the number is improperly formated. BASE, if NULL, defaults
311 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
315 processInt (const char *base0, const char *num0, const char *exp0)
327 base = strtol (base0, (char **) NULL, 10);
328 if (base < 2 || base > 16)
329 error (_("Invalid base: %d."), base);
335 exp = strtol(exp0, (char **) NULL, 10);
338 result = strtoulst (num0, (const char **) &trailer, base);
340 error (_("Integer literal out of range"));
341 if (isxdigit(*trailer))
342 error (_("Invalid digit `%c' in based literal"), *trailer);
346 if (result > (ULONG_MAX / base))
347 error (_("Integer literal out of range"));
352 if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0)
353 yylval.typed_val.type = type_int ();
354 else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0)
355 yylval.typed_val.type = type_long ();
356 else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0)
358 /* We have a number representable as an unsigned integer quantity.
359 For consistency with the C treatment, we will treat it as an
360 anonymous modular (unsigned) quantity. Alas, the types are such
361 that we need to store .val as a signed quantity. Sorry
362 for the mess, but C doesn't officially guarantee that a simple
363 assignment does the trick (no, it doesn't; read the reference manual).
365 yylval.typed_val.type
366 = builtin_type (parse_gdbarch)->builtin_unsigned_long;
367 if (result & LONGEST_SIGN)
368 yylval.typed_val.val =
369 (LONGEST) (result & ~LONGEST_SIGN)
370 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
372 yylval.typed_val.val = (LONGEST) result;
376 yylval.typed_val.type = type_long_long ();
378 yylval.typed_val.val = (LONGEST) result;
383 processReal (const char *num0)
385 sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
387 yylval.typed_val_float.type = type_float ();
388 if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
390 yylval.typed_val_float.type = type_double ();
391 if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
393 yylval.typed_val_float.type = type_long_double ();
399 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
400 resulting string is valid until the next call to ada_parse. It differs
402 + Characters between '...' or <...> are transfered verbatim to
404 + <, >, and trailing "'" characters in quoted sequences are removed
405 (a leading quote is preserved to indicate that the name is not to be
407 + Unquoted whitespace is removed.
408 + Unquoted alphabetic characters are mapped to lower case.
409 Result is returned as a struct stoken, but for convenience, the string
410 is also null-terminated. Result string valid until the next call of
414 processId (const char *name0, int len)
416 char *name = obstack_alloc (&temp_parse_space, len + 11);
418 struct stoken result;
420 while (len > 0 && isspace (name0[len-1]))
425 if (isalnum (name0[i0]))
427 name[i] = tolower (name0[i0]);
430 else switch (name0[i0])
445 while (i0 < len && name0[i0] != '\'');
450 while (i0 < len && name0[i0] != '>')
466 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
467 with special hex character notations replaced with characters.
468 Result valid until the next call to ada_parse. */
471 processString (const char *text, int len)
475 const char *lim = text + len;
476 struct stoken result;
478 q = result.ptr = obstack_alloc (&temp_parse_space, len);
482 if (p[0] == '[' && p[1] == '"' && p+2 < lim)
484 if (p[2] == '"') /* "...["""]... */
492 sscanf (p+2, "%2x", &chr);
502 result.length = q - result.ptr;
506 /* Returns the position within STR of the '.' in a
507 '.{WHITE}*all' component of a dotted name, or -1 if there is none.
508 Note: we actually don't need this routine, since 'all' can never be an
509 Ada identifier. Thus, looking up foo.all or foo.all.x as a name
510 must fail, and will eventually be interpreted as (foo).all or
511 (foo).all.x. However, this does avoid an extraneous lookup. */
514 find_dot_all (const char *str)
517 for (i = 0; str[i] != '\000'; i += 1)
524 while (isspace (str[i]));
525 if (strncmp (str+i, "all", 3) == 0
526 && ! isalnum (str[i+3]) && str[i+3] != '_')
533 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
537 subseqMatch (const char *subseq, const char *str)
539 if (subseq[0] == '\0')
541 else if (str[0] == '\0')
543 else if (tolower (subseq[0]) == tolower (str[0]))
544 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
546 return subseqMatch (subseq, str+1);
550 static struct { const char *name; int code; }
552 { "address", TICK_ADDRESS },
553 { "unchecked_access", TICK_ACCESS },
554 { "unrestricted_access", TICK_ACCESS },
555 { "access", TICK_ACCESS },
556 { "first", TICK_FIRST },
557 { "last", TICK_LAST },
558 { "length", TICK_LENGTH },
561 { "modulus", TICK_MODULUS },
563 { "range", TICK_RANGE },
564 { "size", TICK_SIZE },
570 /* Return the syntactic code corresponding to the attribute name or
574 processAttribute (const char *str)
578 for (i = 0; attributes[i].code != -1; i += 1)
579 if (strcasecmp (str, attributes[i].name) == 0)
580 return attributes[i].code;
582 for (i = 0, k = -1; attributes[i].code != -1; i += 1)
583 if (subseqMatch (str, attributes[i].name))
588 error (_("ambiguous attribute name: `%s'"), str);
591 error (_("unrecognized attribute: `%s'"), str);
593 return attributes[k].code;
602 /* Dummy definition to suppress warnings about unused static definitions. */
603 typedef void (*dummy_function) ();
604 dummy_function ada_flex_use[] =
606 (dummy_function) yyunput