`-------------------------------------------------------------------*/
static symbol **symbols_sorted = NULL;
+static symbol **semantic_types_sorted = NULL;
/*------------------------.
| Distinguished symbols. |
/* If the tag is not a string (starts with a double quote), check
that it is valid for Yacc. */
if (tag[0] != '\"' && tag[0] != '\'' && strchr (tag, '-'))
- yacc_at (loc, _("POSIX Yacc forbids dashes in symbol names: %s"),
- tag);
+ complain_at (loc, Wyacc,
+ _("POSIX Yacc forbids dashes in symbol names: %s"), tag);
res->tag = tag;
res->location = loc;
res->status = undeclared;
if (nsyms == SYMBOL_NUMBER_MAXIMUM)
- fatal (_("too many symbols in input grammar (limit is %d)"),
- SYMBOL_NUMBER_MAXIMUM);
+ complain (fatal, _("too many symbols in input grammar (limit is %d)"),
+ SYMBOL_NUMBER_MAXIMUM);
nsyms++;
return res;
}
-/*-------------------------------------------------------.
-| Name of the code_props type: %destructor or %printer. |
-`-------------------------------------------------------*/
-
-static char const *
+char const *
code_props_type_string (code_props_type kind)
{
switch (kind)
`----------------------------------------*/
static semantic_type *
-semantic_type_new (uniqstr tag)
+semantic_type_new (uniqstr tag, const location *loc)
{
semantic_type *res = xmalloc (sizeof *res);
uniqstr_assert (tag);
res->tag = tag;
+ if (loc)
+ res->location = *loc;
for (int i = 0; i < CODE_PROPS_SIZE; ++i)
code_props_none_init (&res->props[i]);
symbol_redeclaration (symbol *s, const char *what, location first,
location second)
{
- complain_at (second, _("%s redeclaration for %s"), what, s->tag);
- complain_at (first, _("previous declaration"));
+ complain_at (second, complaint, _("%s redeclaration for %s"), what, s->tag);
+ complain_at (first, complaint, _("previous declaration"));
}
static void
semantic_type_redeclaration (semantic_type *s, const char *what, location first,
location second)
{
- complain_at (second, _("%s redeclaration for <%s>"), what, s->tag);
- complain_at (first, _("previous declaration"));
+ complain_at (second, complaint, _("%s redeclaration for <%s>"), what, s->tag);
+ complain_at (first, complaint, _("previous declaration"));
}
if (sym->type_name)
{
code_props const *code =
- &semantic_type_get (sym->type_name)->props[kind];
+ &semantic_type_get (sym->type_name, NULL)->props[kind];
if (code->code)
return code;
}
bool warned = false;
if (sym->class != unknown_sym && sym->class != class)
{
- complain_at (loc, _("symbol %s redefined"), sym->tag);
+ complain_at (loc, complaint, _("symbol %s redefined"), sym->tag);
// Don't report both "redefined" and "redeclared".
warned = true;
}
if (declaring)
{
if (sym->status == declared && !warned)
- warn_at (loc, _("symbol %s redeclared"), sym->tag);
+ complain_at (loc, Wother, _("symbol %s redeclared"), sym->tag);
sym->status = declared;
}
}
user_token_numberp = &sym->alias->user_token_number;
if (*user_token_numberp != USER_NUMBER_UNDEFINED
&& *user_token_numberp != user_token_number)
- complain_at (loc, _("redefining user token number of %s"), sym->tag);
+ complain_at (loc, complaint, _("redefining user token number of %s"),
+ sym->tag);
*user_token_numberp = user_token_number;
/* User defined $end token? */
switch (sym->status)
{
case used:
- warn_at (sym->location,
+ complain_at (sym->location, Wother,
_("symbol %s is used, but is not defined as a token"
" and has no rules"),
sym->tag);
break;
case undeclared:
case needed:
- complain_at (sym->location,
- _("symbol %s is used, but is not defined as a token"
- " and has no rules"),
- sym->tag);
+ complain_at (sym->location, complaint,
+ _("symbol %s is used, but is not defined as a token"
+ " and has no rules"),
+ sym->tag);
break;
case declared:
/* If declared, then sym->class != unknown_sym. */
sym->number = nvars++;
}
+ for (int i = 0; i < 2; ++i)
+ if (sym->props[i].kind == CODE_PROPS_NONE && sym->type_name)
+ {
+ semantic_type *sem_type = semantic_type_get (sym->type_name, NULL);
+ if (sem_type
+ && sem_type->props[i].kind != CODE_PROPS_NONE)
+ sem_type->props[i].is_used = true;
+ }
+
+ /* Set the semantic type status associated to the current symbol to
+ 'declared' so that we could check semantic types unnecessary uses. */
+ if (sym->type_name)
+ {
+ semantic_type *sem_type = semantic_type_get (sym->type_name, NULL);
+ if (sem_type)
+ sem_type->status = declared;
+ }
+
+ return true;
+}
+
+static inline bool
+semantic_type_check_defined (semantic_type *sem_type)
+{
+ if (sem_type->status == declared)
+ {
+ for (int i = 0; i < 2; ++i)
+ if (sem_type->props[i].kind != CODE_PROPS_NONE
+ && ! sem_type->props[i].is_used)
+ complain_at (sem_type->location, Wother,
+ _("useless %s for type <%s>"),
+ code_props_type_string (i), sem_type->tag);
+ }
+ else
+ complain_at (sem_type->location, Wother,
+ _("type <%s> is used, but is not associated to any symbol"),
+ sem_type->tag);
+
return true;
}
return symbol_check_defined (sym);
}
+static bool
+semantic_type_check_defined_processor (void *sem_type,
+ void *null ATTRIBUTE_UNUSED)
+{
+ return semantic_type_check_defined (sem_type);
+}
+
void
symbol_make_alias (symbol *sym, symbol *str, location loc)
{
if (str->alias)
- warn_at (loc, _("symbol %s used more than once as a literal string"),
- str->tag);
+ complain_at (loc, Wother,
+ _("symbol %s used more than once as a literal string"), str->tag);
else if (sym->alias)
- warn_at (loc, _("symbol %s given more than one literal string"),
- sym->tag);
+ complain_at (loc, Wother,
+ _("symbol %s given more than one literal string"), sym->tag);
else
{
str->class = token_sym;
first = second;
second = tmp;
}
- complain_at (second->location,
+ complain_at (second->location, complaint,
_("user token number %d redeclaration for %s"),
num, second->tag);
- complain_at (first->location, _("previous declaration for %s"),
+ complain_at (first->location, complaint, _("previous declaration for %s"),
first->tag);
}
(this->user_token_number,
symbols[token_translations[this->user_token_number]],
this);
-
+
token_translations[this->user_token_number] = this->number;
}
-
+
return true;
}
`-----------------------------------------------------------------------*/
semantic_type *
-semantic_type_from_uniqstr (const uniqstr key)
+semantic_type_from_uniqstr (const uniqstr key, const location *loc)
{
semantic_type probe;
semantic_type *entry;
if (!entry)
{
/* First insertion in the hash. */
- entry = semantic_type_new (key);
+ entry = semantic_type_new (key, loc);
if (!hash_insert (semantic_type_table, entry))
xalloc_die ();
}
`-----------------------------------------------------------------------*/
semantic_type *
-semantic_type_get (const char *key)
+semantic_type_get (const char *key, const location *loc)
{
- return semantic_type_from_uniqstr (uniqstr_new (key));
+ return semantic_type_from_uniqstr (uniqstr_new (key), loc);
}
{
symbols_do (symbol_check_defined_processor, NULL,
symbol_table, symbols_sorted);
+ symbols_do (semantic_type_check_defined_processor, NULL,
+ semantic_type_table, semantic_types_sorted);
}
/*------------------------------------------------------------------.
symbols_token_translations_init ();
if (startsymbol->class == unknown_sym)
- fatal_at (startsymbol_location,
- _("the start symbol %s is undefined"),
- startsymbol->tag);
+ complain_at (startsymbol_location, fatal,
+ _("the start symbol %s is undefined"),
+ startsymbol->tag);
else if (startsymbol->class == token_sym)
- fatal_at (startsymbol_location,
- _("the start symbol %s is a token"),
- startsymbol->tag);
+ complain_at (startsymbol_location, fatal,
+ _("the start symbol %s is a token"),
+ startsymbol->tag);
}
{
if (default_tagged_code_props[kind].code)
{
- complain_at (code->location,
+ complain_at (code->location, complaint,
_("redeclaration for default tagged %s"),
code_props_type_string (kind));
- complain_at (default_tagged_code_props[kind].location,
+ complain_at (default_tagged_code_props[kind].location, complaint,
_("previous declaration"));
}
default_tagged_code_props[kind] = *code;
{
if (default_tagless_code_props[kind].code)
{
- complain_at (code->location,
+ complain_at (code->location, complaint,
_("redeclaration for default tagless %s"),
code_props_type_string (kind));
- complain_at (default_tagless_code_props[kind].location,
+ complain_at (default_tagless_code_props[kind].location, complaint,
_("previous declaration"));
}
default_tagless_code_props[kind] = *code;
}
-
projects / bison.git / blobdiff