GDB (xrefs)
Loading...
Searching...
No Matches
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
#define TICK_VAL
Definition ada-exp.c:605
#define LEQ
Definition ada-exp.c:581
#define DOLLAR_VARIABLE
Definition ada-exp.c:573
#define ELSE
Definition ada-exp.c:579
#define TRUEKEYWORD
Definition ada-exp.c:564
#define STRING
Definition ada-exp.c:567
#define NOTEQUAL
Definition ada-exp.c:580
#define TICK_ADDRESS
Definition ada-exp.c:594
#define yyrestart
Definition ada-exp.c:3122
#define ABS
Definition ada-exp.c:589
#define TICK_COMPLETE
Definition ada-exp.c:570
#define TICK_ENUM_REP
Definition ada-exp.c:606
#define TICK_POS
Definition ada-exp.c:601
#define OR
Definition ada-exp.c:576
#define yytext
Definition ada-exp.c:3123
#define FALSEKEYWORD
Definition ada-exp.c:565
#define TICK_TAG
Definition ada-exp.c:604
#define TICK_SIZE
Definition ada-exp.c:603
#define XOR
Definition ada-exp.c:577
#define NAME
Definition ada-exp.c:568
#define REM
Definition ada-exp.c:587
#define ASSIGN
Definition ada-exp.c:574
#define TICK_RANGE
Definition ada-exp.c:602
static struct parser_state * pstate
Definition ada-exp.c:101
#define NULL_PTR
Definition ada-exp.c:561
#define TICK_ENUM_VAL
Definition ada-exp.c:607
static struct type * type_for_char(struct parser_state *, ULONGEST)
Definition ada-exp.c:3845
static struct obstack temp_parse_space
Definition ada-exp.c:3125
#define ARROW
Definition ada-exp.c:592
#define OTHERS
Definition ada-exp.c:609
#define DOT_COMPLETE
Definition ada-exp.c:571
#define STARSTAR
Definition ada-exp.c:588
#define CHARLIT
Definition ada-exp.c:562
#define DOTDOT
Definition ada-exp.c:584
#define parse_type(ps)
Definition ada-exp.c:84
#define TICK_LENGTH
Definition ada-exp.c:597
#define TICK_MODULUS
Definition ada-exp.c:600
#define NAME_COMPLETE
Definition ada-exp.c:572
#define GEQ
Definition ada-exp.c:582
#define COLONCOLON
Definition ada-exp.c:566
#define TICK_MIN
Definition ada-exp.c:599
#define NEW
Definition ada-exp.c:608
#define IN
Definition ada-exp.c:583
#define MOD
Definition ada-exp.c:586
#define DOT_ID
Definition ada-exp.c:569
#define _AND_
Definition ada-exp.c:575
#define NOT
Definition ada-exp.c:590
#define TICK_MAX
Definition ada-exp.c:598
#define THEN
Definition ada-exp.c:578
#define TICK_LAST
Definition ada-exp.c:596
#define FLOAT
Definition ada-exp.c:563
#define TICK_FIRST
Definition ada-exp.c:595
#define TICK_ACCESS
Definition ada-exp.c:593
static std::vector< std::unique_ptr< gdb_mpz > > int_storage
Definition ada-exp.c:109
#define INT
Definition ada-exp.c:560
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:695
static int subseqMatch(const char *subseq, const char *str)
Definition ada-lex.l:657
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:754
int code
Definition ada-lex.l:670
static struct stoken processId(const char *, int)
Definition ada-lex.l:530
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:587
const char * name
Definition ada-lex.l:670
static int paren_depth
Definition ada-lex.l:112
dummy_function ada_flex_use[]
Definition ada-lex.l:764
static struct @5 attributes[]
void(* dummy_function)()
Definition ada-lex.l:763
static int processReal(struct parser_state *, const char *)
Definition ada-lex.l:502
static int find_dot_all(const char *)
Definition ada-lex.l:633
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
int gdbarch_long_long_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1483
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1449
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1466
enum bfd_endian type_byte_order(const struct type *type)
Definition gdbtypes.c:3900
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
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:1006
bool parse_float(const char *p, int len, const struct type *type, gdb_byte *data)
Definition parse.c:520
bool fits_in_type(int n_sign, ULONGEST n, int type_bits, bool type_signed_p)
Definition parse.c:530
int value
Definition py-param.c:79
std::string m_name
Definition ada-exp.c:442
bool complete(struct expression *exp, completion_tracker &tracker) override
Definition ada-lex.c:2999
struct type * builtin_unsigned_long_long
Definition gdbtypes.h:2097
struct type * builtin_unsigned_long
Definition gdbtypes.h:2086
const struct language_defn * language()
Definition parser-defs.h:66
struct gdbarch * gdbarch()
Definition parser-defs.h:59
void write(gdb::array_view< gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p) const
Definition gmp-utils.h:145
bool parse_completion
bool comma_terminates
const char * lexptr
int length
const char * ptr
ULONGEST length() const
Definition gdbtypes.h:983
Definition value.h:130
#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_char.val = yytext[1];
183 yylval.typed_char.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_char.val = v;
190 yylval.typed_char.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 formatted. 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 result *= base;
426 result += dig;
427 ++num0;
428 }
429
430 while (exp > 0)
431 {
432 result *= 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 int_storage.emplace_back (new gdb_mpz (std::move (result)));
466 const gdb_mpz *value = int_storage.back ().get ();
467
468 int int_bits = gdbarch_int_bit (par_state->gdbarch ());
469 int long_bits = gdbarch_long_bit (par_state->gdbarch ());
470 int long_long_bits = gdbarch_long_long_bit (par_state->gdbarch ());
471
472 if (fits_in_type (1, *value, int_bits, true))
473 yylval.typed_val.type = parse_type (par_state)->builtin_int;
474 else if (fits_in_type (1, *value, long_bits, true))
475 yylval.typed_val.type = parse_type (par_state)->builtin_long;
476 else if (fits_in_type (1, *value, long_bits, false))
477 yylval.typed_val.type
478 = builtin_type (par_state->gdbarch ())->builtin_unsigned_long;
479 else if (fits_in_type (1, *value, long_long_bits, true))
480 yylval.typed_val.type = parse_type (par_state)->builtin_long_long;
481 else if (fits_in_type (1, *value, long_long_bits, false))
482 yylval.typed_val.type
484 else if (fits_in_type (1, *value, 128, true))
485 yylval.typed_val.type
487 par_state->gdbarch (),
488 "long_long_long_integer");
489 else if (fits_in_type (1, *value, 128, false))
490 yylval.typed_val.type
492 par_state->gdbarch (),
493 "unsigned_long_long_long_integer");
494 else
495 error (_("Integer literal out of range"));
496
497 yylval.typed_val.val = value;
498 return INT;
499}
500
501static int
502processReal (struct parser_state *par_state, const char *num0)
503{
504 yylval.typed_val_float.type = parse_type (par_state)->builtin_long_double;
505
506 bool parsed = parse_float (num0, strlen (num0),
507 yylval.typed_val_float.type,
508 yylval.typed_val_float.val);
509 gdb_assert (parsed);
510 return FLOAT;
511}
512
513
514/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
515 resulting string is valid until the next call to ada_parse. If
516 NAME0 contains the substring "___", it is assumed to be already
517 encoded and the resulting name is equal to it. Similarly, if the name
518 starts with '<', it is copied verbatim. Otherwise, it differs
519 from NAME0 in that:
520 + Characters between '...' are transfered verbatim to yylval.ssym.
521 + Trailing "'" characters in quoted sequences are removed (a leading quote is
522 preserved to indicate that the name is not to be GNAT-encoded).
523 + Unquoted whitespace is removed.
524 + Unquoted alphabetic characters are mapped to lower case.
525 Result is returned as a struct stoken, but for convenience, the string
526 is also null-terminated. Result string valid until the next call of
527 ada_parse.
528 */
529static struct stoken
530processId (const char *name0, int len)
531{
532 char *name = (char *) obstack_alloc (&temp_parse_space, len + 11);
533 int i0, i;
534 struct stoken result;
535
536 result.ptr = name;
537 while (len > 0 && isspace (name0[len-1]))
538 len -= 1;
539
540 if (name0[0] == '<' || strstr (name0, "___") != NULL)
541 {
542 strncpy (name, name0, len);
543 name[len] = '\000';
544 result.length = len;
545 return result;
546 }
547
548 bool in_quotes = false;
549 i = i0 = 0;
550 while (i0 < len)
551 {
552 if (name0[i0] == COMPLETE_CHAR)
553 {
554 /* Just ignore. */
555 ++i0;
556 }
557 else if (in_quotes)
558 name[i++] = name0[i0++];
559 else if (isalnum (name0[i0]))
560 {
561 name[i] = tolower (name0[i0]);
562 i += 1; i0 += 1;
563 }
564 else if (isspace (name0[i0]))
565 i0 += 1;
566 else if (name0[i0] == '\'')
567 {
568 /* Copy the starting quote, but not the ending quote. */
569 if (!in_quotes)
570 name[i++] = name0[i0++];
571 in_quotes = !in_quotes;
572 }
573 else
574 name[i++] = name0[i0++];
575 }
576 name[i] = '\000';
577
578 result.length = i;
579 return result;
580}
581
582/* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
583 with special hex character notations replaced with characters.
584 Result valid until the next call to ada_parse. */
585
586static struct stoken
587processString (const char *text, int len)
588{
589 const char *p;
590 char *q;
591 const char *lim = text + len;
592 struct stoken result;
593
594 q = (char *) obstack_alloc (&temp_parse_space, len);
595 result.ptr = q;
596 p = text;
597 while (p < lim)
598 {
599 if (p[0] == '[' && p[1] == '"' && p+2 < lim)
600 {
601 if (p[2] == '"') /* "...["""]... */
602 {
603 *q = '"';
604 p += 4;
605 }
606 else
607 {
608 const char *end;
609 ULONGEST chr = strtoulst (p + 2, &end, 16);
610 if (chr > 0xff)
611 error (_("wide strings are not yet supported"));
612 *q = (char) chr;
613 p = end + 1;
614 }
615 }
616 else
617 *q = *p;
618 q += 1;
619 p += 1;
620 }
621 result.length = q - result.ptr;
622 return result;
623}
624
625/* Returns the position within STR of the '.' in a
626 '.{WHITE}*all' component of a dotted name, or -1 if there is none.
627 Note: we actually don't need this routine, since 'all' can never be an
628 Ada identifier. Thus, looking up foo.all or foo.all.x as a name
629 must fail, and will eventually be interpreted as (foo).all or
630 (foo).all.x. However, this does avoid an extraneous lookup. */
631
632static int
633find_dot_all (const char *str)
634{
635 int i;
636
637 for (i = 0; str[i] != '\000'; i++)
638 if (str[i] == '.')
639 {
640 int i0 = i;
641
642 do
643 i += 1;
644 while (isspace (str[i]));
645
646 if (strncasecmp (str + i, "all", 3) == 0
647 && !isalnum (str[i + 3]) && str[i + 3] != '_')
648 return i0;
649 }
650 return -1;
651}
652
653/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
654 case. */
655
656static int
657subseqMatch (const char *subseq, const char *str)
658{
659 if (subseq[0] == '\0')
660 return 1;
661 else if (str[0] == '\0')
662 return 0;
663 else if (tolower (subseq[0]) == tolower (str[0]))
664 return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
665 else
666 return subseqMatch (subseq, str+1);
667}
668
669
670static struct { const char *name; int code; }
671attributes[] = {
672 { "address", TICK_ADDRESS },
673 { "unchecked_access", TICK_ACCESS },
674 { "unrestricted_access", TICK_ACCESS },
675 { "access", TICK_ACCESS },
676 { "first", TICK_FIRST },
677 { "last", TICK_LAST },
678 { "length", TICK_LENGTH },
679 { "max", TICK_MAX },
680 { "min", TICK_MIN },
681 { "modulus", TICK_MODULUS },
682 { "pos", TICK_POS },
683 { "range", TICK_RANGE },
684 { "size", TICK_SIZE },
685 { "tag", TICK_TAG },
686 { "val", TICK_VAL },
687 { "enum_rep", TICK_ENUM_REP },
688 { "enum_val", TICK_ENUM_VAL },
690
691/* Return the syntactic code corresponding to the attribute name or
692 abbreviation STR. */
693
694static int
695processAttribute (const char *str)
696{
697 gdb_assert (*str == '\'');
698 ++str;
699 while (isspace (*str))
700 ++str;
701
702 int len = strlen (str);
703 if (len > 0 && str[len - 1] == COMPLETE_CHAR)
704 {
705 /* This is enforced by YY_INPUT. */
706 gdb_assert (pstate->parse_completion);
707 yylval.sval.ptr = obstack_strndup (&temp_parse_space, str, len - 1);
708 yylval.sval.length = len - 1;
709 return TICK_COMPLETE;
710 }
711
712 for (const auto &item : attributes)
713 if (strcasecmp (str, item.name) == 0)
714 return item.code;
715
716 gdb::optional<int> found;
717 for (const auto &item : attributes)
718 if (subseqMatch (str, item.name))
719 {
720 if (!found.has_value ())
721 found = item.code;
722 else
723 error (_("ambiguous attribute name: `%s'"), str);
724 }
725 if (!found.has_value ())
726 error (_("unrecognized attribute: `%s'"), str);
727
728 return *found;
729}
730
731bool
733 completion_tracker &tracker)
734{
735 completion_list output;
736 for (const auto &item : attributes)
737 {
738 if (strncasecmp (item.name, m_name.c_str (), m_name.length ()) == 0)
739 output.emplace_back (xstrdup (item.name));
740 }
741 tracker.add_completions (std::move (output));
742 return true;
743}
744
745/* Back up lexptr by yyleng and then to the rightmost occurrence of
746 character CH, case-folded (there must be one). WARNING: since
747 lexptr points to the next input character that Flex has not yet
748 transferred to its internal buffer, the use of this function
749 depends on the assumption that Flex calls YY_INPUT only when it is
750 logically necessary to do so (thus, there is no reading ahead
751 farther than needed to identify the next token.) */
752
753static void
755{
756 pstate->lexptr -= yyleng;
757 while (toupper (*pstate->lexptr) != toupper (ch))
758 pstate->lexptr -= 1;
759 yyrestart (NULL);
760}
761
762/* Dummy definition to suppress warnings about unused static definitions. */
763typedef void (*dummy_function) ();
768
769DIAGNOSTIC_POP