blob: 6337fe744cf7df7e3ca213ff5fbe07b63b6b8e16 [file]
/* YACC parser support code for Modula-2 expressions, for GDB.
Copyright (C) 1986-2026 Free Software Foundation, Inc.
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 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.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "m2-exp-parser.h"
#include "m2-exp-parser-gen.h"
#include "block.h"
#include "expression.h"
#include "language.h"
#include "m2-exp.h"
#include "parser-defs.h"
#include "value.h"
/* The entry point of the bison/yacc-generated parser, defined in
m2-exp-parser-gen.c. Bison produces a declaration for m2_yyparse in
m2-exp-parser-gen.h, but byacc does not, hence this declaration. */
int m2_yyparse ();
/* Likewise, byacc does not produce a declaration for m2_yydebug. */
extern int m2_yydebug;
namespace m2_exp_parser
{
/* See m2-exp-parser.h. */
parser_state *pstate;
/* See m2-exp-parser.h. */
int number_sign = 1;
/* Take care of parsing a number (anything that starts with a digit).
Set yylval and return the token type; update lexptr.
LEN is the number of characters in it. */
/*** Needs some error checking for the float case ***/
static int
parse_number (int olen)
{
const char *p = pstate->lexptr;
ULONGEST n = 0;
ULONGEST prevn = 0;
int c,i,ischar=0;
int base = input_radix;
int len = olen;
if(p[len-1] == 'H')
{
base = 16;
len--;
}
else if(p[len-1] == 'C' || p[len-1] == 'B')
{
base = 8;
ischar = p[len-1] == 'C';
len--;
}
/* Scan the number */
for (c = 0; c < len; c++)
{
if (p[c] == '.' && base == 10)
{
/* It's a float since it contains a point. */
if (!parse_float (p, len,
parse_m2_type (pstate)->builtin_real,
m2_yylval.val))
return ERROR;
pstate->lexptr += len;
return FLOAT;
}
if (p[c] == '.' && base != 10)
error (_("Floating point numbers must be base 10."));
if (base == 10 && (p[c] < '0' || p[c] > '9'))
error (_("Invalid digit \'%c\' in number."),p[c]);
}
while (len-- > 0)
{
c = *p++;
n *= base;
if( base == 8 && (c == '8' || c == '9'))
error (_("Invalid digit \'%c\' in octal number."),c);
if (c >= '0' && c <= '9')
i = c - '0';
else
{
if (base == 16 && c >= 'A' && c <= 'F')
i = c - 'A' + 10;
else
return ERROR;
}
n+=i;
if(i >= base)
return ERROR;
if (n == 0 && prevn == 0)
;
else if (RANGE_CHECK && prevn >= n)
range_error (_("Overflow on numeric constant."));
prevn=n;
}
pstate->lexptr = p;
if(*p == 'B' || *p == 'C' || *p == 'H')
pstate->lexptr++; /* Advance past B,C or H */
if (ischar)
{
m2_yylval.ulval = n;
return CHAR;
}
int int_bits = gdbarch_int_bit (pstate->gdbarch ());
bool have_signed = number_sign == -1;
bool have_unsigned = number_sign == 1;
if (have_signed && fits_in_type (number_sign, n, int_bits, true))
{
m2_yylval.lval = n;
return INT;
}
else if (have_unsigned && fits_in_type (number_sign, n, int_bits, false))
{
m2_yylval.ulval = n;
return UINT;
}
else
error (_("Overflow on numeric constant."));
}
/* Some tokens */
static struct
{
char name[2];
int token;
} tokentab2[] =
{
{ {'<', '>'}, NOTEQUAL },
{ {':', '='}, ASSIGN },
{ {'<', '='}, LEQ },
{ {'>', '='}, GEQ },
{ {':', ':'}, COLONCOLON },
};
/* Some specific keywords */
struct keyword {
char keyw[10];
int token;
};
static struct keyword keytab[] =
{
{"OR" , OROR },
{"IN", IN },/* Note space after IN */
{"AND", LOGICAL_AND},
{"ABS", ABS },
{"ADR", ADR },
{"CHR", CHR },
{"DEC", DEC },
{"NOT", NOT },
{"DIV", DIV },
{"INC", INC },
{"MAX", MAX_FUNC },
{"MIN", MIN_FUNC },
{"MOD", MOD },
{"ODD", ODD },
{"CAP", CAP },
{"ORD", ORD },
{"VAL", VAL },
{"EXCL", EXCL },
{"HIGH", HIGH },
{"INCL", INCL },
{"SIZE", SIZE },
{"FLOAT", FLOAT_FUNC },
{"TRUNC", TRUNC },
{"TSIZE", SIZE },
};
/* Depth of parentheses. */
static int paren_depth;
/* See m2-exp-parser.h. */
int
m2_yylex (void)
{
int c;
int namelen;
int i;
const char *tokstart;
char quote;
retry:
pstate->prev_lexptr = pstate->lexptr;
tokstart = pstate->lexptr;
/* See if it is a special token of length 2 */
for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
if (strncmp (tokentab2[i].name, tokstart, 2) == 0)
{
pstate->lexptr += 2;
return tokentab2[i].token;
}
switch (c = *tokstart)
{
case 0:
return 0;
case ' ':
case '\t':
case '\n':
pstate->lexptr++;
goto retry;
case '(':
paren_depth++;
pstate->lexptr++;
return c;
case ')':
if (paren_depth == 0)
return 0;
paren_depth--;
pstate->lexptr++;
return c;
case ',':
if (pstate->comma_terminates && paren_depth == 0)
return 0;
pstate->lexptr++;
return c;
case '.':
/* Might be a floating point number. */
if (pstate->lexptr[1] >= '0' && pstate->lexptr[1] <= '9')
break; /* Falls into number code. */
else
{
pstate->lexptr++;
return DOT;
}
/* These are character tokens that appear as-is in the YACC grammar */
case '+':
case '-':
case '*':
case '/':
case '^':
case '<':
case '>':
case '[':
case ']':
case '=':
case '{':
case '}':
case '#':
case '@':
case '~':
case '&':
pstate->lexptr++;
return c;
case '\'' :
case '"':
quote = c;
for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++)
if (c == '\\')
{
c = tokstart[++namelen];
if (c >= '0' && c <= '9')
{
c = tokstart[++namelen];
if (c >= '0' && c <= '9')
c = tokstart[++namelen];
}
}
if(c != quote)
error (_("Unterminated string or character constant."));
m2_yylval.sval.ptr = tokstart + 1;
m2_yylval.sval.length = namelen - 1;
pstate->lexptr += namelen + 1;
if(namelen == 2) /* Single character */
{
m2_yylval.ulval = tokstart[1];
return CHAR;
}
else
return STRING;
}
/* Is it a number? */
/* Note: We have already dealt with the case of the token '.'.
See case '.' above. */
if ((c >= '0' && c <= '9'))
{
/* It's a number. */
int got_dot = 0, got_e = 0;
const char *p = tokstart;
int toktype;
for (++p ;; ++p)
{
if (!got_e && (*p == 'e' || *p == 'E'))
got_dot = got_e = 1;
else if (!got_dot && *p == '.')
got_dot = 1;
else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
&& (*p == '-' || *p == '+'))
/* This is the sign of the exponent, not the end of the
number. */
continue;
else if ((*p < '0' || *p > '9') &&
(*p < 'A' || *p > 'F') &&
(*p != 'H')) /* Modula-2 hexadecimal number */
break;
}
toktype = parse_number (p - tokstart);
if (toktype == ERROR)
error (_("Invalid number \"%.*s\"."), (int) (p - tokstart),
tokstart);
pstate->lexptr = p;
return toktype;
}
if (!(c == '_' || c == '$'
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
/* We must have come across a bad character (e.g. ';'). */
error (_("Invalid character '%c' in expression."), c);
/* It's a name. See how long it is. */
namelen = 0;
for (c = tokstart[namelen];
(c == '_' || c == '$' || (c >= '0' && c <= '9')
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
c = tokstart[++namelen])
;
/* The token "if" terminates the expression and is NOT
removed from the input stream. */
if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
{
return 0;
}
pstate->lexptr += namelen;
/* Lookup special keywords */
for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
if (namelen == strlen (keytab[i].keyw)
&& strncmp (tokstart, keytab[i].keyw, namelen) == 0)
return keytab[i].token;
m2_yylval.sval.ptr = tokstart;
m2_yylval.sval.length = namelen;
if (*tokstart == '$')
return DOLLAR_VARIABLE;
/* Use token-type BLOCKNAME for symbols that happen to be defined as
functions. If this is not so, then ...
Use token-type TYPENAME for symbols that happen to be defined
currently as names of types; NAME for other symbols.
The caller is not constrained to care about the distinction. */
{
std::string tmp = copy_name (m2_yylval.sval);
struct symbol *sym;
if (lookup_symtab (current_program_space, tmp.c_str ()) != nullptr)
return BLOCKNAME;
sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
SEARCH_VFT, 0).symbol;
if (sym && sym->loc_class () == LOC_BLOCK)
return BLOCKNAME;
if (lookup_typename (pstate->language (),
tmp.c_str (), pstate->expression_context_block, true)
!= nullptr)
return TYPENAME;
if(sym)
{
switch(sym->loc_class ())
{
case LOC_STATIC:
case LOC_REGISTER:
case LOC_ARG:
case LOC_REF_ARG:
case LOC_REGPARM_ADDR:
case LOC_LOCAL:
case LOC_CONST:
case LOC_CONST_BYTES:
case LOC_OPTIMIZED_OUT:
case LOC_COMPUTED:
return NAME;
case LOC_TYPEDEF:
return TYPENAME;
case LOC_BLOCK:
return BLOCKNAME;
case LOC_UNDEF:
error (_("internal: Undefined class in m2lex()"));
case LOC_LABEL:
case LOC_UNRESOLVED:
error (_("internal: Unforeseen case in m2lex()"));
default:
error (_("unhandled token in m2lex()"));
break;
}
}
else
{
/* Built-in BOOLEAN type. This is sort of a hack. */
if (startswith (tokstart, "TRUE"))
{
m2_yylval.ulval = 1;
return M2_TRUE;
}
else if (startswith (tokstart, "FALSE"))
{
m2_yylval.ulval = 0;
return M2_FALSE;
}
}
/* Must be another type of name... */
return NAME;
}
}
/* See m2-exp-parser.h. */
void
m2_yyerror (const char *msg)
{
pstate->parse_error (msg);
}
} /* namespace m2_exp_parser */
/* See m2-exp-parser.h. */
int
m2_parse (struct parser_state *par_state)
{
using namespace m2_exp_parser;
/* Setting up the parser state. */
scoped_restore pstate_restore = make_scoped_restore (&pstate);
gdb_assert (par_state != NULL);
pstate = par_state;
paren_depth = 0;
scoped_restore restore_yydebug = make_scoped_restore (&m2_yydebug,
par_state->debug);
int result = m2_yyparse ();
if (!result)
pstate->set_operation (pstate->pop ());
return result;
}