%{
#include "defs.h"
-#include "gdb_string.h"
+#include <string.h>
#include <ctype.h>
#include "expression.h"
#include "value.h"
%{
/* YYSTYPE gets defined by %union */
-static int parse_number (char *, int, int, YYSTYPE *);
+static int parse_number (const char *, int, int, YYSTYPE *);
static struct stoken operator_stoken (const char *);
static void check_parameter_typelist (VEC (type_ptr) *);
static void write_destructor_name (struct stoken);
{
struct type *type = $1.type;
struct stoken tmp_token;
+ char *buf;
+
CHECK_TYPEDEF (type);
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION
&& TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
error (_("`%s' is not defined as an aggregate type."),
TYPE_SAFE_NAME (type));
-
- tmp_token.ptr = (char*) alloca ($4.length + 2);
+ buf = alloca ($4.length + 2);
+ tmp_token.ptr = buf;
tmp_token.length = $4.length + 1;
- tmp_token.ptr[0] = '~';
- memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
- tmp_token.ptr[tmp_token.length] = 0;
+ buf[0] = '~';
+ memcpy (buf+1, $4.ptr, $4.length);
+ buf[tmp_token.length] = 0;
/* Check for valid destructor name. */
destructor_name_p (tmp_token.ptr, $1.type);
{
static const char *operator_string = "operator";
struct stoken st = { NULL, 0 };
+ char *buf;
+
st.length = strlen (operator_string) + strlen (op);
- st.ptr = malloc (st.length + 1);
- strcpy (st.ptr, operator_string);
- strcat (st.ptr, op);
+ buf = malloc (st.length + 1);
+ strcpy (buf, operator_string);
+ strcat (buf, op);
+ st.ptr = buf;
/* The toplevel (c_parse) will free the memory allocated here. */
- make_cleanup (free, st.ptr);
+ make_cleanup (free, buf);
return st;
};
/*** Needs some error checking for the float case ***/
static int
-parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
+parse_number (const char *buf, int len, int parsed_float, YYSTYPE *putithere)
{
/* FIXME: Shouldn't these be unsigned? We don't deal with negative values
here, and we do kind of silly things like cast to unsigned. */
ULONGEST high_bit;
struct type *signed_type;
struct type *unsigned_type;
+ char *p;
+
+ p = alloca (len);
+ memcpy (p, buf, len);
if (parsed_float)
{
character was emitted, 0 otherwise. */
int
-c_parse_escape (char **ptr, struct obstack *output)
+c_parse_escape (const char **ptr, struct obstack *output)
{
- char *tokptr = *ptr;
+ const char *tokptr = *ptr;
int result = 1;
/* Some escape sequences undergo character set conversion. Those we
CHAR, depending on what was parsed. *HOST_CHARS is set to the
number of host characters in the literal. */
static int
-parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
- int *host_chars)
+parse_string_or_char (const char *tokptr, const char **outptr,
+ struct typed_stoken *value, int *host_chars)
{
int quote;
enum c_string_type type;
we evaluate ADDRESS in the scope of the current frame, but we
evaluate CONDITION in the scope of the breakpoint's location. So
it's simply wrong to try to macro-expand the whole thing at once. */
-static char *macro_original_text;
+static const char *macro_original_text;
/* We save all intermediate macro expansions on this obstack for the
duration of a single parse. The expansion text may sometimes have
/* Read one token, getting characters through lexptr. */
static int
-lex_one_token (void)
+lex_one_token (int *is_quoted_name)
{
int c;
int namelen;
unsigned int i;
- char *tokstart;
+ const char *tokstart;
int saw_structop = last_was_structop;
char *copy;
last_was_structop = 0;
+ *is_quoted_name = 0;
retry:
{
/* It's a number. */
int got_dot = 0, got_e = 0, toktype;
- char *p = tokstart;
+ const char *p = tokstart;
int hex = input_radix > 10;
if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
case '@':
{
- char *p = &tokstart[1];
+ const char *p = &tokstart[1];
size_t len = strlen ("entry");
if (parse_language->la_language == language_objc)
{
++tokstart;
namelen = lexptr - tokstart - 1;
+ *is_quoted_name = 1;
+
goto tryname;
}
else if (host_len > 1)
characters; for comparison expressions, e.g. "a < b > c",
there must be spaces before the '<', etc. */
- char * p = find_template_name_end (tokstart + namelen);
+ const char *p = find_template_name_end (tokstart + namelen);
+
if (p)
namelen = p - tokstart;
}
&& (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
&& ! scanning_macro_expansion ())
{
- char *p = tokstart + namelen + 1;
+ const char *p = tokstart + namelen + 1;
+
while (*p == ' ' || *p == '\t')
p++;
if (*p >= '0' && *p <= '9')
/* Classify a NAME token. The contents of the token are in `yylval'.
Updates yylval and returns the new token type. BLOCK is the block
- in which lookups start; this can be NULL to mean the global
- scope. */
+ in which lookups start; this can be NULL to mean the global scope.
+ IS_QUOTED_NAME is non-zero if the name token was originally quoted
+ in single quotes. */
static int
-classify_name (const struct block *block)
+classify_name (const struct block *block, int is_quoted_name)
{
struct symbol *sym;
char *copy;
}
else if (!sym)
{
- /* See if it's a file name. */
- struct symtab *symtab;
-
- symtab = lookup_symtab (copy);
- if (symtab)
- {
- yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
- return FILENAME;
- }
-
/* If we found a field of 'this', we might have erroneously
found a constructor where we wanted a type name. Handle this
case by noticing that we found a constructor and then look up
return TYPENAME;
}
}
+
+ /* If we found a field, then we want to prefer it over a
+ filename. However, if the name was quoted, then it is better
+ to check for a filename or a block, since this is the only
+ way the user has of requiring the extension to be used. */
+ if (is_a_field_of_this.type == NULL || is_quoted_name)
+ {
+ /* See if it's a file name. */
+ struct symtab *symtab;
+
+ symtab = lookup_symtab (copy);
+ if (symtab)
+ {
+ yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab),
+ STATIC_BLOCK);
+ return FILENAME;
+ }
+ }
}
if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
char *copy;
if (context == NULL)
- return classify_name (block);
+ return classify_name (block, 0);
type = check_typedef (context);
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
struct type *context_type = NULL;
int last_to_examine, next_to_examine, checkpoint;
const struct block *search_block;
+ int is_quoted_name;
if (popping && !VEC_empty (token_and_value, token_fifo))
goto do_pop;
/* Read the first token and decide what to do. Most of the
subsequent code is C++-only; but also depends on seeing a "::" or
name-like token. */
- current.token = lex_one_token ();
+ current.token = lex_one_token (&is_quoted_name);
if (current.token == NAME)
- current.token = classify_name (expression_context_block);
+ current.token = classify_name (expression_context_block, is_quoted_name);
if (parse_language->la_language != language_cplus
|| (current.token != TYPENAME && current.token != COLONCOLON
&& current.token != FILENAME))
last_was_coloncolon = current.token == COLONCOLON;
while (1)
{
- current.token = lex_one_token ();
+ int ignore;
+
+ /* We ignore quoted names other than the very first one.
+ Subsequent ones do not have any special meaning. */
+ current.token = lex_one_token (&ignore);
current.value = yylval;
VEC_safe_push (token_and_value, token_fifo, ¤t);