GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/ada-lex.l
Go to the documentation of this file.
1/* FLEX lexer for Ada expressions, for GDB. -*- c++ -*-
2 Copyright (C) 1994-2023 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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/>. */
const char *const name
Definition: aarch64-tdep.c:67
#define TICK_VAL
Definition: ada-exp.c:604
#define LEQ
Definition: ada-exp.c:580
#define DOLLAR_VARIABLE
Definition: ada-exp.c:572
#define ELSE
Definition: ada-exp.c:578
static struct type * type_long_double(struct parser_state *)
Definition: ada-exp.c:3792
#define TRUEKEYWORD
Definition: ada-exp.c:563
#define STRING
Definition: ada-exp.c:566
#define NOTEQUAL
Definition: ada-exp.c:579
#define TICK_ADDRESS
Definition: ada-exp.c:593
#define yyrestart
Definition: ada-exp.c:3053
#define ABS
Definition: ada-exp.c:588
#define TICK_COMPLETE
Definition: ada-exp.c:569
#define TICK_POS
Definition: ada-exp.c:600
#define OR
Definition: ada-exp.c:575
#define yytext
Definition: ada-exp.c:3054
#define FALSEKEYWORD
Definition: ada-exp.c:564
#define TICK_TAG
Definition: ada-exp.c:603
#define TICK_SIZE
Definition: ada-exp.c:602
#define XOR
Definition: ada-exp.c:576
#define NAME
Definition: ada-exp.c:567
#define REM
Definition: ada-exp.c:586
#define ASSIGN
Definition: ada-exp.c:573
#define TICK_RANGE
Definition: ada-exp.c:601
static struct parser_state * pstate
Definition: ada-exp.c:104
#define NULL_PTR
Definition: ada-exp.c:560
static struct type * type_long(struct parser_state *)
Definition: ada-exp.c:3780
static struct type * type_for_char(struct parser_state *, ULONGEST)
Definition: ada-exp.c:3798
static struct obstack temp_parse_space
Definition: ada-exp.c:3056
#define ARROW
Definition: ada-exp.c:591
#define OTHERS
Definition: ada-exp.c:606
static struct type * type_int(struct parser_state *)
Definition: ada-exp.c:3774
#define DOT_COMPLETE
Definition: ada-exp.c:570
#define STARSTAR
Definition: ada-exp.c:587
#define CHARLIT
Definition: ada-exp.c:561
#define DOTDOT
Definition: ada-exp.c:583
#define TICK_LENGTH
Definition: ada-exp.c:596
#define TICK_MODULUS
Definition: ada-exp.c:599
#define NAME_COMPLETE
Definition: ada-exp.c:571
#define GEQ
Definition: ada-exp.c:581
#define COLONCOLON
Definition: ada-exp.c:565
#define TICK_MIN
Definition: ada-exp.c:598
#define NEW
Definition: ada-exp.c:605
#define IN
Definition: ada-exp.c:582
#define MOD
Definition: ada-exp.c:585
#define DOT_ID
Definition: ada-exp.c:568
#define _AND_
Definition: ada-exp.c:574
#define NOT
Definition: ada-exp.c:589
#define TICK_MAX
Definition: ada-exp.c:597
#define THEN
Definition: ada-exp.c:577
#define TICK_LAST
Definition: ada-exp.c:595
static struct type * type_long_long(struct parser_state *)
Definition: ada-exp.c:3786
#define FLOAT
Definition: ada-exp.c:562
#define TICK_FIRST
Definition: ada-exp.c:594
#define TICK_ACCESS
Definition: ada-exp.c:592
#define INT
Definition: ada-exp.c:559
int yyleng
Definition: ada-lex.c:270
static void yyunput(int c, char *buf_ptr)
#define INITIAL
Definition: ada-lex.c:920
#define BEGIN
Definition: ada-lex.c:117
#define BEFORE_QUAL_QUOTE
Definition: ada-lex.c:921
#define yyterminate()
Definition: ada-lex.c:1060
#define yyless(n)
Definition: ada-lex.c:169
static void canonicalizeNumeral(char *s1, const char *)
Definition: ada-lex.l:358
static bool returned_complete
Definition: ada-lex.l:86
static int processAttribute(const char *)
Definition: ada-lex.l:711
static int subseqMatch(const char *subseq, const char *str)
Definition: ada-lex.l:675
static int processInt(struct parser_state *, const char *, const char *, const char *)
Definition: ada-lex.l:379
static void rewind_to_char(int)
Definition: ada-lex.l:770
int code
Definition: ada-lex.l:688
static struct @4 attributes[]
static struct stoken processId(const char *, int)
Definition: ada-lex.l:548
static void lexer_init(FILE *inp)
Definition: ada-lex.l:346
#define COMPLETE_CHAR
Definition: ada-lex.l:89
static struct stoken processString(const char *, int)
Definition: ada-lex.l:605
const char * name
Definition: ada-lex.l:688
static int paren_depth
Definition: ada-lex.l:112
dummy_function ada_flex_use[]
Definition: ada-lex.l:780
#define LONGEST_SIGN
Definition: ada-lex.l:60
void(* dummy_function)()
Definition: ada-lex.l:779
static int processReal(struct parser_state *, const char *)
Definition: ada-lex.l:520
static int find_dot_all(const char *)
Definition: ada-lex.l:651
static char numbuf[NUMERAL_WIDTH]
Definition: ada-lex.l:63
#define NUMERAL_WIDTH
Definition: ada-lex.l:59
constexpr std::string_view s1
Definition: 2.cc:26
constexpr std::string_view s2
Definition: 2.cc:27
void add_completions(completion_list &&list)
Definition: completer.c:1590
std::vector< gdb::unique_xmalloc_ptr< char > > completion_list
Definition: completer.h:70
#define ULONGEST_MAX
Definition: defs.h:473
int gdbarch_long_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1457
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1423
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1440
enum bfd_endian type_byte_order(const struct type *type)
Definition: gdbtypes.c:4018
unsigned short base0
Definition: go32-nat.c:1
struct type * language_lookup_primitive_type(const struct language_defn *la, struct gdbarch *gdbarch, const char *name)
Definition: language.c:1053
bool parse_float(const char *p, int len, const struct type *type, gdb_byte *data)
Definition: parse.c:609
bool fits_in_type(int n_sign, ULONGEST n, int type_bits, bool type_signed_p)
Definition: parse.c:619
std::string m_name
Definition: ada-exp.c:450
bool complete(struct expression *exp, completion_tracker &tracker) override
Definition: ada-lex.c:3015
struct type * builtin_unsigned_long_long
Definition: gdbtypes.h:2265
struct type * builtin_unsigned_long
Definition: gdbtypes.h:2254
const struct language_defn * language()
Definition: parser-defs.h:68
struct gdbarch * gdbarch()
Definition: parser-defs.h:61
void write(gdb::array_view< gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p) const
Definition: gmp-utils.c:68
T as_integer() const
Definition: gmp-utils.h:277
mpz_t val
Definition: gmp-utils.h:40
bool parse_completion
Definition: parser-defs.h:297
const char * lexptr
Definition: parser-defs.h:286
int comma_terminates
Definition: parser-defs.h:281
int length
Definition: parser-defs.h:370
const char * ptr
Definition: parser-defs.h:368
Definition: gdbtypes.h:922
ULONGEST length() const
Definition: gdbtypes.h:954
Definition: value.c:181
#define yylval
Definition: yy-remap.h:46
18
19/*----------------------------------------------------------------------*/
20
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. */
26
27DIG [0-9]
28NUM10 ({DIG}({DIG}|_)*)
29HEXDIG [0-9a-f]
30NUM16 ({HEXDIG}({HEXDIG}|_)*)
31OCTDIG [0-7]
32LETTER [a-z_]
33ID ({LETTER}({LETTER}|{DIG}|[\x80-\xff])*|"<"{LETTER}({LETTER}|{DIG})*">")
34WHITE [ \t\n]
35TICK ("'"{WHITE}*)
36GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
37OPER ([-+*/=<>&]|"<="|">="|"**"|"/="|"and"|"or"|"xor"|"not"|"mod"|"rem"|"abs")
38
39EXP (e[+-]{NUM10})
40POSEXP (e"+"?{NUM10})
41
42/* This must agree with COMPLETION_CHAR below. See the comment there
43 for the explanation. */
44COMPLETE "\001"
45NOT_COMPLETE [^\001]
46
47%{
48
49#include "diagnostics.h"
50
51/* Some old versions of flex generate code that uses the "register" keyword,
52 which clang warns about. This was observed for example with flex 2.5.35,
53 as shipped with macOS 10.12. The same happens with flex 2.5.37 and g++ 11
54 which defaults to ISO C++17, that does not allow register storage class
55 specifiers. */
56DIAGNOSTIC_PUSH
57DIAGNOSTIC_IGNORE_DEPRECATED_REGISTER
58
59#define NUMERAL_WIDTH 256
60#define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
61
62/* Temporary staging for numeric literals. */
63static char numbuf[NUMERAL_WIDTH];
64 static void canonicalizeNumeral (char *s1, const char *);
65static struct stoken processString (const char*, int);
66static int processInt (struct parser_state *, const char *, const char *,
67 const char *);
68static int processReal (struct parser_state *, const char *);
69static struct stoken processId (const char *, int);
70static int processAttribute (const char *);
71static int find_dot_all (const char *);
72static void rewind_to_char (int);
73
74#undef YY_DECL
75#define YY_DECL static int yylex ( void )
76
77/* Flex generates a static function "input" which is not used.
78 Defining YY_NO_INPUT comments it out. */
79#define YY_NO_INPUT
80
81/* When completing, we'll return a special character at the end of the
82 input, to signal the completion position to the lexer. This is
83 done because flex does not have a generally useful way to detect
84 EOF in a pattern. This variable records whether the special
85 character has been emitted. */
86static bool returned_complete = false;
87
88/* The character we use to represent the completion point. */
89#define COMPLETE_CHAR '\001'
90
91#undef YY_INPUT
92#define YY_INPUT(BUF, RESULT, MAX_SIZE) \
93 if ( *pstate->lexptr == '\000' ) \
94 { \
95 if (pstate->parse_completion && !returned_complete) \
96 { \
97 returned_complete = true; \
98 *(BUF) = COMPLETE_CHAR; \
99 (RESULT) = 1; \
100 } \
101 else \
102 (RESULT) = YY_NULL; \
103 } \
104 else \
105 { \
106 *(BUF) = *pstate->lexptr == COMPLETE_CHAR ? ' ' : *pstate->lexptr; \
107 (RESULT) = 1; \
108 pstate->lexptr += 1; \
109 }
110
111/* Depth of parentheses. */
112static int paren_depth;
113
114%}
115
116%option case-insensitive interactive nodefault noyywrap
117
118%s BEFORE_QUAL_QUOTE
119
121
122{WHITE} { }
123
124"--".* { yyterminate(); }
125
126{NUM10}{POSEXP} {
128 char *e_ptr = strrchr (numbuf, 'e');
129 *e_ptr = '\0';
130 return processInt (pstate, nullptr, numbuf, e_ptr + 1);
131 }
132
133{NUM10} {
135 return processInt (pstate, NULL, numbuf, NULL);
136 }
137
138{NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
140 char *e_ptr = strrchr (numbuf, 'e');
141 *e_ptr = '\0';
142 return processInt (pstate, numbuf,
143 strchr (numbuf, '#') + 1,
144 e_ptr + 1);
145 }
146
147 /* The "llf" is a gdb extension to allow a floating-point
148 constant to be written in some other base. The
149 floating-point number is formed by reinterpreting the
150 bytes, allowing direct control over the bits. */
151{NUM10}(l{0,2}f)?"#"{HEXDIG}({HEXDIG}|_)*"#" {
153 return processInt (pstate, numbuf, strchr (numbuf, '#') + 1,
154 NULL);
155 }
156
157"0x"{HEXDIG}+ {
159 return processInt (pstate, "16#", numbuf, NULL);
160 }
161
162
163{NUM10}"."{NUM10}{EXP} {
165 return processReal (pstate, numbuf);
166 }
167
168{NUM10}"."{NUM10} {
170 return processReal (pstate, numbuf);
171 }
172
173{NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
174 error (_("Based real literals not implemented yet."));
175 }
176
177{NUM10}"#"{NUM16}"."{NUM16}"#" {
178 error (_("Based real literals not implemented yet."));
179 }
180
181<INITIAL>"'"({GRAPHIC}|\")"'" {
182 yylval.typed_val.val = yytext[1];
183 yylval.typed_val.type = type_for_char (pstate, yytext[1]);
184 return CHARLIT;
185 }
186
187<INITIAL>"'[\""{HEXDIG}{2,}"\"]'" {
188 ULONGEST v = strtoulst (yytext+3, nullptr, 16);
189 yylval.typed_val.val = v;
190 yylval.typed_val.type = type_for_char (pstate, v);
191 return CHARLIT;
192 }
193
194 /* Note that we don't handle bracket sequences of more than 2
195 digits here. Currently there's no support for wide or
196 wide-wide strings. */
197\"({GRAPHIC}|"[\""({HEXDIG}{2,}|\")"\"]")*\" {
198 yylval.sval = processString (yytext+1, yyleng-2);
199 return STRING;
200 }
201
202\" {
203 error (_("ill-formed or non-terminated string literal"));
204 }
205
206
207if {
208 rewind_to_char ('i');
209 return 0;
210 }
211
212task {
213 rewind_to_char ('t');
214 return 0;
215 }
216
217thread{WHITE}+{DIG} {
218 /* This keyword signals the end of the expression and
219 will be processed separately. */
220 rewind_to_char ('t');
221 return 0;
222 }
223
224 /* ADA KEYWORDS */
225
226abs { return ABS; }
227and { return _AND_; }
228else { return ELSE; }
229in { return IN; }
230mod { return MOD; }
231new { return NEW; }
232not { return NOT; }
233null { return NULL_PTR; }
234or { return OR; }
235others { return OTHERS; }
236rem { return REM; }
237then { return THEN; }
238xor { return XOR; }
239
240 /* BOOLEAN "KEYWORDS" */
241
242 /* True and False are not keywords in Ada, but rather enumeration constants.
243 However, the boolean type is no longer represented as an enum, so True
244 and False are no longer defined in symbol tables. We compromise by
245 making them keywords (when bare). */
246
247true { return TRUEKEYWORD; }
248false { return FALSEKEYWORD; }
249
250 /* ATTRIBUTES */
251
252{TICK}([a-z][a-z_]*)?{COMPLETE}? { BEGIN INITIAL; return processAttribute (yytext); }
253
254 /* PUNCTUATION */
255
256"=>" { return ARROW; }
257".." { return DOTDOT; }
258"**" { return STARSTAR; }
259":=" { return ASSIGN; }
260"/=" { return NOTEQUAL; }
261"<=" { return LEQ; }
262">=" { return GEQ; }
263
264<BEFORE_QUAL_QUOTE>"'"/{NOT_COMPLETE} { BEGIN INITIAL; return '\''; }
265
266[-&*+{}@/:<>=|;\[\]] { return yytext[0]; }
267
268"," { if (paren_depth == 0 && pstate->comma_terminates)
269 {
270 rewind_to_char (',');
271 return 0;
272 }
273 else
274 return ',';
275 }
276
277"(" { paren_depth += 1; return '('; }
278")" { if (paren_depth == 0)
279 {
280 rewind_to_char (')');
281 return 0;
282 }
283 else
284 {
285 paren_depth -= 1;
286 return ')';
287 }
288 }
289
290"."{WHITE}*{ID}{COMPLETE}? {
291 yylval.sval = processId (yytext+1, yyleng-1);
292 if (yytext[yyleng - 1] == COMPLETE_CHAR)
293 return DOT_COMPLETE;
294 return DOT_ID;
295 }
296
297"."{WHITE}*{COMPLETE} {
298 yylval.sval.ptr = "";
299 yylval.sval.length = 0;
300 return DOT_COMPLETE;
301 }
302
303{ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'"|{COMPLETE})? {
304 int all_posn = find_dot_all (yytext);
305
306 if (all_posn == -1 && yytext[yyleng-1] == '\'')
307 {
309 yyless (yyleng-1);
310 }
311 else if (all_posn >= 0)
312 yyless (all_posn);
313 bool is_completion = yytext[yyleng - 1] == COMPLETE_CHAR;
314 yylval.sval = processId (yytext, yyleng);
315 return is_completion ? NAME_COMPLETE : NAME;
316 }
317
318
319 /* GDB EXPRESSION CONSTRUCTS */
320
321"'"[^']+"'"{WHITE}*:: {
322 yyless (yyleng - 2);
323 yylval.sval = processId (yytext, yyleng);
324 return NAME;
325 }
326
327"::" { return COLONCOLON; }
328
329 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
330
331"$"({LETTER}|{DIG}|"$")* {
332 yylval.sval.ptr = yytext;
333 yylval.sval.length = yyleng;
334 return DOLLAR_VARIABLE;
335 }
336
337 /* CATCH-ALL ERROR CASE */
338
339. { error (_("Invalid character '%s' in expression."), yytext); }
340%%
341
342#include <ctype.h>
343/* Initialize the lexer for processing new expression. */
344
345static void
346lexer_init (FILE *inp)
347{
349 paren_depth = 0;
350 returned_complete = false;
351 yyrestart (inp);
352}
353
354
355/* Copy S2 to S1, removing all underscores, and downcasing all letters. */
356
357static void
358canonicalizeNumeral (char *s1, const char *s2)
359{
360 for (; *s2 != '\000'; s2 += 1)
361 {
362 if (*s2 != '_')
363 {
364 *s1 = tolower(*s2);
365 s1 += 1;
366 }
367 }
368 s1[0] = '\000';
369}
370
371/* Interprets the prefix of NUM that consists of digits of the given BASE
372 as an integer of that BASE, with the string EXP as an exponent.
373 Puts value in yylval, and returns INT, if the string is valid. Causes
374 an error if the number is improperly formated. BASE, if NULL, defaults
375 to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
376 */
377
378static int
379processInt (struct parser_state *par_state, const char *base0,
380 const char *num0, const char *exp0)
381{
382 long exp;
383 int base;
384 /* For the based literal with an "f" prefix, we'll return a
385 floating-point number. This counts the the number of "l"s seen,
386 to decide the width of the floating-point number to return. -1
387 means no "f". */
388 int floating_point_l_count = -1;
389
390 if (base0 == NULL)
391 base = 10;
392 else
393 {
394 char *end_of_base;
395 base = strtol (base0, &end_of_base, 10);
396 if (base < 2 || base > 16)
397 error (_("Invalid base: %d."), base);
398 while (*end_of_base == 'l')
399 {
400 ++floating_point_l_count;
401 ++end_of_base;
402 }
403 /* This assertion is ensured by the pattern. */
404 gdb_assert (floating_point_l_count == -1 || *end_of_base == 'f');
405 if (*end_of_base == 'f')
406 {
407 ++end_of_base;
408 ++floating_point_l_count;
409 }
410 /* This assertion is ensured by the pattern. */
411 gdb_assert (*end_of_base == '#');
412 }
413
414 if (exp0 == NULL)
415 exp = 0;
416 else
417 exp = strtol(exp0, (char **) NULL, 10);
418
419 gdb_mpz result;
420 while (isxdigit (*num0))
421 {
422 int dig = fromhex (*num0);
423 if (dig >= base)
424 error (_("Invalid digit `%c' in based literal"), *num0);
425 mpz_mul_ui (result.val, result.val, base);
426 mpz_add_ui (result.val, result.val, dig);
427 ++num0;
428 }
429
430 while (exp > 0)
431 {
432 mpz_mul_ui (result.val, result.val, base);
433 exp -= 1;
434 }
435
436 if (floating_point_l_count > -1)
437 {
438 struct type *fp_type;
439 if (floating_point_l_count == 0)
440 fp_type = language_lookup_primitive_type (par_state->language (),
441 par_state->gdbarch (),
442 "float");
443 else if (floating_point_l_count == 1)
444 fp_type = language_lookup_primitive_type (par_state->language (),
445 par_state->gdbarch (),
446 "long_float");
447 else
448 {
449 /* This assertion is ensured by the pattern. */
450 gdb_assert (floating_point_l_count == 2);
451 fp_type = language_lookup_primitive_type (par_state->language (),
452 par_state->gdbarch (),
453 "long_long_float");
454 }
455
456 yylval.typed_val_float.type = fp_type;
457 result.write (gdb::make_array_view (yylval.typed_val_float.val,
458 fp_type->length ()),
459 type_byte_order (fp_type),
460 true);
461
462 return FLOAT;
463 }
464
465 gdb_mpz maxval (ULONGEST_MAX);
466 if (mpz_cmp (result.val, maxval.val) > 0)
467 error (_("Integer literal out of range"));
468
469 int int_bits = gdbarch_int_bit (par_state->gdbarch ());
470 int long_bits = gdbarch_long_bit (par_state->gdbarch ());
471 int long_long_bits = gdbarch_long_long_bit (par_state->gdbarch ());
472
473 ULONGEST value = result.as_integer<ULONGEST> ();
474 if (fits_in_type (1, value, int_bits, true))
475 yylval.typed_val.type = type_int (par_state);
476 else if (fits_in_type (1, value, long_bits, true))
477 yylval.typed_val.type = type_long (par_state);
478 else if (fits_in_type (1, value, long_bits, false))
479 {
480 /* We have a number representable as an unsigned integer quantity.
481 For consistency with the C treatment, we will treat it as an
482 anonymous modular (unsigned) quantity. Alas, the types are such
483 that we need to store .val as a signed quantity. Sorry
484 for the mess, but C doesn't officially guarantee that a simple
485 assignment does the trick (no, it doesn't; read the reference manual).
486 */
487 yylval.typed_val.type
488 = builtin_type (par_state->gdbarch ())->builtin_unsigned_long;
489 if (value & LONGEST_SIGN)
490 yylval.typed_val.val =
491 (LONGEST) (value & ~LONGEST_SIGN)
492 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
493 else
494 yylval.typed_val.val = (LONGEST) value;
495 return INT;
496 }
497 else if (fits_in_type (1, value, long_long_bits, true))
498 yylval.typed_val.type = type_long_long (par_state);
499 else if (fits_in_type (1, value, long_long_bits, false))
500 {
501 yylval.typed_val.type
503 /* See unsigned long case above. */
504 if (value & LONGEST_SIGN)
505 yylval.typed_val.val =
506 (LONGEST) (value & ~LONGEST_SIGN)
507 - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
508 else
509 yylval.typed_val.val = (LONGEST) value;
510 return INT;
511 }
512 else
513 error (_("Integer literal out of range"));
514
515 yylval.typed_val.val = value;
516 return INT;
517}
518
519static int
520processReal (struct parser_state *par_state, const char *num0)
521{
522 yylval.typed_val_float.type = type_long_double (par_state);
523
524 bool parsed = parse_float (num0, strlen (num0),
525 yylval.typed_val_float.type,
526 yylval.typed_val_float.val);
527 gdb_assert (parsed);
528 return FLOAT;
529}
530
531
532/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
533 resulting string is valid until the next call to ada_parse. If
534 NAME0 contains the substring "___", it is assumed to be already
535 encoded and the resulting name is equal to it. Similarly, if the name
536 starts with '<', it is copied verbatim. Otherwise, it differs
537 from NAME0 in that:
538 + Characters between '...' are transfered verbatim to yylval.ssym.
539 + Trailing "'" characters in quoted sequences are removed (a leading quote is
540 preserved to indicate that the name is not to be GNAT-encoded).
541 + Unquoted whitespace is removed.
542 + Unquoted alphabetic characters are mapped to lower case.
543 Result is returned as a struct stoken, but for convenience, the string
544 is also null-terminated. Result string valid until the next call of
545 ada_parse.
546 */
547static struct stoken
548processId (const char *name0, int len)
549{
550 char *name = (char *) obstack_alloc (&temp_parse_space, len + 11);
551 int i0, i;
552 struct stoken result;
553
554 result.ptr = name;
555 while (len > 0 && isspace (name0[len-1]))
556 len -= 1;
557
558 if (name0[0] == '<' || strstr (name0, "___") != NULL)
559 {
560 strncpy (name, name0, len);
561 name[len] = '\000';
562 result.length = len;
563 return result;
564 }
565
566 bool in_quotes = false;
567 i = i0 = 0;
568 while (i0 < len)
569 {
570 if (name0[i0] == COMPLETE_CHAR)
571 {
572 /* Just ignore. */
573 ++i0;
574 }
575 else if (in_quotes)
576 name[i++] = name0[i0++];
577 else if (isalnum (name0[i0]))
578 {
579 name[i] = tolower (name0[i0]);
580 i += 1; i0 += 1;
581 }
582 else if (isspace (name0[i0]))
583 i0 += 1;
584 else if (name0[i0] == '\'')
585 {
586 /* Copy the starting quote, but not the ending quote. */
587 if (!in_quotes)
588 name[i++] = name0[i0++];
589 in_quotes = !in_quotes;
590 }
591 else
592 name[i++] = name0[i0++];
593 }
594 name[i] = '\000';
595
596 result.length = i;
597 return result;
598}
599
600/* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
601 with special hex character notations replaced with characters.
602 Result valid until the next call to ada_parse. */
603
604static struct stoken
605processString (const char *text, int len)
606{
607 const char *p;
608 char *q;
609 const char *lim = text + len;
610 struct stoken result;
611
612 q = (char *) obstack_alloc (&temp_parse_space, len);
613 result.ptr = q;
614 p = text;
615 while (p < lim)
616 {
617 if (p[0] == '[' && p[1] == '"' && p+2 < lim)
618 {
619 if (p[2] == '"') /* "...["""]... */
620 {
621 *q = '"';
622 p += 4;
623 }
624 else
625 {
626 const char *end;
627 ULONGEST chr = strtoulst (p + 2, &end, 16);
628 if (chr > 0xff)
629 error (_("wide strings are not yet supported"));
630 *q = (char) chr;
631 p = end + 1;
632 }
633 }
634 else
635 *q = *p;
636 q += 1;
637 p += 1;
638 }
639 result.length = q - result.ptr;
640 return result;
641}
642
643/* Returns the position within STR of the '.' in a
644 '.{WHITE}*all' component of a dotted name, or -1 if there is none.
645 Note: we actually don't need this routine, since 'all' can never be an
646 Ada identifier. Thus, looking up foo.all or foo.all.x as a name
647 must fail, and will eventually be interpreted as (foo).all or
648 (foo).all.x. However, this does avoid an extraneous lookup. */
649
650static int
651find_dot_all (const char *str)
652{
653 int i;
654
655 for (i = 0; str[i] != '\000'; i++)
656 if (str[i] == '.')
657 {
658 int i0 = i;
659
660 do
661 i += 1;
662 while (isspace (str[i]));
663
664 if (strncasecmp (str + i, "all", 3) == 0
665 && !isalnum (str[i + 3]) && str[i + 3] != '_')
666 return i0;
667 }
668 return -1;
669}
670
671/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
672 case. */
673
674static int
675subseqMatch (const char *subseq, const char *str)
676{
677 if (subseq[0] == '\0')
678 return 1;
679 else if (str[0] == '\0')
680 return 0;
681 else if (tolower (subseq[0]) == tolower (str[0]))
682 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
683 else
684 return subseqMatch (subseq, str+1);
685}
686
687
688static struct { const char *name; int code; }
689attributes[] = {
690 { "address", TICK_ADDRESS },
691 { "unchecked_access", TICK_ACCESS },
692 { "unrestricted_access", TICK_ACCESS },
693 { "access", TICK_ACCESS },
694 { "first", TICK_FIRST },
695 { "last", TICK_LAST },
696 { "length", TICK_LENGTH },
697 { "max", TICK_MAX },
698 { "min", TICK_MIN },
699 { "modulus", TICK_MODULUS },
700 { "pos", TICK_POS },
701 { "range", TICK_RANGE },
702 { "size", TICK_SIZE },
703 { "tag", TICK_TAG },
704 { "val", TICK_VAL },
706
707/* Return the syntactic code corresponding to the attribute name or
708 abbreviation STR. */
709
710static int
711processAttribute (const char *str)
712{
713 gdb_assert (*str == '\'');
714 ++str;
715 while (isspace (*str))
716 ++str;
717
718 int len = strlen (str);
719 if (len > 0 && str[len - 1] == COMPLETE_CHAR)
720 {
721 /* This is enforced by YY_INPUT. */
722 gdb_assert (pstate->parse_completion);
723 yylval.sval.ptr = obstack_strndup (&temp_parse_space, str, len - 1);
724 yylval.sval.length = len - 1;
725 return TICK_COMPLETE;
726 }
727
728 for (const auto &item : attributes)
729 if (strcasecmp (str, item.name) == 0)
730 return item.code;
731
732 gdb::optional<int> found;
733 for (const auto &item : attributes)
734 if (subseqMatch (str, item.name))
735 {
736 if (!found.has_value ())
737 found = item.code;
738 else
739 error (_("ambiguous attribute name: `%s'"), str);
740 }
741 if (!found.has_value ())
742 error (_("unrecognized attribute: `%s'"), str);
743
744 return *found;
745}
746
747bool
749 completion_tracker &tracker)
750{
751 completion_list output;
752 for (const auto &item : attributes)
753 {
754 if (strncasecmp (item.name, m_name.c_str (), m_name.length ()) == 0)
755 output.emplace_back (xstrdup (item.name));
756 }
757 tracker.add_completions (std::move (output));
758 return true;
759}
760
761/* Back up lexptr by yyleng and then to the rightmost occurrence of
762 character CH, case-folded (there must be one). WARNING: since
763 lexptr points to the next input character that Flex has not yet
764 transferred to its internal buffer, the use of this function
765 depends on the assumption that Flex calls YY_INPUT only when it is
766 logically necessary to do so (thus, there is no reading ahead
767 farther than needed to identify the next token.) */
768
769static void
771{
772 pstate->lexptr -= yyleng;
773 while (toupper (*pstate->lexptr) != toupper (ch))
774 pstate->lexptr -= 1;
775 yyrestart (NULL);
776}
777
778/* Dummy definition to suppress warnings about unused static definitions. */
779typedef void (*dummy_function) ();
781{
783};
784
785DIAGNOSTIC_POP