case T_ANDAND: \
case T_CHARACTER_CONSTANT: \
case T_FLOATINGPOINT: \
- case T_FLOATINGPOINT_HEXADECIMAL: \
case T_INTEGER: \
- case T_INTEGER_HEXADECIMAL: \
- case T_INTEGER_OCTAL: \
case T_MINUSMINUS: \
case T_PLUSPLUS: \
case T_STRING_LITERAL: \
[EXPR_LITERAL_BOOLEAN] = sizeof(literal_expression_t),
[EXPR_LITERAL_INTEGER] = sizeof(literal_expression_t),
[EXPR_LITERAL_FLOATINGPOINT] = sizeof(literal_expression_t),
- [EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL] = sizeof(literal_expression_t),
[EXPR_LITERAL_CHARACTER] = sizeof(literal_expression_t),
[EXPR_LITERAL_WIDE_CHARACTER] = sizeof(literal_expression_t),
[EXPR_STRING_LITERAL] = sizeof(string_literal_expression_t),
if (token.kind != T_IDENTIFIER)
return NULL;
}
- symbol_t *const sym = token.identifier.symbol;
+ symbol_t *const sym = token.base.symbol;
if (pos)
*pos = *HERE;
eat(T_IDENTIFIER);
/* is it an identifier */
if (token.kind == T_IDENTIFIER
&& (look_ahead(1)->kind == ',' || look_ahead(1)->kind == ')')) {
- symbol_t *symbol = token.identifier.symbol;
argument->kind = ATTRIBUTE_ARGUMENT_SYMBOL;
- argument->v.symbol = symbol;
+ argument->v.symbol = token.base.symbol;
next_token();
} else {
/* must be an expression */
return attribute;
}
-static symbol_t *get_symbol_from_token(void)
-{
- switch(token.kind) {
- case T_CHARACTER_CONSTANT:
- case T_EOF:
- case T_FLOATINGPOINT:
- case T_FLOATINGPOINT_HEXADECIMAL:
- case T_INTEGER:
- case T_INTEGER_HEXADECIMAL:
- case T_INTEGER_OCTAL:
- case T_STRING_LITERAL:
- case T_WIDE_CHARACTER_CONSTANT:
- case T_WIDE_STRING_LITERAL:
- return NULL;
-
- default:
- return token.identifier.symbol;
- }
-}
-
static attribute_t *parse_attribute_gnu_single(void)
{
/* parse "any-word" */
- symbol_t *symbol = get_symbol_from_token();
+ symbol_t *const symbol = token.base.symbol;
if (symbol == NULL) {
parse_error_expected("while parsing attribute((", T_IDENTIFIER, NULL);
return NULL;
/* GNU-style designator ("identifier: value") */
designator = allocate_ast_zero(sizeof(designator[0]));
designator->source_position = token.base.source_position;
- designator->symbol = token.identifier.symbol;
+ designator->symbol = token.base.symbol;
eat(T_IDENTIFIER);
eat(':');
} else {
if (type == NULL) {
if (env->entity != NULL) {
- errorf(HERE,
- "extra brace group at end of initializer for '%Y'",
- env->entity->base.symbol);
+ errorf(HERE, "extra brace group at end of initializer for '%N'", env->entity);
} else {
errorf(HERE, "extra brace group at end of initializer");
}
source_position_t const* const pos = &expression->base.source_position;
if (env->entity != NULL) {
- warningf(WARN_OTHER, pos, "excess elements in initializer for '%Y'", env->entity->base.symbol);
+ warningf(WARN_OTHER, pos, "excess elements in initializer for '%N'", env->entity);
} else {
warningf(WARN_OTHER, pos, "excess elements in initializer");
}
entity_kind_tag_t const kind = is_struct ? ENTITY_STRUCT : ENTITY_UNION;
if (token.kind == T_IDENTIFIER) {
/* the compound has a name, check if we have seen it already */
- symbol = token.identifier.symbol;
+ symbol = token.base.symbol;
entity = get_tag(symbol, kind);
next_token();
eat(T_enum);
switch (token.kind) {
case T_IDENTIFIER:
- symbol = token.identifier.symbol;
+ symbol = token.base.symbol;
entity = get_tag(symbol, ENTITY_ENUM);
next_token();
switch (token.kind) {
case T_IDENTIFIER:
- if (is_typedef_symbol(token.identifier.symbol)) {
+ if (is_typedef_symbol(token.base.symbol)) {
DECLARATION_START
type = parse_typename();
} else {
if (next_if(T_restrict)) {
kind = ATTRIBUTE_MS_RESTRICT;
} else if (token.kind == T_IDENTIFIER) {
- const char *name = token.identifier.symbol->string;
+ char const *const name = token.base.symbol->string;
for (attribute_kind_t k = ATTRIBUTE_MS_FIRST; k <= ATTRIBUTE_MS_LAST;
++k) {
const char *attribute_name = get_attribute_name(k);
}
}
- type_t *const typedef_type = get_typedef_type(token.identifier.symbol);
+ type_t *const typedef_type = get_typedef_type(token.base.symbol);
if (typedef_type == NULL) {
/* Be somewhat resilient to typos like 'vodi f()' at the beginning of a
* declaration, so it doesn't generate 'implicit int' followed by more
case '*': {
errorf(HERE, "%K does not name a type", &token);
- symbol_t *symbol = token.identifier.symbol;
- entity_t *entity
- = create_error_entity(symbol, ENTITY_TYPEDEF);
+ entity_t *const entity = create_error_entity(token.base.symbol, ENTITY_TYPEDEF);
type = allocate_type_zero(TYPE_TYPEDEF);
type->typedeft.typedefe = &entity->typedefe;
{
assert(token.kind == T_IDENTIFIER);
do {
- entity_t *const entity = allocate_entity_zero(ENTITY_PARAMETER, NAMESPACE_NORMAL, token.identifier.symbol, HERE);
+ entity_t *const entity = allocate_entity_zero(ENTITY_PARAMETER, NAMESPACE_NORMAL, token.base.symbol, HERE);
/* a K&R parameter has no type, yet */
next_token();
if (look_ahead(1)->kind != ')')
return true;
if (token.kind == T_IDENTIFIER) {
- entity_t const *const entity
- = get_entity(token.identifier.symbol, NAMESPACE_NORMAL);
+ entity_t const *const entity = get_entity(token.base.symbol, NAMESPACE_NORMAL);
if (entity == NULL)
return true;
if (entity->kind != ENTITY_TYPEDEF)
eat('(');
add_anchor_token(')');
- if (token.kind == T_IDENTIFIER &&
- !is_typedef_symbol(token.identifier.symbol) &&
+ if (token.kind == T_IDENTIFIER &&
+ !is_typedef_symbol(token.base.symbol) &&
(look_ahead(1)->kind == ',' || look_ahead(1)->kind == ')')) {
type->kr_style_parameters = true;
parse_identifier_list(scope);
if (env->must_be_abstract) {
errorf(HERE, "no identifier expected in typename");
} else {
- env->symbol = token.identifier.symbol;
+ env->symbol = token.base.symbol;
env->source_position = token.base.source_position;
}
next_token();
token_t const *const la1 = look_ahead(1);
switch (la1->kind) {
case T_IDENTIFIER:
- if (is_typedef_symbol(la1->identifier.symbol)) {
+ if (is_typedef_symbol(la1->base.symbol)) {
case ')':
/* ยง6.7.6:2 footnote 126: Empty parentheses in a type name are
* interpreted as ``function with no parameter specification'', rather
if (env.symbol != NULL) {
if (specifiers->is_inline && is_type_valid(type)) {
- errorf(&env.source_position,
- "compound member '%Y' declared 'inline'", env.symbol);
+ errorf(&env.source_position, "'%N' declared 'inline'", entity);
}
if (specifiers->thread_local ||
specifiers->storage_class != STORAGE_CLASS_NONE) {
- errorf(&env.source_position,
- "compound member '%Y' must have no storage class",
- env.symbol);
+ errorf(&env.source_position, "'%N' must have no storage class", entity);
}
}
} else if (flags & DECL_IS_PARAMETER) {
}
}
if (invalid_storage_class) {
- errorf(&env.source_position, "invalid storage class for variable '%N'", entity);
+ errorf(&env.source_position, "invalid storage class for '%N'", entity);
}
}
}
} else if (!is_definition &&
is_type_valid(prev_type) &&
!pos->is_system_header) {
- warningf(WARN_REDUNDANT_DECLS, pos, "redundant declaration for '%Y' (declared %P)", symbol, ppos);
+ warningf(WARN_REDUNDANT_DECLS, pos, "redundant declaration for '%N' (declared %P)", entity, ppos);
}
} else if (current_function == NULL) {
if (old_storage_class != STORAGE_CLASS_STATIC &&
new_storage_class == STORAGE_CLASS_STATIC) {
- errorf(pos, "static declaration of '%Y' follows non-static declaration (declared %P)", symbol, ppos);
+ errorf(pos, "static declaration of '%N' follows non-static declaration (declared %P)", entity, ppos);
} else if (old_storage_class == STORAGE_CLASS_EXTERN) {
prev_decl->storage_class = STORAGE_CLASS_NONE;
prev_decl->declared_storage_class = STORAGE_CLASS_NONE;
} else if (is_type_valid(prev_type)) {
if (old_storage_class == new_storage_class) {
error_redeclaration:
- errorf(pos, "redeclaration of '%Y' (declared %P)", symbol, ppos);
+ errorf(pos, "redeclaration of '%N' (declared %P)", entity, ppos);
} else {
- errorf(pos, "redeclaration of '%Y' with different linkage (declared %P)", symbol, ppos);
+ errorf(pos, "redeclaration of '%N' with different linkage (declared %P)", entity, ppos);
}
}
}
static void parser_error_multiple_definition(entity_t *entity,
const source_position_t *source_position)
{
- errorf(source_position, "multiple definition of '%Y' (declared %P)",
- entity->base.symbol, &entity->base.source_position);
+ errorf(source_position, "redefinition of '%N' (declared %P)", entity, &entity->base.source_position);
}
static bool is_declaration_specifier(const token_t *token)
DECLARATION_START
return true;
case T_IDENTIFIER:
- return is_typedef_symbol(token->identifier.symbol);
+ return is_typedef_symbol(token->base.symbol);
default:
return false;
entity_t *prev = find_compound_entry(compound, symbol);
if (prev != NULL) {
source_position_t const *const ppos = &prev->base.source_position;
- errorf(pos, "multiple declarations of symbol '%Y' (declared %P)", symbol, ppos);
+ errorf(pos, "multiple declarations of '%N' (declared %P)", entity, ppos);
}
}
switch (token.kind) {
case T_INTEGER:
- case T_INTEGER_OCTAL:
- case T_INTEGER_HEXADECIMAL:
kind = EXPR_LITERAL_INTEGER;
check_integer_suffix();
type = type_int;
kind = EXPR_LITERAL_FLOATINGPOINT;
type = check_floatingpoint_suffix();
break;
- case T_FLOATINGPOINT_HEXADECIMAL:
- kind = EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL;
- type = check_floatingpoint_suffix();
- break;
+
default:
panic("unexpected token type in parse_number_literal");
}
if (entity == NULL) {
if (!strict_mode && token.kind == '(') {
/* an implicitly declared function */
- warningf(WARN_IMPLICIT_FUNCTION_DECLARATION, &pos,
- "implicit declaration of function '%Y'", symbol);
entity = create_implicit_function(symbol, &pos);
+ warningf(WARN_IMPLICIT_FUNCTION_DECLARATION, &pos, "implicit declaration of '%N'", entity);
} else {
errorf(&pos, "unknown identifier '%Y' found.", symbol);
entity = create_error_entity(symbol, ENTITY_VARIABLE);
return parse_statement_expression();
case T_IDENTIFIER:
- if (is_typedef_symbol(la1->identifier.symbol)) {
+ if (is_typedef_symbol(la1->base.symbol)) {
DECLARATION_START
return parse_cast();
}
assert(token.kind == T_IDENTIFIER);
assert(current_function != NULL);
- entity_t *label = get_entity(token.identifier.symbol, NAMESPACE_LABEL);
+ entity_t *label = get_entity(token.base.symbol, NAMESPACE_LABEL);
/* If we find a local label, we already created the declaration. */
if (label != NULL && label->kind == ENTITY_LOCAL_LABEL) {
if (label->base.parent_scope != current_scope) {
} else if (label == NULL || label->base.parent_scope != ¤t_function->parameters) {
/* There is no matching label in the same function, so create a new one. */
source_position_t const nowhere = { NULL, 0, 0, false };
- label = allocate_entity_zero(ENTITY_LABEL, NAMESPACE_LABEL, token.identifier.symbol, &nowhere);
+ label = allocate_entity_zero(ENTITY_LABEL, NAMESPACE_LABEL, token.base.symbol, &nowhere);
label_push(label);
}
case T_false: return parse_boolean_literal(false);
case T_true: return parse_boolean_literal(true);
case T_INTEGER:
- case T_INTEGER_OCTAL:
- case T_INTEGER_HEXADECIMAL:
- case T_FLOATINGPOINT:
- case T_FLOATINGPOINT_HEXADECIMAL: return parse_number_literal();
+ case T_FLOATINGPOINT: return parse_number_literal();
case T_CHARACTER_CONSTANT: return parse_character_constant();
case T_WIDE_CHARACTER_CONSTANT: return parse_wide_character_constant();
case T_STRING_LITERAL:
case T_COLONCOLON:
return parse_reference();
case T_IDENTIFIER:
- if (!is_typedef_symbol(token.identifier.symbol)) {
+ if (!is_typedef_symbol(token.base.symbol)) {
return parse_reference();
}
/* FALLTHROUGH */
case EXPR_LITERAL_WIDE_CHARACTER:
case EXPR_LITERAL_INTEGER:
case EXPR_LITERAL_FLOATINGPOINT:
- case EXPR_LITERAL_FLOATINGPOINT_HEXADECIMAL: return false;
case EXPR_STRING_LITERAL: return false;
case EXPR_WIDE_STRING_LITERAL: return false;
symbol_t *symbol = NULL;
if (token.kind == T_IDENTIFIER) {
- symbol = token.identifier.symbol;
+ symbol = token.base.symbol;
next_token();
entity = get_entity(symbol, NAMESPACE_NORMAL);
token_kind_t la1_type = (token_kind_t)look_ahead(1)->kind;
if (la1_type == ':') {
statement = parse_label_statement();
- } else if (is_typedef_symbol(token.identifier.symbol)) {
+ } else if (is_typedef_symbol(token.base.symbol)) {
statement = parse_declaration_statement();
} else {
/* it's an identifier, the grammar says this must be an
switch (la1_type) {
case '&':
case '*':
- if (get_entity(token.identifier.symbol, NAMESPACE_NORMAL) != NULL) {
+ if (get_entity(token.base.symbol, NAMESPACE_NORMAL) != NULL) {
default:
statement = parse_expression_statement();
} else {