-/* FLEX lexer for Ada expressions, for GDB.
- Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007
- Free Software Foundation, Inc.
+/* FLEX lexer for Ada expressions, for GDB. -*- c++ -*-
+ Copyright (C) 1994-2022 Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/*----------------------------------------------------------------------*/
NUM16 ({HEXDIG}({HEXDIG}|_)*)
OCTDIG [0-7]
LETTER [a-z_]
-ID ({LETTER}({LETTER}|{DIG})*|"<"{LETTER}({LETTER}|{DIG})*">")
+ID ({LETTER}({LETTER}|{DIG}|[\x80-\xff])*|"<"{LETTER}({LETTER}|{DIG})*">")
WHITE [ \t\n]
TICK ("'"{WHITE}*)
GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
EXP (e[+-]{NUM10})
POSEXP (e"+"?{NUM10})
+/* This must agree with COMPLETION_CHAR below. See the comment there
+ for the explanation. */
+COMPLETE "\001"
+NOT_COMPLETE [^\001]
+
%{
+#include "diagnostics.h"
+
+/* Some old versions of flex generate code that uses the "register" keyword,
+ which clang warns about. This was observed for example with flex 2.5.35,
+ as shipped with macOS 10.12. The same happens with flex 2.5.37 and g++ 11
+ which defaults to ISO C++17, that does not allow register storage class
+ specifiers. */
+DIAGNOSTIC_PUSH
+DIAGNOSTIC_IGNORE_DEPRECATED_REGISTER
+
#define NUMERAL_WIDTH 256
#define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
static char numbuf[NUMERAL_WIDTH];
static void canonicalizeNumeral (char *s1, const char *);
static struct stoken processString (const char*, int);
-static int processInt (const char *, const char *, const char *);
-static int processReal (const char *);
+static int processInt (struct parser_state *, const char *, const char *,
+ const char *);
+static int processReal (struct parser_state *, const char *);
static struct stoken processId (const char *, int);
static int processAttribute (const char *);
static int find_dot_all (const char *);
+static void rewind_to_char (int);
#undef YY_DECL
#define YY_DECL static int yylex ( void )
+/* Flex generates a static function "input" which is not used.
+ Defining YY_NO_INPUT comments it out. */
+#define YY_NO_INPUT
+
+/* When completing, we'll return a special character at the end of the
+ input, to signal the completion position to the lexer. This is
+ done because flex does not have a generally useful way to detect
+ EOF in a pattern. This variable records whether the special
+ character has been emitted. */
+static bool returned_complete = false;
+
+/* The character we use to represent the completion point. */
+#define COMPLETE_CHAR '\001'
+
#undef YY_INPUT
-#define YY_INPUT(BUF, RESULT, MAX_SIZE) \
- if ( *lexptr == '\000' ) \
- (RESULT) = YY_NULL; \
- else \
- { \
- *(BUF) = *lexptr; \
- (RESULT) = 1; \
- lexptr += 1; \
- }
+#define YY_INPUT(BUF, RESULT, MAX_SIZE) \
+ if ( *pstate->lexptr == '\000' ) \
+ { \
+ if (pstate->parse_completion && !returned_complete) \
+ { \
+ returned_complete = true; \
+ *(BUF) = COMPLETE_CHAR; \
+ (RESULT) = 1; \
+ } \
+ else \
+ (RESULT) = YY_NULL; \
+ } \
+ else \
+ { \
+ *(BUF) = *pstate->lexptr == COMPLETE_CHAR ? ' ' : *pstate->lexptr; \
+ (RESULT) = 1; \
+ pstate->lexptr += 1; \
+ }
-static int find_dot_all (const char *);
+/* Depth of parentheses. */
+static int paren_depth;
%}
-%option case-insensitive interactive nodefault
+%option case-insensitive interactive nodefault noyywrap
%s BEFORE_QUAL_QUOTE
{NUM10}{POSEXP} {
canonicalizeNumeral (numbuf, yytext);
- return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
+ char *e_ptr = strrchr (numbuf, 'e');
+ *e_ptr = '\0';
+ return processInt (pstate, nullptr, numbuf, e_ptr + 1);
}
{NUM10} {
canonicalizeNumeral (numbuf, yytext);
- return processInt (NULL, numbuf, NULL);
+ return processInt (pstate, NULL, numbuf, NULL);
}
{NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
canonicalizeNumeral (numbuf, yytext);
- return processInt (numbuf,
+ char *e_ptr = strrchr (numbuf, 'e');
+ *e_ptr = '\0';
+ return processInt (pstate, numbuf,
strchr (numbuf, '#') + 1,
- strrchr(numbuf, '#') + 1);
+ e_ptr + 1);
}
-{NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
+ /* The "llf" is a gdb extension to allow a floating-point
+ constant to be written in some other base. The
+ floating-point number is formed by reinterpreting the
+ bytes, allowing direct control over the bits. */
+{NUM10}(l{0,2}f)?"#"{HEXDIG}({HEXDIG}|_)*"#" {
canonicalizeNumeral (numbuf, yytext);
- return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
+ return processInt (pstate, numbuf, strchr (numbuf, '#') + 1,
+ NULL);
}
"0x"{HEXDIG}+ {
canonicalizeNumeral (numbuf, yytext+2);
- return processInt ("16#", numbuf, NULL);
+ return processInt (pstate, "16#", numbuf, NULL);
}
{NUM10}"."{NUM10}{EXP} {
canonicalizeNumeral (numbuf, yytext);
- return processReal (numbuf);
+ return processReal (pstate, numbuf);
}
{NUM10}"."{NUM10} {
canonicalizeNumeral (numbuf, yytext);
- return processReal (numbuf);
+ return processReal (pstate, numbuf);
}
{NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
}
<INITIAL>"'"({GRAPHIC}|\")"'" {
- yylval.typed_val.type = type_char ();
yylval.typed_val.val = yytext[1];
+ yylval.typed_val.type = type_for_char (pstate, yytext[1]);
return CHARLIT;
}
-<INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
- int v;
- yylval.typed_val.type = type_char ();
- sscanf (yytext+3, "%2x", &v);
+<INITIAL>"'[\""{HEXDIG}{2,}"\"]'" {
+ ULONGEST v = strtoulst (yytext+3, nullptr, 16);
yylval.typed_val.val = v;
+ yylval.typed_val.type = type_for_char (pstate, v);
return CHARLIT;
}
-\"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\" {
+ /* Note that we don't handle bracket sequences of more than 2
+ digits here. Currently there's no support for wide or
+ wide-wide strings. */
+\"({GRAPHIC}|"[\""({HEXDIG}{2,}|\")"\"]")*\" {
yylval.sval = processString (yytext+1, yyleng-2);
return STRING;
}
if {
- while (*lexptr != 'i' && *lexptr != 'I')
- lexptr -= 1;
- yyrestart(NULL);
+ rewind_to_char ('i');
+ return 0;
+ }
+
+task {
+ rewind_to_char ('t');
+ return 0;
+ }
+
+thread{WHITE}+{DIG} {
+ /* This keyword signals the end of the expression and
+ will be processed separately. */
+ rewind_to_char ('t');
return 0;
}
then { return THEN; }
xor { return XOR; }
+ /* BOOLEAN "KEYWORDS" */
+
+ /* True and False are not keywords in Ada, but rather enumeration constants.
+ However, the boolean type is no longer represented as an enum, so True
+ and False are no longer defined in symbol tables. We compromise by
+ making them keywords (when bare). */
+
+true { return TRUEKEYWORD; }
+false { return FALSEKEYWORD; }
+
/* ATTRIBUTES */
-{TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }
+{TICK}([a-z][a-z_]*)?{COMPLETE}? { BEGIN INITIAL; return processAttribute (yytext); }
/* PUNCTUATION */
"<=" { return LEQ; }
">=" { return GEQ; }
-<BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
+<BEFORE_QUAL_QUOTE>"'"/{NOT_COMPLETE} { BEGIN INITIAL; return '\''; }
-[-&*+./:<>=|;\[\]] { return yytext[0]; }
+[-&*+{}@/:<>=|;\[\]] { return yytext[0]; }
-"," { if (paren_depth == 0 && comma_terminates)
+"," { if (paren_depth == 0 && pstate->comma_terminates)
{
- lexptr -= 1;
- yyrestart(NULL);
+ rewind_to_char (',');
return 0;
}
else
"(" { paren_depth += 1; return '('; }
")" { if (paren_depth == 0)
{
- lexptr -= 1;
- yyrestart(NULL);
+ rewind_to_char (')');
return 0;
}
else
}
}
-"."{WHITE}*all { return DOT_ALL; }
-
-"."{WHITE}*{ID} {
+"."{WHITE}*{ID}{COMPLETE}? {
yylval.sval = processId (yytext+1, yyleng-1);
+ if (yytext[yyleng - 1] == COMPLETE_CHAR)
+ return DOT_COMPLETE;
return DOT_ID;
}
-{ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")? {
+"."{WHITE}*{COMPLETE} {
+ yylval.sval.ptr = "";
+ yylval.sval.length = 0;
+ return DOT_COMPLETE;
+ }
+
+{ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'"|{COMPLETE})? {
int all_posn = find_dot_all (yytext);
if (all_posn == -1 && yytext[yyleng-1] == '\'')
}
else if (all_posn >= 0)
yyless (all_posn);
+ bool is_completion = yytext[yyleng - 1] == COMPLETE_CHAR;
yylval.sval = processId (yytext, yyleng);
- return NAME;
+ return is_completion ? NAME_COMPLETE : NAME;
}
"::" { return COLONCOLON; }
-[{}@] { return yytext[0]; }
-
/* REGISTERS AND GDB CONVENIENCE VARIABLES */
"$"({LETTER}|{DIG}|"$")* {
yylval.sval.ptr = yytext;
yylval.sval.length = yyleng;
- return SPECIAL_VARIABLE;
+ return DOLLAR_VARIABLE;
}
/* CATCH-ALL ERROR CASE */
%%
#include <ctype.h>
-#include "gdb_string.h"
-
/* Initialize the lexer for processing new expression. */
-void
+static void
lexer_init (FILE *inp)
{
BEGIN INITIAL;
+ paren_depth = 0;
+ returned_complete = false;
yyrestart (inp);
}
*/
static int
-processInt (const char *base0, const char *num0, const char *exp0)
+processInt (struct parser_state *par_state, const char *base0,
+ const char *num0, const char *exp0)
{
- ULONGEST result;
long exp;
int base;
-
- char *trailer;
+ /* For the based literal with an "f" prefix, we'll return a
+ floating-point number. This counts the the number of "l"s seen,
+ to decide the width of the floating-point number to return. -1
+ means no "f". */
+ int floating_point_l_count = -1;
if (base0 == NULL)
base = 10;
else
{
- base = strtol (base0, (char **) NULL, 10);
+ char *end_of_base;
+ base = strtol (base0, &end_of_base, 10);
if (base < 2 || base > 16)
error (_("Invalid base: %d."), base);
+ while (*end_of_base == 'l')
+ {
+ ++floating_point_l_count;
+ ++end_of_base;
+ }
+ /* This assertion is ensured by the pattern. */
+ gdb_assert (floating_point_l_count == -1 || *end_of_base == 'f');
+ if (*end_of_base == 'f')
+ {
+ ++end_of_base;
+ ++floating_point_l_count;
+ }
+ /* This assertion is ensured by the pattern. */
+ gdb_assert (*end_of_base == '#');
}
if (exp0 == NULL)
else
exp = strtol(exp0, (char **) NULL, 10);
- errno = 0;
- result = strtoulst (num0, (const char **) &trailer, base);
- if (errno == ERANGE)
- error (_("Integer literal out of range"));
- if (isxdigit(*trailer))
- error (_("Invalid digit `%c' in based literal"), *trailer);
+ gdb_mpz result;
+ while (isxdigit (*num0))
+ {
+ int dig = fromhex (*num0);
+ if (dig >= base)
+ error (_("Invalid digit `%c' in based literal"), *num0);
+ mpz_mul_ui (result.val, result.val, base);
+ mpz_add_ui (result.val, result.val, dig);
+ ++num0;
+ }
while (exp > 0)
{
- if (result > (ULONG_MAX / base))
- error (_("Integer literal out of range"));
- result *= base;
+ mpz_mul_ui (result.val, result.val, base);
exp -= 1;
}
- if ((result >> (TARGET_INT_BIT-1)) == 0)
- yylval.typed_val.type = type_int ();
- else if ((result >> (TARGET_LONG_BIT-1)) == 0)
- yylval.typed_val.type = type_long ();
- else if (((result >> (TARGET_LONG_BIT-1)) >> 1) == 0)
+ if (floating_point_l_count > -1)
+ {
+ struct type *fp_type;
+ if (floating_point_l_count == 0)
+ fp_type = language_lookup_primitive_type (par_state->language (),
+ par_state->gdbarch (),
+ "float");
+ else if (floating_point_l_count == 1)
+ fp_type = language_lookup_primitive_type (par_state->language (),
+ par_state->gdbarch (),
+ "long_float");
+ else
+ {
+ /* This assertion is ensured by the pattern. */
+ gdb_assert (floating_point_l_count == 2);
+ fp_type = language_lookup_primitive_type (par_state->language (),
+ par_state->gdbarch (),
+ "long_long_float");
+ }
+
+ yylval.typed_val_float.type = fp_type;
+ result.write (gdb::make_array_view (yylval.typed_val_float.val,
+ TYPE_LENGTH (fp_type)),
+ type_byte_order (fp_type),
+ true);
+
+ return FLOAT;
+ }
+
+ gdb_mpz maxval (ULONGEST_MAX);
+ if (mpz_cmp (result.val, maxval.val) > 0)
+ error (_("Integer literal out of range"));
+
+ ULONGEST value = result.as_integer<ULONGEST> ();
+ if ((value >> (gdbarch_int_bit (par_state->gdbarch ())-1)) == 0)
+ yylval.typed_val.type = type_int (par_state);
+ else if ((value >> (gdbarch_long_bit (par_state->gdbarch ())-1)) == 0)
+ yylval.typed_val.type = type_long (par_state);
+ else if (((value >> (gdbarch_long_bit (par_state->gdbarch ())-1)) >> 1) == 0)
{
/* We have a number representable as an unsigned integer quantity.
For consistency with the C treatment, we will treat it as an
for the mess, but C doesn't officially guarantee that a simple
assignment does the trick (no, it doesn't; read the reference manual).
*/
- yylval.typed_val.type = builtin_type_unsigned_long;
- if (result & LONGEST_SIGN)
+ yylval.typed_val.type
+ = builtin_type (par_state->gdbarch ())->builtin_unsigned_long;
+ if (value & LONGEST_SIGN)
yylval.typed_val.val =
- (LONGEST) (result & ~LONGEST_SIGN)
+ (LONGEST) (value & ~LONGEST_SIGN)
- (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
else
- yylval.typed_val.val = (LONGEST) result;
+ yylval.typed_val.val = (LONGEST) value;
return INT;
}
else
- yylval.typed_val.type = type_long_long ();
+ yylval.typed_val.type = type_long_long (par_state);
- yylval.typed_val.val = (LONGEST) result;
+ yylval.typed_val.val = value;
return INT;
}
static int
-processReal (const char *num0)
+processReal (struct parser_state *par_state, const char *num0)
{
- sscanf (num0, DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
-
- yylval.typed_val_float.type = type_float ();
- if (sizeof(DOUBLEST) >= TARGET_DOUBLE_BIT / TARGET_CHAR_BIT)
- yylval.typed_val_float.type = type_double ();
- if (sizeof(DOUBLEST) >= TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT)
- yylval.typed_val_float.type = type_long_double ();
+ yylval.typed_val_float.type = type_long_double (par_state);
+ bool parsed = parse_float (num0, strlen (num0),
+ yylval.typed_val_float.type,
+ yylval.typed_val_float.val);
+ gdb_assert (parsed);
return FLOAT;
}
/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
- resulting string is valid until the next call to ada_parse. It differs
+ resulting string is valid until the next call to ada_parse. If
+ NAME0 contains the substring "___", it is assumed to be already
+ encoded and the resulting name is equal to it. Similarly, if the name
+ starts with '<', it is copied verbatim. Otherwise, it differs
from NAME0 in that:
- + Characters between '...' or <...> are transfered verbatim to
- yylval.ssym.
- + <, >, and trailing "'" characters in quoted sequences are removed
- (a leading quote is preserved to indicate that the name is not to be
- GNAT-encoded).
+ + Characters between '...' are transfered verbatim to yylval.ssym.
+ + Trailing "'" characters in quoted sequences are removed (a leading quote is
+ preserved to indicate that the name is not to be GNAT-encoded).
+ Unquoted whitespace is removed.
+ Unquoted alphabetic characters are mapped to lower case.
Result is returned as a struct stoken, but for convenience, the string
static struct stoken
processId (const char *name0, int len)
{
- char *name = obstack_alloc (&temp_parse_space, len + 11);
+ char *name = (char *) obstack_alloc (&temp_parse_space, len + 11);
int i0, i;
struct stoken result;
+ result.ptr = name;
while (len > 0 && isspace (name0[len-1]))
len -= 1;
+
+ if (name0[0] == '<' || strstr (name0, "___") != NULL)
+ {
+ strncpy (name, name0, len);
+ name[len] = '\000';
+ result.length = len;
+ return result;
+ }
+
+ bool in_quotes = false;
i = i0 = 0;
while (i0 < len)
{
- if (isalnum (name0[i0]))
+ if (name0[i0] == COMPLETE_CHAR)
+ {
+ /* Just ignore. */
+ ++i0;
+ }
+ else if (in_quotes)
+ name[i++] = name0[i0++];
+ else if (isalnum (name0[i0]))
{
name[i] = tolower (name0[i0]);
i += 1; i0 += 1;
}
- else switch (name0[i0])
+ else if (isspace (name0[i0]))
+ i0 += 1;
+ else if (name0[i0] == '\'')
{
- default:
- name[i] = name0[i0];
- i += 1; i0 += 1;
- break;
- case ' ': case '\t':
- i0 += 1;
- break;
- case '\'':
- do
- {
- name[i] = name0[i0];
- i += 1; i0 += 1;
- }
- while (i0 < len && name0[i0] != '\'');
- i0 += 1;
- break;
- case '<':
- i0 += 1;
- while (i0 < len && name0[i0] != '>')
- {
- name[i] = name0[i0];
- i += 1; i0 += 1;
- }
- i0 += 1;
- break;
+ /* Copy the starting quote, but not the ending quote. */
+ if (!in_quotes)
+ name[i++] = name0[i0++];
+ in_quotes = !in_quotes;
}
+ else
+ name[i++] = name0[i0++];
}
name[i] = '\000';
- result.ptr = name;
result.length = i;
return result;
}
const char *lim = text + len;
struct stoken result;
- q = result.ptr = obstack_alloc (&temp_parse_space, len);
+ q = (char *) obstack_alloc (&temp_parse_space, len);
+ result.ptr = q;
p = text;
while (p < lim)
{
}
else
{
- int chr;
- sscanf (p+2, "%2x", &chr);
+ const char *end;
+ ULONGEST chr = strtoulst (p + 2, &end, 16);
+ if (chr > 0xff)
+ error (_("wide strings are not yet supported"));
*q = (char) chr;
- p += 5;
+ p = end + 1;
}
}
else
find_dot_all (const char *str)
{
int i;
- for (i = 0; str[i] != '\000'; i += 1)
- {
- if (str[i] == '.')
- {
- int i0 = i;
- do
- i += 1;
- while (isspace (str[i]));
- if (strncmp (str+i, "all", 3) == 0
- && ! isalnum (str[i+3]) && str[i+3] != '_')
- return i0;
- }
- }
+
+ for (i = 0; str[i] != '\000'; i++)
+ if (str[i] == '.')
+ {
+ int i0 = i;
+
+ do
+ i += 1;
+ while (isspace (str[i]));
+
+ if (strncasecmp (str + i, "all", 3) == 0
+ && !isalnum (str[i + 3]) && str[i + 3] != '_')
+ return i0;
+ }
return -1;
}
{ "size", TICK_SIZE },
{ "tag", TICK_TAG },
{ "val", TICK_VAL },
- { NULL, -1 }
};
/* Return the syntactic code corresponding to the attribute name or
static int
processAttribute (const char *str)
{
- int i, k;
+ gdb_assert (*str == '\'');
+ ++str;
+ while (isspace (*str))
+ ++str;
+
+ int len = strlen (str);
+ if (len > 0 && str[len - 1] == COMPLETE_CHAR)
+ {
+ /* This is enforced by YY_INPUT. */
+ gdb_assert (pstate->parse_completion);
+ yylval.sval.ptr = obstack_strndup (&temp_parse_space, str, len - 1);
+ yylval.sval.length = len - 1;
+ return TICK_COMPLETE;
+ }
- for (i = 0; attributes[i].code != -1; i += 1)
- if (strcasecmp (str, attributes[i].name) == 0)
- return attributes[i].code;
+ for (const auto &item : attributes)
+ if (strcasecmp (str, item.name) == 0)
+ return item.code;
- for (i = 0, k = -1; attributes[i].code != -1; i += 1)
- if (subseqMatch (str, attributes[i].name))
+ gdb::optional<int> found;
+ for (const auto &item : attributes)
+ if (subseqMatch (str, item.name))
{
- if (k == -1)
- k = i;
+ if (!found.has_value ())
+ found = item.code;
else
error (_("ambiguous attribute name: `%s'"), str);
}
- if (k == -1)
+ if (!found.has_value ())
error (_("unrecognized attribute: `%s'"), str);
- return attributes[k].code;
+ return *found;
}
-int
-yywrap(void)
+bool
+ada_tick_completer::complete (struct expression *exp,
+ completion_tracker &tracker)
{
- return 1;
+ completion_list output;
+ for (const auto &item : attributes)
+ {
+ if (strncasecmp (item.name, m_name.c_str (), m_name.length ()) == 0)
+ output.emplace_back (xstrdup (item.name));
+ }
+ tracker.add_completions (std::move (output));
+ return true;
+}
+
+/* Back up lexptr by yyleng and then to the rightmost occurrence of
+ character CH, case-folded (there must be one). WARNING: since
+ lexptr points to the next input character that Flex has not yet
+ transferred to its internal buffer, the use of this function
+ depends on the assumption that Flex calls YY_INPUT only when it is
+ logically necessary to do so (thus, there is no reading ahead
+ farther than needed to identify the next token.) */
+
+static void
+rewind_to_char (int ch)
+{
+ pstate->lexptr -= yyleng;
+ while (toupper (*pstate->lexptr) != toupper (ch))
+ pstate->lexptr -= 1;
+ yyrestart (NULL);
}
/* Dummy definition to suppress warnings about unused static definitions. */
{
(dummy_function) yyunput
};
+
+DIAGNOSTIC_POP
projects / binutils-gdb.git / blobdiff