bool invalid;
bool have_arguments;
union {
- size_t value;
- string_t string;
+ size_t value;
+ string_t string;
+ atomic_type_kind_t akind;
} u;
};
unsigned char alignment; /**< Alignment, 0 if not set. */
unsigned int is_inline : 1;
unsigned int deprecated : 1;
- decl_modifiers_t decl_modifiers; /**< MS __declspec extended modifier mask */
+ decl_modifiers_t modifiers; /**< declaration modifiers */
gnu_attribute_t *gnu_attributes; /**< list of GNU attributes */
const char *deprecated_string; /**< can be set if declaration was marked deprecated. */
symbol_t *get_property_sym; /**< the name of the get property if set. */
static declaration_t *current_function = NULL;
static switch_statement_t *current_switch = NULL;
static statement_t *current_loop = NULL;
+static ms_try_statement_t *current_try = NULL;
static goto_statement_t *goto_first = NULL;
static goto_statement_t *goto_last = NULL;
static label_statement_t *label_first = NULL;
static label_statement_t *label_last = NULL;
+static translation_unit_t *unit = NULL;
static struct obstack temp_obst;
static source_position_t null_position = { NULL, 0 };
static unsigned char token_anchor_set[T_LAST_TOKEN];
/** The current source position. */
-#define HERE &token.source_position
+#define HERE (&token.source_position)
static type_t *type_valist;
-static statement_t *parse_compound_statement(void);
+static statement_t *parse_compound_statement(bool inside_expression_statement);
static statement_t *parse_statement(void);
static expression_t *parse_sub_expression(unsigned precedence);
case T_restrict: \
case T_volatile: \
case T_inline: \
- case T__forceinline:
+ case T__forceinline: \
+ case T___attribute__:
#ifdef PROVIDE_COMPLEX
#define COMPLEX_SPECIFIERS \
[STATEMENT_WHILE] = sizeof(while_statement_t),
[STATEMENT_DO_WHILE] = sizeof(do_while_statement_t),
[STATEMENT_FOR] = sizeof(for_statement_t),
- [STATEMENT_ASM] = sizeof(asm_statement_t)
+ [STATEMENT_ASM] = sizeof(asm_statement_t),
+ [STATEMENT_MS_TRY] = sizeof(ms_try_statement_t),
+ [STATEMENT_LEAVE] = sizeof(leave_statement_t)
};
assert(kind <= sizeof(sizes) / sizeof(sizes[0]));
assert(sizes[kind] != 0);
[EXPR_VA_ARG] = sizeof(va_arg_expression_t),
[EXPR_STATEMENT] = sizeof(statement_expression_t),
};
- if(kind >= EXPR_UNARY_FIRST && kind <= EXPR_UNARY_LAST) {
+ if (kind >= EXPR_UNARY_FIRST && kind <= EXPR_UNARY_LAST) {
return sizes[EXPR_UNARY_FIRST];
}
- if(kind >= EXPR_BINARY_FIRST && kind <= EXPR_BINARY_LAST) {
+ if (kind >= EXPR_BINARY_FIRST && kind <= EXPR_BINARY_LAST) {
return sizes[EXPR_BINARY_FIRST];
}
assert(kind <= sizeof(sizes) / sizeof(sizes[0]));
{
static const size_t sizes[] = {
[TYPE_ATOMIC] = sizeof(atomic_type_t),
+ [TYPE_COMPLEX] = sizeof(complex_type_t),
+ [TYPE_IMAGINARY] = sizeof(imaginary_type_t),
[TYPE_BITFIELD] = sizeof(bitfield_type_t),
[TYPE_COMPOUND_STRUCT] = sizeof(compound_type_t),
[TYPE_COMPOUND_UNION] = sizeof(compound_type_t),
++token_anchor_set[token_type];
}
+static int save_and_reset_anchor_state(int token_type) {
+ assert(0 <= token_type && token_type < T_LAST_TOKEN);
+ int count = token_anchor_set[token_type];
+ token_anchor_set[token_type] = 0;
+ return count;
+}
+
+static void restore_anchor_state(int token_type, int count) {
+ assert(0 <= token_type && token_type < T_LAST_TOKEN);
+ token_anchor_set[token_type] = count;
+}
+
/**
* Remove a token from the token anchor set (a multi-set).
*/
}
static bool at_anchor(void) {
- if(token.type < 0)
+ if (token.type < 0)
return false;
return token_anchor_set[token.type];
}
unsigned parenthesis_count = 0;
unsigned brace_count = 0;
unsigned bracket_count = 0;
- int end_token = type;
- if(type == '(')
- end_token = ')';
- else if(type == '{')
- end_token = '}';
- else if(type == '[')
- end_token = ']';
+ int end_token;
+ switch (type) {
+ case '(': end_token = ')'; break;
+ case '{': end_token = '}'; break;
+ case '[': end_token = ']'; break;
+ default: end_token = type; break;
+ }
while(token.type != end_token ||
(parenthesis_count > 0 || brace_count > 0 || bracket_count > 0)) {
case '{': ++brace_count; break;
case '[': ++bracket_count; break;
case ')':
- if(parenthesis_count > 0)
+ if (parenthesis_count > 0)
--parenthesis_count;
break;
case '}':
- if(brace_count > 0)
+ if (brace_count > 0)
--brace_count;
break;
case ']':
- if(bracket_count > 0)
+ if (bracket_count > 0)
--bracket_count;
break;
default:
* Eat input tokens until an anchor is found.
*/
static void eat_until_anchor(void) {
- if(token.type == T_EOF)
+ if (token.type == T_EOF)
return;
while(token_anchor_set[token.type] == 0) {
- if(token.type == '(' || token.type == '{' || token.type == '[')
+ if (token.type == '(' || token.type == '{' || token.type == '[')
eat_until_matching_token(token.type);
- if(token.type == T_EOF)
+ if (token.type == T_EOF)
break;
next_token();
}
static void eat_block(void) {
eat_until_matching_token('{');
- if(token.type == '}')
+ if (token.type == '}')
next_token();
}
/**
- * eat all token until a ';' is reached
- * or a stop token is found.
+ * eat all token until a ';' is reached or a stop token is found.
*/
static void eat_statement(void) {
eat_until_matching_token(';');
- if(token.type == ';')
+ if (token.type == ';')
next_token();
}
/**
* Report a parse error because an expected token was not found.
*/
-static void parse_error_expected(const char *message, ...)
+static
+#if defined __GNUC__ && __GNUC__ >= 4
+__attribute__((sentinel))
+#endif
+void parse_error_expected(const char *message, ...)
{
- if(message != NULL) {
+ if (message != NULL) {
errorf(HERE, "%s", message);
}
va_list ap;
va_start(ap, message);
- errorf(HERE, "got %K, expected %#k", &token, &ap, "a ");
+ errorf(HERE, "got %K, expected %#k", &token, &ap, ", ");
va_end(ap);
}
static void type_error_incompatible(const char *msg,
const source_position_t *source_position, type_t *type1, type_t *type2)
{
- errorf(source_position, "%s, incompatible types: '%T' - '%T'", msg, type1, type2);
+ errorf(source_position, "%s, incompatible types: '%T' - '%T'",
+ msg, type1, type2);
}
/**
* If not, generate an error, eat the current statement,
* and goto the end_error label.
*/
-#define expect(expected) \
- do { \
- if(UNLIKELY(token.type != (expected))) { \
- parse_error_expected(NULL, (expected), 0); \
- add_anchor_token(expected); \
- eat_until_anchor(); \
- rem_anchor_token(expected); \
- goto end_error; \
- } \
- next_token(); \
+#define expect(expected) \
+ do { \
+ if (UNLIKELY(token.type != (expected))) { \
+ parse_error_expected(NULL, (expected), NULL); \
+ add_anchor_token(expected); \
+ eat_until_anchor(); \
+ if (token.type == expected) \
+ next_token(); \
+ rem_anchor_token(expected); \
+ goto end_error; \
+ } \
+ next_token(); \
} while(0)
static void set_scope(scope_t *new_scope)
{
- if(scope != NULL) {
+ if (scope != NULL) {
scope->last_declaration = last_declaration;
}
scope = new_scope;
{
declaration_t *declaration = symbol->declaration;
for( ; declaration != NULL; declaration = declaration->symbol_next) {
- if(declaration->namespc == namespc)
+ if (declaration->namespc == namespc)
return declaration;
}
declaration_t *iter_last = NULL;
for( ; iter != NULL; iter_last = iter, iter = iter->symbol_next) {
/* replace an entry? */
- if(iter->namespc == namespc) {
- if(iter_last == NULL) {
+ if (iter->namespc == namespc) {
+ if (iter_last == NULL) {
symbol->declaration = declaration;
} else {
iter_last->symbol_next = declaration;
break;
}
}
- if(iter == NULL) {
+ if (iter == NULL) {
assert(iter_last->symbol_next == NULL);
iter_last->symbol_next = declaration;
}
size_t i;
assert(new_top <= top);
- if(new_top == top)
+ if (new_top == top)
return;
for(i = top; i > new_top; --i) {
/* replace/remove declaration */
declaration_t *declaration = symbol->declaration;
assert(declaration != NULL);
- if(declaration->namespc == namespc) {
- if(old_declaration == NULL) {
+ if (declaration->namespc == namespc) {
+ if (old_declaration == NULL) {
symbol->declaration = declaration->symbol_next;
} else {
symbol->declaration = old_declaration;
declaration_t *iter = declaration->symbol_next;
for( ; iter != NULL; iter_last = iter, iter = iter->symbol_next) {
/* replace an entry? */
- if(iter->namespc == namespc) {
+ if (iter->namespc == namespc) {
assert(iter_last != NULL);
iter_last->symbol_next = old_declaration;
- if(old_declaration != NULL) {
+ if (old_declaration != NULL) {
old_declaration->symbol_next = iter->symbol_next;
}
break;
static int get_rank(const type_t *type)
{
assert(!is_typeref(type));
- /* The C-standard allows promoting to int or unsigned int (see § 7.2.2
+ /* The C-standard allows promoting enums to int or unsigned int (see § 7.2.2
* and esp. footnote 108). However we can't fold constants (yet), so we
* can't decide whether unsigned int is possible, while int always works.
* (unsigned int would be preferable when possible... for stuff like
* struct { enum { ... } bla : 4; } ) */
- if(type->kind == TYPE_ENUM)
+ if (type->kind == TYPE_ENUM)
return ATOMIC_TYPE_INT;
assert(type->kind == TYPE_ATOMIC);
static type_t *promote_integer(type_t *type)
{
- if(type->kind == TYPE_BITFIELD)
- type = type->bitfield.base;
+ if (type->kind == TYPE_BITFIELD)
+ type = type->bitfield.base_type;
- if(get_rank(type) < ATOMIC_TYPE_INT)
+ if (get_rank(type) < ATOMIC_TYPE_INT)
type = type_int;
return type;
static bool is_null_pointer_constant(const expression_t *expression)
{
/* skip void* cast */
- if(expression->kind == EXPR_UNARY_CAST
+ if (expression->kind == EXPR_UNARY_CAST
|| expression->kind == EXPR_UNARY_CAST_IMPLICIT) {
expression = expression->unary.value;
}
return create_cast_expression(expression, dest_type);
}
+typedef enum assign_error_t {
+ ASSIGN_SUCCESS,
+ ASSIGN_ERROR_INCOMPATIBLE,
+ ASSIGN_ERROR_POINTER_QUALIFIER_MISSING,
+ ASSIGN_WARNING_POINTER_INCOMPATIBLE,
+ ASSIGN_WARNING_POINTER_FROM_INT,
+ ASSIGN_WARNING_INT_FROM_POINTER
+} assign_error_t;
+
+static void report_assign_error(assign_error_t error, type_t *orig_type_left,
+ const expression_t *const right,
+ const char *context,
+ const source_position_t *source_position)
+{
+ type_t *const orig_type_right = right->base.type;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
+
+ switch (error) {
+ case ASSIGN_SUCCESS:
+ return;
+ case ASSIGN_ERROR_INCOMPATIBLE:
+ errorf(source_position,
+ "destination type '%T' in %s is incompatible with type '%T'",
+ orig_type_left, context, orig_type_right);
+ return;
+
+ case ASSIGN_ERROR_POINTER_QUALIFIER_MISSING: {
+ type_t *points_to_left
+ = skip_typeref(type_left->pointer.points_to);
+ type_t *points_to_right
+ = skip_typeref(type_right->pointer.points_to);
+
+ /* the left type has all qualifiers from the right type */
+ unsigned missing_qualifiers
+ = points_to_right->base.qualifiers & ~points_to_left->base.qualifiers;
+ errorf(source_position,
+ "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointed-to type",
+ orig_type_left, context, orig_type_right, missing_qualifiers);
+ return;
+ }
+
+ case ASSIGN_WARNING_POINTER_INCOMPATIBLE:
+ warningf(source_position,
+ "destination type '%T' in %s is incompatible with '%E' of type '%T'",
+ orig_type_left, context, right, orig_type_right);
+ return;
+
+ case ASSIGN_WARNING_POINTER_FROM_INT:
+ warningf(source_position,
+ "%s makes integer '%T' from pointer '%T' without a cast",
+ context, orig_type_left, orig_type_right);
+ return;
+
+ case ASSIGN_WARNING_INT_FROM_POINTER:
+ warningf(source_position,
+ "%s makes integer '%T' from pointer '%T' without a cast",
+ context, orig_type_left, orig_type_right);
+ return;
+
+ default:
+ panic("invalid error value");
+ }
+}
+
/** Implements the rules from § 6.5.16.1 */
-static type_t *semantic_assign(type_t *orig_type_left,
- const expression_t *const right,
- const char *context,
- const source_position_t *source_position)
+static assign_error_t semantic_assign(type_t *orig_type_left,
+ const expression_t *const right)
{
type_t *const orig_type_right = right->base.type;
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_right = skip_typeref(orig_type_right);
- if(is_type_pointer(type_left)) {
- if(is_null_pointer_constant(right)) {
- return orig_type_left;
- } else if(is_type_pointer(type_right)) {
+ if (is_type_pointer(type_left)) {
+ if (is_null_pointer_constant(right)) {
+ return ASSIGN_SUCCESS;
+ } else if (is_type_pointer(type_right)) {
type_t *points_to_left
= skip_typeref(type_left->pointer.points_to);
type_t *points_to_right
/* the left type has all qualifiers from the right type */
unsigned missing_qualifiers
= points_to_right->base.qualifiers & ~points_to_left->base.qualifiers;
- if(missing_qualifiers != 0) {
- errorf(source_position,
- "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointed-to type", type_left, context, type_right, missing_qualifiers);
- return orig_type_left;
+ if (missing_qualifiers != 0) {
+ return ASSIGN_ERROR_POINTER_QUALIFIER_MISSING;
}
points_to_left = get_unqualified_type(points_to_left);
if (is_type_atomic(points_to_left, ATOMIC_TYPE_VOID) ||
is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)) {
- return orig_type_left;
+ return ASSIGN_SUCCESS;
}
if (!types_compatible(points_to_left, points_to_right)) {
- warningf(source_position,
- "destination type '%T' in %s is incompatible with '%E' of type '%T'",
- orig_type_left, context, right, orig_type_right);
+ return ASSIGN_WARNING_POINTER_INCOMPATIBLE;
}
- return orig_type_left;
- } else if(is_type_integer(type_right)) {
- warningf(source_position,
- "%s makes pointer '%T' from integer '%T' without a cast",
- context, orig_type_left, orig_type_right);
- return orig_type_left;
+ return ASSIGN_SUCCESS;
+ } else if (is_type_integer(type_right)) {
+ return ASSIGN_WARNING_POINTER_FROM_INT;
}
} else if ((is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) ||
(is_type_atomic(type_left, ATOMIC_TYPE_BOOL)
&& is_type_pointer(type_right))) {
- return orig_type_left;
+ return ASSIGN_SUCCESS;
} else if ((is_type_compound(type_left) && is_type_compound(type_right))
|| (is_type_builtin(type_left) && is_type_builtin(type_right))) {
type_t *const unqual_type_left = get_unqualified_type(type_left);
type_t *const unqual_type_right = get_unqualified_type(type_right);
if (types_compatible(unqual_type_left, unqual_type_right)) {
- return orig_type_left;
+ return ASSIGN_SUCCESS;
}
} else if (is_type_integer(type_left) && is_type_pointer(type_right)) {
- warningf(source_position,
- "%s makes integer '%T' from pointer '%T' without a cast",
- context, orig_type_left, orig_type_right);
- return orig_type_left;
+ return ASSIGN_WARNING_INT_FROM_POINTER;
}
- if (!is_type_valid(type_left))
- return type_left;
-
- if (!is_type_valid(type_right))
- return orig_type_right;
+ if (!is_type_valid(type_left) || !is_type_valid(type_right))
+ return ASSIGN_SUCCESS;
- return NULL;
+ return ASSIGN_ERROR_INCOMPATIBLE;
}
static expression_t *parse_constant_expression(void)
/* start parsing at precedence 7 (conditional expression) */
expression_t *result = parse_sub_expression(7);
- if(!is_constant_expression(result)) {
- errorf(&result->base.source_position, "expression '%E' is not constant\n", result);
+ if (!is_constant_expression(result)) {
+ errorf(&result->base.source_position,
+ "expression '%E' is not constant\n", result);
}
return result;
[GNU_AK_DESTRUCTOR] = "destructor",
[GNU_AK_NOTHROW] = "nothrow",
[GNU_AK_TRANSPARENT_UNION] = "transparent_union",
- [GNU_AK_COMMON] = "coommon",
+ [GNU_AK_COMMON] = "common",
[GNU_AK_NOCOMMON] = "nocommon",
[GNU_AK_PACKED] = "packed",
[GNU_AK_SHARED] = "shared",
[GNU_AK_TLS_MODEL] = "tls_model",
[GNU_AK_VISIBILITY] = "visibility",
[GNU_AK_REGPARM] = "regparm",
+ [GNU_AK_MODE] = "mode",
[GNU_AK_MODEL] = "model",
[GNU_AK_TRAP_EXIT] = "trap_exit",
[GNU_AK_SP_SWITCH] = "sp_switch",
* compare two string, ignoring double underscores on the second.
*/
static int strcmp_underscore(const char *s1, const char *s2) {
- if(s2[0] == '_' && s2[1] == '_') {
- s2 += 2;
- size_t l1 = strlen(s1);
- if(l1 + 2 != strlen(s2)) {
- /* not equal */
- return 1;
+ if (s2[0] == '_' && s2[1] == '_') {
+ size_t len2 = strlen(s2);
+ size_t len1 = strlen(s1);
+ if (len1 == len2-4 && s2[len2-2] == '_' && s2[len2-1] == '_') {
+ return strncmp(s1, s2+2, len2-4);
}
- return strncmp(s1, s2, l1);
}
+
return strcmp(s1, s2);
}
*/
static gnu_attribute_t *allocate_gnu_attribute(gnu_attribute_kind_t kind) {
gnu_attribute_t *attribute = obstack_alloc(&temp_obst, sizeof(*attribute));
- attribute->kind = kind;
- attribute->next = NULL;
- attribute->invalid = false;
- attribute->have_arguments = false;
+ attribute->kind = kind;
+ attribute->next = NULL;
+ attribute->invalid = false;
+ attribute->have_arguments = false;
+
+ return attribute;
}
/**
add_anchor_token(',');
while(true){
expression = parse_constant_expression();
- if(token.type != ',')
+ if (token.type != ',')
break;
next_token();
}
/**
* parse one string literal argument.
*/
-static void parse_gnu_attribute_string_arg(gnu_attribute_t *attribute, string_t *string) {
+static void parse_gnu_attribute_string_arg(gnu_attribute_t *attribute,
+ string_t *string)
+{
add_anchor_token('(');
- if(token.type != T_STRING_LITERAL) {
- parse_error_expected("while parsing attribute directive", T_STRING_LITERAL);
+ if (token.type != T_STRING_LITERAL) {
+ parse_error_expected("while parsing attribute directive",
+ T_STRING_LITERAL, NULL);
goto end_error;
}
*string = parse_string_literals();
};
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
- if(string.begin != NULL) {
+ if (string.begin != NULL) {
for(size_t i = 0; i < 4; ++i) {
- if(strcmp(tls_models[i], string.begin) == 0) {
+ if (strcmp(tls_models[i], string.begin) == 0) {
attribute->u.value = i;
return;
}
}
+ errorf(HERE, "'%s' is an unrecognized tls model", string.begin);
}
- errorf(HERE, "'%s' is an unrecognized tls model", string.begin);
attribute->invalid = true;
}
};
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
- if(string.begin != NULL) {
+ if (string.begin != NULL) {
for(size_t i = 0; i < 4; ++i) {
- if(strcmp(visibilities[i], string.begin) == 0) {
+ if (strcmp(visibilities[i], string.begin) == 0) {
attribute->u.value = i;
return;
}
}
+ errorf(HERE, "'%s' is an unrecognized visibility", string.begin);
}
- errorf(HERE, "'%s' is an unrecognized visibility", string.begin);
attribute->invalid = true;
}
};
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
- if(string.begin != NULL) {
+ if (string.begin != NULL) {
for(int i = 0; i < 3; ++i) {
- if(strcmp(visibilities[i], string.begin) == 0) {
+ if (strcmp(visibilities[i], string.begin) == 0) {
attribute->u.value = i;
return;
}
}
+ errorf(HERE, "'%s' is an unrecognized model", string.begin);
+ }
+ attribute->invalid = true;
+}
+
+static void parse_gnu_attribute_mode_arg(gnu_attribute_t *attribute)
+{
+ /* TODO: find out what is allowed here... */
+
+ /* at least: byte, word, pointer, list of machine modes
+ * __XXX___ is interpreted as XXX */
+ add_anchor_token(')');
+
+ if (token.type != T_IDENTIFIER) {
+ expect(T_IDENTIFIER);
+ }
+
+ /* This isn't really correct, the backend should provide a list of machine
+ * specific modes (according to gcc philosophy that is...) */
+ const char *symbol_str = token.v.symbol->string;
+ if (strcmp_underscore("QI", symbol_str) == 0 ||
+ strcmp_underscore("byte", symbol_str) == 0) {
+ attribute->u.akind = ATOMIC_TYPE_CHAR;
+ } else if (strcmp_underscore("HI", symbol_str) == 0) {
+ attribute->u.akind = ATOMIC_TYPE_SHORT;
+ } else if (strcmp_underscore("SI", symbol_str) == 0
+ || strcmp_underscore("word", symbol_str) == 0
+ || strcmp_underscore("pointer", symbol_str) == 0) {
+ attribute->u.akind = ATOMIC_TYPE_INT;
+ } else if (strcmp_underscore("DI", symbol_str) == 0) {
+ attribute->u.akind = ATOMIC_TYPE_LONGLONG;
+ } else {
+ warningf(HERE, "ignoring unknown mode '%s'", symbol_str);
+ attribute->invalid = true;
}
- errorf(HERE, "'%s' is an unrecognized model", string.begin);
+ next_token();
+
+ rem_anchor_token(')');
+ expect(')');
+ return;
+end_error:
attribute->invalid = true;
}
};
string_t string = { NULL, 0 };
parse_gnu_attribute_string_arg(attribute, &string);
- if(string.begin != NULL) {
+ if (string.begin != NULL) {
for(size_t i = 0; i < 5; ++i) {
- if(strcmp(interrupts[i], string.begin) == 0) {
+ if (strcmp(interrupts[i], string.begin) == 0) {
attribute->u.value = i;
return;
}
}
+ errorf(HERE, "'%s' is not an interrupt", string.begin);
}
- errorf(HERE, "'%s' is an interrupt", string.begin);
attribute->invalid = true;
}
};
int i;
- if(token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing format attribute directive", T_IDENTIFIER);
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing format attribute directive", T_IDENTIFIER, NULL);
goto end_error;
}
const char *name = token.v.symbol->string;
for(i = 0; i < 4; ++i) {
- if(strcmp_underscore(format_names[i], name) == 0)
+ if (strcmp_underscore(format_names[i], name) == 0)
break;
}
- if(i >= 4) {
- if(warning.attribute)
+ if (i >= 4) {
+ if (warning.attribute)
warningf(HERE, "'%s' is an unrecognized format function type", name);
}
next_token();
attribute->u.value = true;
}
+static void check_no_argument(gnu_attribute_t *attribute, const char *name)
+{
+ if (!attribute->have_arguments)
+ return;
+
+ /* should have no arguments */
+ errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
+ eat_until_matching_token('(');
+ /* we have already consumed '(', so we stop before ')', eat it */
+ eat(')');
+ attribute->invalid = true;
+}
+
/**
* Parse one GNU attribute.
*
* interrupt( string literal )
* sentinel( constant expression )
*/
-static void parse_gnu_attribute(gnu_attribute_t **attributes)
+static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes)
{
- gnu_attribute_t *head = *attributes;
- gnu_attribute_t *last = *attributes;
+ gnu_attribute_t *head = *attributes;
+ gnu_attribute_t *last = *attributes;
+ decl_modifiers_t modifiers = 0;
gnu_attribute_t *attribute;
eat(T___attribute__);
expect('(');
expect('(');
- if(token.type != ')') {
+ if (token.type != ')') {
/* find the end of the list */
- if(last != NULL) {
+ if (last != NULL) {
while(last->next != NULL)
last = last->next;
}
/* non-empty attribute list */
while(true) {
const char *name;
- if(token.type == T_const) {
+ if (token.type == T_const) {
name = "const";
- } else if(token.type == T_volatile) {
+ } else if (token.type == T_volatile) {
name = "volatile";
- } else if(token.type == T_cdecl) {
+ } else if (token.type == T_cdecl) {
/* __attribute__((cdecl)), WITH ms mode */
name = "cdecl";
- } else if(token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing GNU attribute", T_IDENTIFIER);
+ } else if (token.type == T_IDENTIFIER) {
+ const symbol_t *sym = token.v.symbol;
+ name = sym->string;
+ } else {
+ parse_error_expected("while parsing GNU attribute", T_IDENTIFIER, NULL);
break;
}
- const symbol_t *sym = token.v.symbol;
- name = sym->string;
+
next_token();
int i;
for(i = 0; i < GNU_AK_LAST; ++i) {
- if(strcmp_underscore(gnu_attribute_names[i], name) == 0)
+ if (strcmp_underscore(gnu_attribute_names[i], name) == 0)
break;
}
gnu_attribute_kind_t kind = (gnu_attribute_kind_t)i;
attribute = NULL;
- if(kind == GNU_AK_LAST) {
- if(warning.attribute)
+ if (kind == GNU_AK_LAST) {
+ if (warning.attribute)
warningf(HERE, "'%s' attribute directive ignored", name);
/* skip possible arguments */
- if(token.type == '(') {
+ if (token.type == '(') {
eat_until_matching_token(')');
}
} else {
/* check for arguments */
attribute = allocate_gnu_attribute(kind);
- if(token.type == '(') {
+ if (token.type == '(') {
next_token();
- if(token.type == ')') {
+ if (token.type == ')') {
/* empty args are allowed */
next_token();
} else
switch(kind) {
case GNU_AK_CONST:
case GNU_AK_VOLATILE:
- case GNU_AK_CDECL:
- case GNU_AK_STDCALL:
- case GNU_AK_FASTCALL:
case GNU_AK_DEPRECATED:
- case GNU_AK_NOINLINE:
- case GNU_AK_NORETURN:
case GNU_AK_NAKED:
- case GNU_AK_PURE:
- case GNU_AK_ALWAYS_INLINE:
case GNU_AK_MALLOC:
case GNU_AK_WEAK:
- case GNU_AK_CONSTRUCTOR:
- case GNU_AK_DESTRUCTOR:
- case GNU_AK_NOTHROW:
- case GNU_AK_TRANSPARENT_UNION:
case GNU_AK_COMMON:
case GNU_AK_NOCOMMON:
- case GNU_AK_PACKED:
case GNU_AK_SHARED:
case GNU_AK_NOTSHARED:
- case GNU_AK_USED:
case GNU_AK_UNUSED:
case GNU_AK_NO_INSTRUMENT_FUNCTION:
case GNU_AK_WARN_UNUSED_RESULT:
case GNU_AK_MAY_ALIAS:
case GNU_AK_MS_STRUCT:
case GNU_AK_GCC_STRUCT:
- case GNU_AK_DLLIMPORT:
- case GNU_AK_DLLEXPORT:
- if(attribute->have_arguments) {
- /* should have no arguments */
- errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
- eat_until_matching_token('(');
- /* we have already consumed '(', so we stop before ')', eat it */
- eat(')');
- attribute->invalid = true;
+ goto no_arg;
+
+ case GNU_AK_CDECL: modifiers |= DM_CDECL; goto no_arg;
+ case GNU_AK_FASTCALL: modifiers |= DM_FASTCALL; goto no_arg;
+ case GNU_AK_STDCALL: modifiers |= DM_STDCALL; goto no_arg;
+ case GNU_AK_USED: modifiers |= DM_USED; goto no_arg;
+ case GNU_AK_PURE: modifiers |= DM_PURE; goto no_arg;
+ case GNU_AK_ALWAYS_INLINE: modifiers |= DM_FORCEINLINE; goto no_arg;
+ case GNU_AK_DLLIMPORT: modifiers |= DM_DLLIMPORT; goto no_arg;
+ case GNU_AK_DLLEXPORT: modifiers |= DM_DLLEXPORT; goto no_arg;
+ case GNU_AK_PACKED: modifiers |= DM_PACKED; goto no_arg;
+ case GNU_AK_NOINLINE: modifiers |= DM_NOINLINE; goto no_arg;
+ case GNU_AK_NORETURN: modifiers |= DM_NORETURN; goto no_arg;
+ case GNU_AK_NOTHROW: modifiers |= DM_NOTHROW; goto no_arg;
+ case GNU_AK_TRANSPARENT_UNION: modifiers |= DM_TRANSPARENT_UNION; goto no_arg;
+ case GNU_AK_CONSTRUCTOR: modifiers |= DM_CONSTRUCTOR; goto no_arg;
+ case GNU_AK_DESTRUCTOR: modifiers |= DM_DESTRUCTOR; goto no_arg;
+
+ case GNU_AK_ALIGNED:
+ /* __align__ may be used without an argument */
+ if (attribute->have_arguments) {
+ parse_gnu_attribute_const_arg(attribute);
}
break;
- case GNU_AK_ALIGNED:
case GNU_AK_FORMAT_ARG:
case GNU_AK_REGPARM:
case GNU_AK_TRAP_EXIT:
- if(!attribute->have_arguments) {
+ if (!attribute->have_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
attribute->invalid = true;
case GNU_AK_ALIAS:
case GNU_AK_SECTION:
case GNU_AK_SP_SWITCH:
- if(!attribute->have_arguments) {
+ if (!attribute->have_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
attribute->invalid = true;
parse_gnu_attribute_string_arg(attribute, &attribute->u.string);
break;
case GNU_AK_FORMAT:
- if(!attribute->have_arguments) {
+ if (!attribute->have_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
attribute->invalid = true;
break;
case GNU_AK_WEAKREF:
/* may have one string argument */
- if(attribute->have_arguments)
+ if (attribute->have_arguments)
parse_gnu_attribute_string_arg(attribute, &attribute->u.string);
break;
case GNU_AK_NONNULL:
- if(attribute->have_arguments)
+ if (attribute->have_arguments)
parse_gnu_attribute_const_arg_list(attribute);
break;
case GNU_AK_TLS_MODEL:
- if(!attribute->have_arguments) {
+ if (!attribute->have_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
} else
parse_gnu_attribute_tls_model_arg(attribute);
break;
case GNU_AK_VISIBILITY:
- if(!attribute->have_arguments) {
+ if (!attribute->have_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
} else
parse_gnu_attribute_visibility_arg(attribute);
break;
case GNU_AK_MODEL:
- if(!attribute->have_arguments) {
+ if (!attribute->have_arguments) {
/* should have arguments */
errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
- } else
+ } else {
parse_gnu_attribute_model_arg(attribute);
+ }
+ break;
+ case GNU_AK_MODE:
+ if (!attribute->have_arguments) {
+ /* should have arguments */
+ errorf(HERE, "wrong number of arguments specified for '%s' attribute", name);
+ } else {
+ parse_gnu_attribute_mode_arg(attribute);
+ }
+ break;
case GNU_AK_INTERRUPT:
/* may have one string argument */
- if(attribute->have_arguments)
+ if (attribute->have_arguments)
parse_gnu_attribute_interrupt_arg(attribute);
break;
case GNU_AK_SENTINEL:
/* may have one string argument */
- if(attribute->have_arguments)
+ if (attribute->have_arguments)
parse_gnu_attribute_const_arg(attribute);
break;
case GNU_AK_LAST:
/* already handled */
break;
+
+no_arg:
+ check_no_argument(attribute, name);
}
}
- if(attribute != NULL) {
- if(last != NULL) {
+ if (attribute != NULL) {
+ if (last != NULL) {
last->next = attribute;
last = attribute;
} else {
}
}
- if(token.type != ',')
+ if (token.type != ',')
break;
next_token();
}
expect(')');
end_error:
*attributes = head;
+
+ return modifiers;
}
/**
* Parse GNU attributes.
*/
-static void parse_attributes(gnu_attribute_t **attributes)
+static decl_modifiers_t parse_attributes(gnu_attribute_t **attributes)
{
+ decl_modifiers_t modifiers = 0;
+
while(true) {
switch(token.type) {
- case T___attribute__: {
- parse_gnu_attribute(attributes);
- break;
- }
+ case T___attribute__:
+ modifiers |= parse_gnu_attribute(attributes);
+ continue;
+
case T_asm:
next_token();
expect('(');
- if(token.type != T_STRING_LITERAL) {
+ if (token.type != T_STRING_LITERAL) {
parse_error_expected("while parsing assembler attribute",
- T_STRING_LITERAL);
+ T_STRING_LITERAL, NULL);
eat_until_matching_token('(');
break;
} else {
parse_string_literals();
}
expect(')');
+ continue;
+
+ case T_cdecl: modifiers |= DM_CDECL; break;
+ case T__fastcall: modifiers |= DM_FASTCALL; break;
+ case T__stdcall: modifiers |= DM_STDCALL; break;
+
+ case T___thiscall:
+ /* TODO record modifier */
+ warningf(HERE, "Ignoring declaration modifier %K", &token);
break;
- default:
- goto attributes_finished;
- }
- }
-attributes_finished:
end_error:
- return;
+ default: return modifiers;
+ }
+
+ next_token();
+ }
}
static designator_t *parse_designation(void)
designator = allocate_ast_zero(sizeof(designator[0]));
designator->source_position = token.source_position;
next_token();
- if(token.type != T_IDENTIFIER) {
+ if (token.type != T_IDENTIFIER) {
parse_error_expected("while parsing designator",
- T_IDENTIFIER, 0);
+ T_IDENTIFIER, NULL);
return NULL;
}
designator->symbol = token.v.symbol;
}
assert(designator != NULL);
- if(last != NULL) {
+ if (last != NULL) {
last->next = designator;
} else {
result = designator;
}
}
- type_t *const res_type = semantic_assign(type, expression, "initializer",
- &expression->base.source_position);
- if (res_type == NULL)
+ assign_error_t error = semantic_assign(type, expression);
+ if (error == ASSIGN_ERROR_INCOMPATIBLE)
return NULL;
+ report_assign_error(error, type, expression, "initializer",
+ &expression->base.source_position);
initializer_t *const result = allocate_initializer_zero(INITIALIZER_VALUE);
- result->value.value = create_implicit_cast(expression, res_type);
+ result->value.value = create_implicit_cast(expression, type);
return result;
}
{
/* there might be extra {} hierarchies */
int braces = 0;
- while(token.type == '{') {
- next_token();
- if(braces == 0) {
- warningf(HERE, "extra curly braces around scalar initializer");
- }
- braces++;
+ if (token.type == '{') {
+ warningf(HERE, "extra curly braces around scalar initializer");
+ do {
+ ++braces;
+ next_token();
+ } while (token.type == '{');
}
expression_t *expression = parse_assignment_expression();
- if(must_be_constant && !is_initializer_constant(expression)) {
+ if (must_be_constant && !is_initializer_constant(expression)) {
errorf(&expression->base.source_position,
"Initialisation expression '%E' is not constant\n",
expression);
initializer_t *initializer = initializer_from_expression(type, expression);
- if(initializer == NULL) {
+ if (initializer == NULL) {
errorf(&expression->base.source_position,
"expression '%E' (type '%T') doesn't match expected type '%T'",
expression, expression->base.type, type);
bool additional_warning_displayed = false;
while(braces > 0) {
- if(token.type == ',') {
+ if (token.type == ',') {
next_token();
}
- if(token.type != '}') {
- if(!additional_warning_displayed) {
+ if (token.type != '}') {
+ if (!additional_warning_displayed) {
warningf(HERE, "additional elements in scalar initializer");
additional_warning_displayed = true;
}
const type_path_entry_t *entry = & path->path[i];
type_t *type = skip_typeref(entry->type);
- if(is_type_compound(type)) {
+ if (is_type_compound(type)) {
/* in gcc mode structs can have no members */
- if(entry->v.compound_entry == NULL) {
+ if (entry->v.compound_entry == NULL) {
assert(i == len-1);
continue;
}
fprintf(stderr, ".%s", entry->v.compound_entry->symbol->string);
- } else if(is_type_array(type)) {
+ } else if (is_type_array(type)) {
fprintf(stderr, "[%zd]", entry->v.index);
} else {
fprintf(stderr, "-INVALID-");
}
}
- if(path->top_type != NULL) {
+ if (path->top_type != NULL) {
fprintf(stderr, " (");
print_type(path->top_type);
fprintf(stderr, ")");
type_path_entry_t *top = append_to_type_path(path);
top->type = top_type;
- if(is_type_compound(top_type)) {
+ if (is_type_compound(top_type)) {
declaration_t *declaration = top_type->compound.declaration;
declaration_t *entry = declaration->scope.declarations;
top->v.compound_entry = entry;
- if(entry != NULL) {
+ if (entry != NULL) {
path->top_type = entry->type;
} else {
path->top_type = NULL;
type_t *type = skip_typeref(orig_type);
- if(designator->symbol != NULL) {
+ if (designator->symbol != NULL) {
symbol_t *symbol = designator->symbol;
- if(!is_type_compound(type)) {
- if(is_type_valid(type)) {
+ if (!is_type_compound(type)) {
+ if (is_type_valid(type)) {
errorf(&designator->source_position,
"'.%Y' designator used for non-compound type '%T'",
symbol, orig_type);
declaration_t *declaration = type->compound.declaration;
declaration_t *iter = declaration->scope.declarations;
for( ; iter != NULL; iter = iter->next) {
- if(iter->symbol == symbol) {
+ if (iter->symbol == symbol) {
break;
}
}
- if(iter == NULL) {
+ if (iter == NULL) {
errorf(&designator->source_position,
"'%T' has no member named '%Y'", orig_type, symbol);
goto failed;
}
- if(used_in_offsetof) {
+ if (used_in_offsetof) {
type_t *real_type = skip_typeref(iter->type);
- if(real_type->kind == TYPE_BITFIELD) {
+ if (real_type->kind == TYPE_BITFIELD) {
errorf(&designator->source_position,
"offsetof designator '%Y' may not specify bitfield",
symbol);
expression_t *array_index = designator->array_index;
assert(designator->array_index != NULL);
- if(!is_type_array(type)) {
- if(is_type_valid(type)) {
+ if (!is_type_array(type)) {
+ if (is_type_valid(type)) {
errorf(&designator->source_position,
"[%E] designator used for non-array type '%T'",
array_index, orig_type);
}
goto failed;
}
- if(!is_type_valid(array_index->base.type)) {
+ if (!is_type_valid(array_index->base.type)) {
goto failed;
}
long index = fold_constant(array_index);
- if(!used_in_offsetof) {
- if(index < 0) {
+ if (!used_in_offsetof) {
+ if (index < 0) {
errorf(&designator->source_position,
"array index [%E] must be positive", array_index);
goto failed;
}
- if(type->array.size_constant == true) {
+ if (type->array.size_constant == true) {
long array_size = type->array.size;
- if(index >= array_size) {
+ if (index >= array_size) {
errorf(&designator->source_position,
"designator [%E] (%d) exceeds array size %d",
array_index, index, array_size);
}
path->top_type = orig_type;
- if(designator->next != NULL) {
+ if (designator->next != NULL) {
descend_into_subtype(path);
}
}
type_path_entry_t *top = get_type_path_top(path);
type_t *type = skip_typeref(top->type);
- if(is_type_union(type)) {
+ if (is_type_union(type)) {
/* in unions only the first element is initialized */
top->v.compound_entry = NULL;
- } else if(is_type_struct(type)) {
+ } else if (is_type_struct(type)) {
declaration_t *entry = top->v.compound_entry;
entry = entry->next;
top->v.compound_entry = entry;
- if(entry != NULL) {
+ if (entry != NULL) {
path->top_type = entry->type;
return;
}
top->v.index++;
- if(!type->array.size_constant || top->v.index < type->array.size) {
+ if (!type->array.size_constant || top->v.index < type->array.size) {
return;
}
}
* can ascend in the type hierarchy and continue with another subobject */
size_t len = ARR_LEN(path->path);
- if(len > top_path_level) {
+ if (len > top_path_level) {
ascend_from_subtype(path);
advance_current_object(path, top_path_level);
} else {
*/
static void skip_until(int type) {
while(token.type != type) {
- if(token.type == T_EOF)
+ if (token.type == T_EOF)
return;
next_token();
}
}
/**
- * skip any {...} blocks until a closing braket is reached.
+ * skip any {...} blocks until a closing bracket is reached.
*/
static void skip_initializers(void)
{
- if(token.type == '{')
+ if (token.type == '{')
next_token();
while(token.type != '}') {
- if(token.type == T_EOF)
+ if (token.type == T_EOF)
return;
- if(token.type == '{') {
+ if (token.type == '{') {
eat_block();
continue;
}
type_t *outer_type, size_t top_path_level,
parse_initializer_env_t *env)
{
- if(token.type == '}') {
+ if (token.type == '}') {
/* empty initializer */
return create_empty_initializer();
}
/* we can't do usefull stuff if we didn't even parse the type. Skip the
* initializers in this case. */
- if(!is_type_valid(type)) {
+ if (!is_type_valid(type)) {
skip_initializers();
return create_empty_initializer();
}
while(true) {
designator_t *designator = NULL;
- if(token.type == '.' || token.type == '[') {
+ if (token.type == '.' || token.type == '[') {
designator = parse_designation();
/* reset path to toplevel, evaluate designator from there */
ascend_to(path, top_path_level);
- if(!walk_designator(path, designator, false)) {
+ if (!walk_designator(path, designator, false)) {
/* can't continue after designation error */
goto end_error;
}
= allocate_initializer_zero(INITIALIZER_DESIGNATOR);
designator_initializer->designator.designator = designator;
ARR_APP1(initializer_t*, initializers, designator_initializer);
+
+ orig_type = path->top_type;
+ type = orig_type != NULL ? skip_typeref(orig_type) : NULL;
}
initializer_t *sub;
- if(token.type == '{') {
- if(type != NULL && is_type_scalar(type)) {
+ if (token.type == '{') {
+ if (type != NULL && is_type_scalar(type)) {
sub = parse_scalar_initializer(type, env->must_be_constant);
} else {
eat('{');
- if(type == NULL) {
- if (env->declaration != NULL)
+ if (type == NULL) {
+ if (env->declaration != NULL) {
errorf(HERE, "extra brace group at end of initializer for '%Y'",
- env->declaration->symbol);
- else
- errorf(HERE, "extra brace group at end of initializer");
+ env->declaration->symbol);
+ } else {
+ errorf(HERE, "extra brace group at end of initializer");
+ }
} else
descend_into_subtype(path);
env);
rem_anchor_token('}');
- if(type != NULL) {
+ if (type != NULL) {
ascend_from_subtype(path);
expect('}');
} else {
/* must be an expression */
expression_t *expression = parse_assignment_expression();
- if(env->must_be_constant && !is_initializer_constant(expression)) {
+ if (env->must_be_constant && !is_initializer_constant(expression)) {
errorf(&expression->base.source_position,
"Initialisation expression '%E' is not constant\n",
expression);
}
- if(type == NULL) {
+ if (type == NULL) {
/* we are already outside, ... */
goto error_excess;
}
/* handle { "string" } special case */
- if((expression->kind == EXPR_STRING_LITERAL
+ if ((expression->kind == EXPR_STRING_LITERAL
|| expression->kind == EXPR_WIDE_STRING_LITERAL)
&& outer_type != NULL) {
sub = initializer_from_expression(outer_type, expression);
- if(sub != NULL) {
- if(token.type == ',') {
+ if (sub != NULL) {
+ if (token.type == ',') {
next_token();
}
- if(token.type != '}') {
+ if (token.type != '}') {
warningf(HERE, "excessive elements in initializer for type '%T'",
orig_type);
}
type = skip_typeref(orig_type);
sub = initializer_from_expression(orig_type, expression);
- if(sub != NULL) {
+ if (sub != NULL) {
break;
}
- if(!is_type_valid(type)) {
+ if (!is_type_valid(type)) {
goto end_error;
}
- if(is_type_scalar(type)) {
+ if (is_type_scalar(type)) {
errorf(&expression->base.source_position,
"expression '%E' doesn't match expected type '%T'",
expression, orig_type);
const type_path_entry_t *first = &path->path[0];
type_t *first_type = first->type;
first_type = skip_typeref(first_type);
- if(is_type_array(first_type)) {
+ if (is_type_array(first_type)) {
size_t index = first->v.index;
- if(index > path->max_index)
+ if (index > path->max_index)
path->max_index = index;
}
- if(type != NULL) {
+ if (type != NULL) {
/* append to initializers list */
ARR_APP1(initializer_t*, initializers, sub);
} else {
error_excess:
- if(env->declaration != NULL)
+ if (env->declaration != NULL)
warningf(HERE, "excess elements in struct initializer for '%Y'",
env->declaration->symbol);
else
}
error_parse_next:
- if(token.type == '}') {
+ if (token.type == '}') {
break;
}
expect(',');
- if(token.type == '}') {
+ if (token.type == '}') {
break;
}
- if(type != NULL) {
+ if (type != NULL) {
/* advance to the next declaration if we are not at the end */
advance_current_object(path, top_path_level);
orig_type = path->top_type;
- if(orig_type != NULL)
+ if (orig_type != NULL)
type = skip_typeref(orig_type);
else
type = NULL;
len * sizeof(initializers[0]));
DEL_ARR_F(initializers);
- ascend_to(path, top_path_level);
+ ascend_to(path, top_path_level+1);
return result;
end_error:
skip_initializers();
DEL_ARR_F(initializers);
- ascend_to(path, top_path_level);
+ ascend_to(path, top_path_level+1);
return NULL;
}
initializer_t *result = NULL;
size_t max_index;
- if(is_type_scalar(type)) {
+ if (is_type_scalar(type)) {
result = parse_scalar_initializer(type, env->must_be_constant);
- } else if(token.type == '{') {
+ } else if (token.type == '{') {
eat('{');
type_path_t path;
/* § 6.7.5 (22) array initializers for arrays with unknown size determine
* the array type size */
- if(is_type_array(type) && type->array.size_expression == NULL
+ if (is_type_array(type) && type->array.size_expression == NULL
&& result != NULL) {
size_t size;
switch (result->kind) {
size = result->wide_string.string.size;
break;
+ case INITIALIZER_DESIGNATOR:
+ case INITIALIZER_VALUE:
+ /* can happen for parse errors */
+ size = 0;
+ break;
+
default:
internal_errorf(HERE, "invalid initializer type");
}
static declaration_t *parse_compound_type_specifier(bool is_struct)
{
- gnu_attribute_t *attributes = NULL;
- if(is_struct) {
+ gnu_attribute_t *attributes = NULL;
+ decl_modifiers_t modifiers = 0;
+ if (is_struct) {
eat(T_struct);
} else {
eat(T_union);
declaration_t *declaration = NULL;
if (token.type == T___attribute__) {
- parse_attributes(&attributes);
+ modifiers |= parse_attributes(&attributes);
}
- if(token.type == T_IDENTIFIER) {
+ if (token.type == T_IDENTIFIER) {
symbol = token.v.symbol;
next_token();
- if(is_struct) {
- declaration = get_declaration(symbol, NAMESPACE_STRUCT);
- } else {
- declaration = get_declaration(symbol, NAMESPACE_UNION);
+ namespace_t const namespc =
+ is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION;
+ declaration = get_declaration(symbol, namespc);
+ if (declaration != NULL) {
+ if (declaration->parent_scope != scope &&
+ (token.type == '{' || token.type == ';')) {
+ declaration = NULL;
+ } else if (declaration->init.complete &&
+ token.type == '{') {
+ assert(symbol != NULL);
+ errorf(HERE, "multiple definitions of '%s %Y' (previous definition at %P)",
+ is_struct ? "struct" : "union", symbol,
+ &declaration->source_position);
+ declaration->scope.declarations = NULL;
+ }
}
- } else if(token.type != '{') {
- if(is_struct) {
+ } else if (token.type != '{') {
+ if (is_struct) {
parse_error_expected("while parsing struct type specifier",
- T_IDENTIFIER, '{', 0);
+ T_IDENTIFIER, '{', NULL);
} else {
parse_error_expected("while parsing union type specifier",
- T_IDENTIFIER, '{', 0);
+ T_IDENTIFIER, '{', NULL);
}
return NULL;
}
- if(declaration == NULL) {
+ if (declaration == NULL) {
declaration = allocate_declaration_zero();
declaration->namespc =
(is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION);
declaration->source_position = token.source_position;
declaration->symbol = symbol;
- declaration->parent_scope = scope;
+ declaration->parent_scope = scope;
if (symbol != NULL) {
environment_push(declaration);
}
append_declaration(declaration);
}
- if(token.type == '{') {
- if(declaration->init.is_defined) {
- assert(symbol != NULL);
- errorf(HERE, "multiple definitions of '%s %Y'",
- is_struct ? "struct" : "union", symbol);
- declaration->scope.declarations = NULL;
- }
- declaration->init.is_defined = true;
+ if (token.type == '{') {
+ declaration->init.complete = true;
parse_compound_type_entries(declaration);
- parse_attributes(&attributes);
+ modifiers |= parse_attributes(&attributes);
}
+ declaration->modifiers |= modifiers;
return declaration;
}
{
eat('{');
- if(token.type == '}') {
+ if (token.type == '}') {
next_token();
errorf(HERE, "empty enum not allowed");
return;
add_anchor_token('}');
do {
- if(token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing enum entry", T_IDENTIFIER, 0);
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing enum entry", T_IDENTIFIER, NULL);
eat_block();
rem_anchor_token('}');
return;
entry->source_position = token.source_position;
next_token();
- if(token.type == '=') {
+ if (token.type == '=') {
next_token();
expression_t *value = parse_constant_expression();
record_declaration(entry);
- if(token.type != ',')
+ if (token.type != ',')
break;
next_token();
} while(token.type != '}');
symbol_t *symbol;
eat(T_enum);
- if(token.type == T_IDENTIFIER) {
+ if (token.type == T_IDENTIFIER) {
symbol = token.v.symbol;
next_token();
declaration = get_declaration(symbol, NAMESPACE_ENUM);
- } else if(token.type != '{') {
+ } else if (token.type != '{') {
parse_error_expected("while parsing enum type specifier",
- T_IDENTIFIER, '{', 0);
+ T_IDENTIFIER, '{', NULL);
return NULL;
} else {
declaration = NULL;
symbol = NULL;
}
- if(declaration == NULL) {
+ if (declaration == NULL) {
declaration = allocate_declaration_zero();
declaration->namespc = NAMESPACE_ENUM;
declaration->source_position = token.source_position;
type_t *const type = allocate_type_zero(TYPE_ENUM, &declaration->source_position);
type->enumt.declaration = declaration;
- if(token.type == '{') {
- if(declaration->init.is_defined) {
+ if (token.type == '{') {
+ if (declaration->init.complete) {
errorf(HERE, "multiple definitions of enum %Y", symbol);
}
if (symbol != NULL) {
environment_push(declaration);
}
append_declaration(declaration);
- declaration->init.is_defined = 1;
+ declaration->init.complete = true;
parse_enum_entries(type);
parse_attributes(&attributes);
goto restart;
case T_IDENTIFIER:
- if(is_typedef_symbol(token.v.symbol)) {
+ if (is_typedef_symbol(token.v.symbol)) {
type = parse_typename();
} else {
expression = parse_expression();
SPECIFIER_INT32 = 1 << 13,
SPECIFIER_INT64 = 1 << 14,
SPECIFIER_INT128 = 1 << 15,
-#ifdef PROVIDE_COMPLEX
SPECIFIER_COMPLEX = 1 << 16,
SPECIFIER_IMAGINARY = 1 << 17,
-#endif
} specifiers_t;
static type_t *create_builtin_type(symbol_t *const symbol,
static type_t *get_typedef_type(symbol_t *symbol)
{
declaration_t *declaration = get_declaration(symbol, NAMESPACE_NORMAL);
- if(declaration == NULL
- || declaration->storage_class != STORAGE_CLASS_TYPEDEF)
+ if (declaration == NULL ||
+ declaration->storage_class != STORAGE_CLASS_TYPEDEF)
return NULL;
type_t *type = allocate_type_zero(TYPE_TYPEDEF, &declaration->source_position);
* check for the allowed MS alignment values.
*/
static bool check_elignment_value(long long intvalue) {
- if(intvalue < 1 || intvalue > 8192) {
+ if (intvalue < 1 || intvalue > 8192) {
errorf(HERE, "illegal alignment value");
return false;
}
}
#define DET_MOD(name, tag) do { \
- if(*modifiers & tag) warningf(HERE, #name " used more than once"); \
+ if (*modifiers & tag) warningf(HERE, #name " used more than once"); \
*modifiers |= tag; \
} while(0)
static void parse_microsoft_extended_decl_modifier(declaration_specifiers_t *specifiers)
{
- decl_modifiers_t *modifiers = &specifiers->decl_modifiers;
+ decl_modifiers_t *modifiers = &specifiers->modifiers;
while(true) {
- if(token.type == T_restrict) {
+ if (token.type == T_restrict) {
next_token();
DET_MOD(restrict, DM_RESTRICT);
goto end_loop;
- } else if(token.type != T_IDENTIFIER)
+ } else if (token.type != T_IDENTIFIER)
break;
symbol_t *symbol = token.v.symbol;
- if(symbol == sym_align) {
+ if (symbol == sym_align) {
next_token();
expect('(');
- if(token.type != T_INTEGER)
+ if (token.type != T_INTEGER)
goto end_error;
- if(check_elignment_value(token.v.intvalue)) {
- if(specifiers->alignment != 0)
+ if (check_elignment_value(token.v.intvalue)) {
+ if (specifiers->alignment != 0)
warningf(HERE, "align used more than once");
specifiers->alignment = (unsigned char)token.v.intvalue;
}
next_token();
expect(')');
- } else if(symbol == sym_allocate) {
+ } else if (symbol == sym_allocate) {
next_token();
expect('(');
- if(token.type != T_IDENTIFIER)
+ if (token.type != T_IDENTIFIER)
goto end_error;
(void)token.v.symbol;
expect(')');
- } else if(symbol == sym_dllimport) {
+ } else if (symbol == sym_dllimport) {
next_token();
DET_MOD(dllimport, DM_DLLIMPORT);
- } else if(symbol == sym_dllexport) {
+ } else if (symbol == sym_dllexport) {
next_token();
DET_MOD(dllexport, DM_DLLEXPORT);
- } else if(symbol == sym_thread) {
+ } else if (symbol == sym_thread) {
next_token();
DET_MOD(thread, DM_THREAD);
- } else if(symbol == sym_naked) {
+ } else if (symbol == sym_naked) {
next_token();
DET_MOD(naked, DM_NAKED);
- } else if(symbol == sym_noinline) {
+ } else if (symbol == sym_noinline) {
next_token();
DET_MOD(noinline, DM_NOINLINE);
- } else if(symbol == sym_noreturn) {
+ } else if (symbol == sym_noreturn) {
next_token();
DET_MOD(noreturn, DM_NORETURN);
- } else if(symbol == sym_nothrow) {
+ } else if (symbol == sym_nothrow) {
next_token();
DET_MOD(nothrow, DM_NOTHROW);
- } else if(symbol == sym_novtable) {
+ } else if (symbol == sym_novtable) {
next_token();
DET_MOD(novtable, DM_NOVTABLE);
- } else if(symbol == sym_property) {
+ } else if (symbol == sym_property) {
next_token();
expect('(');
for(;;) {
bool is_get = false;
- if(token.type != T_IDENTIFIER)
+ if (token.type != T_IDENTIFIER)
goto end_error;
- if(token.v.symbol == sym_get) {
+ if (token.v.symbol == sym_get) {
is_get = true;
- } else if(token.v.symbol == sym_put) {
+ } else if (token.v.symbol == sym_put) {
} else {
errorf(HERE, "Bad property name '%Y'", token.v.symbol);
goto end_error;
}
next_token();
expect('=');
- if(token.type != T_IDENTIFIER)
+ if (token.type != T_IDENTIFIER)
goto end_error;
- if(is_get) {
- if(specifiers->get_property_sym != NULL) {
+ if (is_get) {
+ if (specifiers->get_property_sym != NULL) {
errorf(HERE, "get property name already specified");
} else {
specifiers->get_property_sym = token.v.symbol;
}
} else {
- if(specifiers->put_property_sym != NULL) {
+ if (specifiers->put_property_sym != NULL) {
errorf(HERE, "put property name already specified");
} else {
specifiers->put_property_sym = token.v.symbol;
}
}
next_token();
- if(token.type == ',') {
+ if (token.type == ',') {
next_token();
continue;
}
break;
}
expect(')');
- } else if(symbol == sym_selectany) {
+ } else if (symbol == sym_selectany) {
next_token();
DET_MOD(selectany, DM_SELECTANY);
- } else if(symbol == sym_uuid) {
+ } else if (symbol == sym_uuid) {
next_token();
expect('(');
- if(token.type != T_STRING_LITERAL)
+ if (token.type != T_STRING_LITERAL)
goto end_error;
next_token();
expect(')');
- } else if(symbol == sym_deprecated) {
+ } else if (symbol == sym_deprecated) {
next_token();
- if(specifiers->deprecated != 0)
+ if (specifiers->deprecated != 0)
warningf(HERE, "deprecated used more than once");
specifiers->deprecated = 1;
- if(token.type == '(') {
+ if (token.type == '(') {
next_token();
- if(token.type == T_STRING_LITERAL) {
+ if (token.type == T_STRING_LITERAL) {
specifiers->deprecated_string = token.v.string.begin;
next_token();
} else {
}
expect(')');
}
- } else if(symbol == sym_noalias) {
+ } else if (symbol == sym_noalias) {
next_token();
DET_MOD(noalias, DM_NOALIAS);
} else {
warningf(HERE, "Unknown modifier %Y ignored", token.v.symbol);
next_token();
- if(token.type == '(')
+ if (token.type == '(')
skip_until(')');
}
end_loop:
static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
{
- type_t *type = NULL;
- unsigned type_qualifiers = 0;
- unsigned type_specifiers = 0;
- int newtype = 0;
+ type_t *type = NULL;
+ type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
+ type_modifiers_t modifiers = TYPE_MODIFIER_NONE;
+ unsigned type_specifiers = 0;
+ int newtype = 0;
specifiers->source_position = token.source_position;
while(true) {
+ specifiers->modifiers
+ |= parse_attributes(&specifiers->gnu_attributes);
+ if (specifiers->modifiers & DM_TRANSPARENT_UNION)
+ modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
+
switch(token.type) {
/* storage class */
#define MATCH_STORAGE_CLASS(token, class) \
case token: \
- if(specifiers->declared_storage_class != STORAGE_CLASS_NONE) { \
+ if (specifiers->declared_storage_class != STORAGE_CLASS_NONE) { \
errorf(HERE, "multiple storage classes in declaration specifiers"); \
} \
specifiers->declared_storage_class = class; \
/* type qualifiers */
#define MATCH_TYPE_QUALIFIER(token, qualifier) \
case token: \
- type_qualifiers |= qualifier; \
+ qualifiers |= qualifier; \
next_token(); \
break;
#define MATCH_SPECIFIER(token, specifier, name) \
case token: \
next_token(); \
- if(type_specifiers & specifier) { \
+ if (type_specifiers & specifier) { \
errorf(HERE, "multiple " name " type specifiers given"); \
} else { \
type_specifiers |= specifier; \
MATCH_SPECIFIER(T__int32, SPECIFIER_INT32, "_int32")
MATCH_SPECIFIER(T__int64, SPECIFIER_INT64, "_int64")
MATCH_SPECIFIER(T__int128, SPECIFIER_INT128, "_int128")
-#ifdef PROVIDE_COMPLEX
MATCH_SPECIFIER(T__Complex, SPECIFIER_COMPLEX, "_Complex")
MATCH_SPECIFIER(T__Imaginary, SPECIFIER_IMAGINARY, "_Imaginary")
-#endif
+
case T__forceinline:
/* only in microsoft mode */
- specifiers->decl_modifiers |= DM_FORCEINLINE;
+ specifiers->modifiers |= DM_FORCEINLINE;
case T_inline:
next_token();
case T_long:
next_token();
- if(type_specifiers & SPECIFIER_LONG_LONG) {
+ if (type_specifiers & SPECIFIER_LONG_LONG) {
errorf(HERE, "multiple type specifiers given");
- } else if(type_specifiers & SPECIFIER_LONG) {
+ } else if (type_specifiers & SPECIFIER_LONG) {
type_specifiers |= SPECIFIER_LONG_LONG;
} else {
type_specifiers |= SPECIFIER_LONG;
}
case T_union: {
type = allocate_type_zero(TYPE_COMPOUND_UNION, HERE);
-
type->compound.declaration = parse_compound_type_specifier(false);
+ if (type->compound.declaration->modifiers & DM_TRANSPARENT_UNION)
+ modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
break;
}
case T_enum:
next_token();
break;
- case T___attribute__:
- parse_attributes(&specifiers->gnu_attributes);
- break;
-
case T_IDENTIFIER: {
/* only parse identifier if we haven't found a type yet */
- if(type != NULL || type_specifiers != 0)
+ if (type != NULL || type_specifiers != 0)
goto finish_specifiers;
type_t *typedef_type = get_typedef_type(token.v.symbol);
- if(typedef_type == NULL)
+ if (typedef_type == NULL)
goto finish_specifiers;
next_token();
finish_specifiers:
- if(type == NULL) {
+ if (type == NULL) {
atomic_type_kind_t atomic_type;
/* match valid basic types */
case SPECIFIER_BOOL:
atomic_type = ATOMIC_TYPE_BOOL;
break;
-#ifdef PROVIDE_COMPLEX
case SPECIFIER_FLOAT | SPECIFIER_COMPLEX:
- atomic_type = ATOMIC_TYPE_FLOAT_COMPLEX;
- break;
- case SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
- atomic_type = ATOMIC_TYPE_DOUBLE_COMPLEX;
- break;
- case SPECIFIER_LONG | SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
- atomic_type = ATOMIC_TYPE_LONG_DOUBLE_COMPLEX;
- break;
case SPECIFIER_FLOAT | SPECIFIER_IMAGINARY:
- atomic_type = ATOMIC_TYPE_FLOAT_IMAGINARY;
+ atomic_type = ATOMIC_TYPE_FLOAT;
break;
+ case SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
case SPECIFIER_DOUBLE | SPECIFIER_IMAGINARY:
- atomic_type = ATOMIC_TYPE_DOUBLE_IMAGINARY;
+ atomic_type = ATOMIC_TYPE_DOUBLE;
break;
+ case SPECIFIER_LONG | SPECIFIER_DOUBLE | SPECIFIER_COMPLEX:
case SPECIFIER_LONG | SPECIFIER_DOUBLE | SPECIFIER_IMAGINARY:
- atomic_type = ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY;
+ atomic_type = ATOMIC_TYPE_LONG_DOUBLE;
break;
-#endif
default:
/* invalid specifier combination, give an error message */
- if(type_specifiers == 0) {
+ if (type_specifiers == 0) {
if (! strict_mode) {
if (warning.implicit_int) {
warningf(HERE, "no type specifiers in declaration, using 'int'");
} else {
errorf(HERE, "no type specifiers given in declaration");
}
- } else if((type_specifiers & SPECIFIER_SIGNED) &&
+ } else if ((type_specifiers & SPECIFIER_SIGNED) &&
(type_specifiers & SPECIFIER_UNSIGNED)) {
errorf(HERE, "signed and unsigned specifiers gives");
- } else if(type_specifiers & (SPECIFIER_SIGNED | SPECIFIER_UNSIGNED)) {
+ } else if (type_specifiers & (SPECIFIER_SIGNED | SPECIFIER_UNSIGNED)) {
errorf(HERE, "only integer types can be signed or unsigned");
} else {
errorf(HERE, "multiple datatypes in declaration");
atomic_type = ATOMIC_TYPE_INVALID;
}
- type = allocate_type_zero(TYPE_ATOMIC, &builtin_source_position);
- type->atomic.akind = atomic_type;
- newtype = 1;
+ if (type_specifiers & SPECIFIER_COMPLEX &&
+ atomic_type != ATOMIC_TYPE_INVALID) {
+ type = allocate_type_zero(TYPE_COMPLEX, &builtin_source_position);
+ type->complex.akind = atomic_type;
+ } else if (type_specifiers & SPECIFIER_IMAGINARY &&
+ atomic_type != ATOMIC_TYPE_INVALID) {
+ type = allocate_type_zero(TYPE_IMAGINARY, &builtin_source_position);
+ type->imaginary.akind = atomic_type;
+ } else {
+ type = allocate_type_zero(TYPE_ATOMIC, &builtin_source_position);
+ type->atomic.akind = atomic_type;
+ }
+ newtype = 1;
} else {
- if(type_specifiers != 0) {
+ if (type_specifiers != 0) {
errorf(HERE, "multiple datatypes in declaration");
}
}
- type->base.qualifiers = type_qualifiers;
/* FIXME: check type qualifiers here */
+ type->base.qualifiers = qualifiers;
+ type->base.modifiers = modifiers;
+
type_t *result = typehash_insert(type);
- if(newtype && result != type) {
+ if (newtype && result != type) {
free_type(type);
}
static type_qualifiers_t parse_type_qualifiers(void)
{
- type_qualifiers_t type_qualifiers = TYPE_QUALIFIER_NONE;
+ type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
while(true) {
switch(token.type) {
MATCH_TYPE_QUALIFIER(T___sptr, TYPE_QUALIFIER_SPTR);
default:
- return type_qualifiers;
+ return qualifiers;
}
}
}
declaration->symbol = token.v.symbol;
next_token();
- if(last_declaration != NULL) {
+ if (last_declaration != NULL) {
last_declaration->next = declaration;
} else {
declarations = declaration;
}
last_declaration = declaration;
- if(token.type != ',')
+ if (token.type != ',') {
break;
+ }
next_token();
} while(token.type == T_IDENTIFIER);
return declarations;
}
+static type_t *automatic_type_conversion(type_t *orig_type);
+
static void semantic_parameter(declaration_t *declaration)
{
/* TODO: improve error messages */
- if(declaration->declared_storage_class == STORAGE_CLASS_TYPEDEF) {
+ if (declaration->declared_storage_class == STORAGE_CLASS_TYPEDEF) {
errorf(HERE, "typedef not allowed in parameter list");
- } else if(declaration->declared_storage_class != STORAGE_CLASS_NONE
+ } else if (declaration->declared_storage_class != STORAGE_CLASS_NONE
&& declaration->declared_storage_class != STORAGE_CLASS_REGISTER) {
errorf(HERE, "parameter may only have none or register storage class");
}
type_t *const orig_type = declaration->type;
- type_t * type = skip_typeref(orig_type);
-
- /* Array as last part of a parameter type is just syntactic sugar. Turn it
- * into a pointer. § 6.7.5.3 (7) */
- if (is_type_array(type)) {
- type_t *const element_type = type->array.element_type;
-
- type = make_pointer_type(element_type, type->base.qualifiers);
-
- declaration->type = type;
- }
+ /* §6.7.5.3(7): Array as last part of a parameter type is just syntactic
+ * sugar. Turn it into a pointer.
+ * §6.7.5.3(8): A declaration of a parameter as ``function returning type''
+ * shall be adjusted to ``pointer to function returning type'', as in 6.3.2.1.
+ */
+ type_t *const type = automatic_type_conversion(orig_type);
+ declaration->type = type;
- if(is_type_incomplete(type)) {
+ if (is_type_incomplete(skip_typeref(type))) {
errorf(HERE, "incomplete type '%T' not allowed for parameter '%Y'",
orig_type, declaration->symbol);
}
declaration_t *declaration = parse_declarator(&specifiers, /*may_be_abstract=*/true);
- semantic_parameter(declaration);
-
return declaration;
}
static declaration_t *parse_parameters(function_type_t *type)
{
- if(token.type == T_IDENTIFIER) {
+ declaration_t *declarations = NULL;
+
+ eat('(');
+ add_anchor_token(')');
+ int saved_comma_state = save_and_reset_anchor_state(',');
+
+ if (token.type == T_IDENTIFIER) {
symbol_t *symbol = token.v.symbol;
- if(!is_typedef_symbol(symbol)) {
+ if (!is_typedef_symbol(symbol)) {
type->kr_style_parameters = true;
- return parse_identifier_list();
+ declarations = parse_identifier_list();
+ goto parameters_finished;
}
}
- if(token.type == ')') {
+ if (token.type == ')') {
type->unspecified_parameters = 1;
- return NULL;
- }
- if(token.type == T_void && look_ahead(1)->type == ')') {
- next_token();
- return NULL;
+ goto parameters_finished;
}
- declaration_t *declarations = NULL;
declaration_t *declaration;
declaration_t *last_declaration = NULL;
function_parameter_t *parameter;
case T_DOTDOTDOT:
next_token();
type->variadic = 1;
- return declarations;
+ goto parameters_finished;
case T_IDENTIFIER:
case T___extension__:
DECLARATION_START
declaration = parse_parameter();
+ /* func(void) is not a parameter */
+ if (last_parameter == NULL
+ && token.type == ')'
+ && declaration->symbol == NULL
+ && skip_typeref(declaration->type) == type_void) {
+ goto parameters_finished;
+ }
+ semantic_parameter(declaration);
+
parameter = obstack_alloc(type_obst, sizeof(parameter[0]));
memset(parameter, 0, sizeof(parameter[0]));
parameter->type = declaration->type;
- if(last_parameter != NULL) {
+ if (last_parameter != NULL) {
last_declaration->next = declaration;
last_parameter->next = parameter;
} else {
break;
default:
- return declarations;
+ goto parameters_finished;
+ }
+ if (token.type != ',') {
+ goto parameters_finished;
}
- if(token.type != ',')
- return declarations;
next_token();
}
+
+
+parameters_finished:
+ rem_anchor_token(')');
+ expect(')');
+
+ restore_anchor_state(',', saved_comma_state);
+ return declarations;
+
+end_error:
+ restore_anchor_state(',', saved_comma_state);
+ return NULL;
}
typedef enum {
memset(array, 0, sizeof(array[0]));
array->construct_type.kind = CONSTRUCT_ARRAY;
- if(token.type == T_static) {
+ if (token.type == T_static) {
array->is_static = true;
next_token();
}
type_qualifiers_t type_qualifiers = parse_type_qualifiers();
- if(type_qualifiers != 0) {
- if(token.type == T_static) {
+ if (type_qualifiers != 0) {
+ if (token.type == T_static) {
array->is_static = true;
next_token();
}
}
array->type_qualifiers = type_qualifiers;
- if(token.type == '*' && look_ahead(1)->type == ']') {
+ if (token.type == '*' && look_ahead(1)->type == ']') {
array->is_variable = true;
next_token();
- } else if(token.type != ']') {
+ } else if (token.type != ']') {
array->size = parse_assignment_expression();
}
static construct_type_t *parse_function_declarator(declaration_t *declaration)
{
- eat('(');
- add_anchor_token(')');
-
type_t *type;
- if(declaration != NULL) {
+ if (declaration != NULL) {
type = allocate_type_zero(TYPE_FUNCTION, &declaration->source_position);
} else {
type = allocate_type_zero(TYPE_FUNCTION, HERE);
}
declaration_t *parameters = parse_parameters(&type->function);
- if(declaration != NULL) {
+ if (declaration != NULL) {
declaration->scope.declarations = parameters;
}
construct_function_type->construct_type.kind = CONSTRUCT_FUNCTION;
construct_function_type->function_type = type;
- rem_anchor_token(')');
- expect(')');
-
-end_error:
return (construct_type_t*) construct_function_type;
}
+static void fix_declaration_type(declaration_t *declaration)
+{
+ decl_modifiers_t declaration_modifiers = declaration->modifiers;
+ type_modifiers_t type_modifiers = declaration->type->base.modifiers;
+
+ if (declaration_modifiers & DM_TRANSPARENT_UNION)
+ type_modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION;
+
+ if (declaration->type->base.modifiers == type_modifiers)
+ return;
+
+ type_t *copy = duplicate_type(declaration->type);
+ copy->base.modifiers = type_modifiers;
+
+ type_t *result = typehash_insert(copy);
+ if (result != copy) {
+ obstack_free(type_obst, copy);
+ }
+
+ declaration->type = result;
+}
+
static construct_type_t *parse_inner_declarator(declaration_t *declaration,
bool may_be_abstract)
{
construct_type_t *last = NULL;
gnu_attribute_t *attributes = NULL;
+ decl_modifiers_t modifiers = parse_attributes(&attributes);
+
/* pointers */
while(token.type == '*') {
construct_type_t *type = parse_pointer_declarator();
- if(last == NULL) {
+ if (last == NULL) {
first = type;
last = type;
} else {
last->next = type;
last = type;
}
- }
- /* TODO: find out if this is correct */
- parse_attributes(&attributes);
+ /* TODO: find out if this is correct */
+ modifiers |= parse_attributes(&attributes);
+ }
construct_type_t *inner_types = NULL;
switch(token.type) {
case T_IDENTIFIER:
- if(declaration == NULL) {
+ if (declaration == NULL) {
errorf(HERE, "no identifier expected in typename");
} else {
declaration->symbol = token.v.symbol;
expect(')');
break;
default:
- if(may_be_abstract)
+ if (may_be_abstract)
break;
- parse_error_expected("while parsing declarator", T_IDENTIFIER, '(', 0);
+ parse_error_expected("while parsing declarator", T_IDENTIFIER, '(', NULL);
/* avoid a loop in the outermost scope, because eat_statement doesn't
* eat '}' */
- if(token.type == '}' && current_function == NULL) {
+ if (token.type == '}' && current_function == NULL) {
next_token();
} else {
eat_statement();
}
/* insert in the middle of the list (behind p) */
- if(p != NULL) {
+ if (p != NULL) {
type->next = p->next;
p->next = type;
} else {
type->next = first;
first = type;
}
- if(last == p) {
+ if (last == p) {
last = type;
}
}
declarator_finished:
- parse_attributes(&attributes);
-
/* append inner_types at the end of the list, we don't to set last anymore
* as it's not needed anymore */
- if(last == NULL) {
+ if (last == NULL) {
assert(first == NULL);
first = inner_types;
} else {
return NULL;
}
+static void parse_declaration_attributes(declaration_t *declaration)
+{
+ gnu_attribute_t *attributes = NULL;
+ decl_modifiers_t modifiers = parse_attributes(&attributes);
+
+ if (declaration == NULL)
+ return;
+
+ declaration->modifiers |= modifiers;
+ /* check if we have these stupid mode attributes... */
+ type_t *old_type = declaration->type;
+ if (old_type == NULL)
+ return;
+
+ gnu_attribute_t *attribute = attributes;
+ for ( ; attribute != NULL; attribute = attribute->next) {
+ if (attribute->kind != GNU_AK_MODE || attribute->invalid)
+ continue;
+
+ atomic_type_kind_t akind = attribute->u.akind;
+ if (!is_type_signed(old_type)) {
+ switch(akind) {
+ case ATOMIC_TYPE_CHAR: akind = ATOMIC_TYPE_UCHAR; break;
+ case ATOMIC_TYPE_SHORT: akind = ATOMIC_TYPE_USHORT; break;
+ case ATOMIC_TYPE_INT: akind = ATOMIC_TYPE_UINT; break;
+ case ATOMIC_TYPE_LONGLONG: akind = ATOMIC_TYPE_ULONGLONG; break;
+ default:
+ panic("invalid akind in mode attribute");
+ }
+ }
+ declaration->type
+ = make_atomic_type(akind, old_type->base.qualifiers);
+ }
+}
+
static type_t *construct_declarator_type(construct_type_t *construct_list,
type_t *type)
{
type_t *array_type = allocate_type_zero(TYPE_ARRAY, &null_position);
expression_t *size_expression = parsed_array->size;
- if(size_expression != NULL) {
+ if (size_expression != NULL) {
size_expression
= create_implicit_cast(size_expression, type_size_t);
}
array_type->array.is_variable = parsed_array->is_variable;
array_type->array.size_expression = size_expression;
- if(size_expression != NULL) {
- if(is_constant_expression(size_expression)) {
+ if (size_expression != NULL) {
+ if (is_constant_expression(size_expression)) {
array_type->array.size_constant = true;
array_type->array.size
= fold_constant(size_expression);
}
type_t *hashed_type = typehash_insert(type);
- if(hashed_type != type) {
+ if (hashed_type != type) {
/* the function type was constructed earlier freeing it here will
* destroy other types... */
- if(iter->kind != CONSTRUCT_FUNCTION) {
+ if (iter->kind != CONSTRUCT_FUNCTION) {
free_type(type);
}
type = hashed_type;
{
declaration_t *const declaration = allocate_declaration_zero();
declaration->declared_storage_class = specifiers->declared_storage_class;
- declaration->modifiers = specifiers->decl_modifiers;
+ declaration->modifiers = specifiers->modifiers;
declaration->deprecated = specifiers->deprecated;
declaration->deprecated_string = specifiers->deprecated_string;
declaration->get_property_sym = specifiers->get_property_sym;
declaration->is_inline = specifiers->is_inline;
declaration->storage_class = specifiers->declared_storage_class;
- if(declaration->storage_class == STORAGE_CLASS_NONE
+ if (declaration->storage_class == STORAGE_CLASS_NONE
&& scope != global_scope) {
declaration->storage_class = STORAGE_CLASS_AUTO;
}
- if(specifiers->alignment != 0) {
+ if (specifiers->alignment != 0) {
/* TODO: add checks here */
declaration->alignment = specifiers->alignment;
}
type_t *const type = specifiers->type;
declaration->type = construct_declarator_type(construct_type, type);
- if(construct_type != NULL) {
+ parse_declaration_attributes(declaration);
+
+ fix_declaration_type(declaration);
+
+ if (construct_type != NULL) {
obstack_free(&temp_obst, construct_type);
}
construct_type_t *construct_type = parse_inner_declarator(NULL, 1);
type_t *result = construct_declarator_type(construct_type, base_type);
- if(construct_type != NULL) {
+ if (construct_type != NULL) {
obstack_free(&temp_obst, construct_type);
}
const symbol_t *const symbol = declaration->symbol;
const namespace_t namespc = (namespace_t)declaration->namespc;
+ assert(declaration->symbol != NULL);
+ declaration_t *previous_declaration = get_declaration(symbol, namespc);
+
type_t *const orig_type = declaration->type;
type_t *const type = skip_typeref(orig_type);
if (is_type_function(type) &&
type->function.unspecified_parameters &&
- warning.strict_prototypes) {
+ warning.strict_prototypes &&
+ previous_declaration == NULL) {
warningf(&declaration->source_position,
"function declaration '%#T' is not a prototype",
orig_type, declaration->symbol);
check_type_of_main(declaration, &type->function);
}
- assert(declaration->symbol != NULL);
- declaration_t *previous_declaration = get_declaration(symbol, namespc);
-
assert(declaration != previous_declaration);
- if (previous_declaration != NULL) {
- if (previous_declaration->parent_scope == scope) {
- /* can happen for K&R style declarations */
- if(previous_declaration->type == NULL) {
- previous_declaration->type = declaration->type;
+ if (previous_declaration != NULL
+ && previous_declaration->parent_scope == scope) {
+ /* can happen for K&R style declarations */
+ if (previous_declaration->type == NULL) {
+ previous_declaration->type = declaration->type;
+ }
+
+ const type_t *prev_type = skip_typeref(previous_declaration->type);
+ if (!types_compatible(type, prev_type)) {
+ errorf(&declaration->source_position,
+ "declaration '%#T' is incompatible with '%#T' (declared %P)",
+ orig_type, symbol, previous_declaration->type, symbol,
+ &previous_declaration->source_position);
+ } else {
+ unsigned old_storage_class = previous_declaration->storage_class;
+ if (old_storage_class == STORAGE_CLASS_ENUM_ENTRY) {
+ errorf(&declaration->source_position,
+ "redeclaration of enum entry '%Y' (declared %P)",
+ symbol, &previous_declaration->source_position);
+ return previous_declaration;
}
- const type_t *prev_type = skip_typeref(previous_declaration->type);
- if (!types_compatible(type, prev_type)) {
- errorf(&declaration->source_position,
- "declaration '%#T' is incompatible with '%#T' (declared %P)",
- orig_type, symbol, previous_declaration->type, symbol,
- &previous_declaration->source_position);
- } else {
- unsigned old_storage_class = previous_declaration->storage_class;
- if(old_storage_class == STORAGE_CLASS_ENUM_ENTRY) {
- errorf(&declaration->source_position,
- "redeclaration of enum entry '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
- return previous_declaration;
- }
+ unsigned new_storage_class = declaration->storage_class;
- unsigned new_storage_class = declaration->storage_class;
+ if (is_type_incomplete(prev_type)) {
+ previous_declaration->type = type;
+ prev_type = type;
+ }
- if(is_type_incomplete(prev_type)) {
+ /* pretend no storage class means extern for function
+ * declarations (except if the previous declaration is neither
+ * none nor extern) */
+ if (is_type_function(type)) {
+ if (prev_type->function.unspecified_parameters) {
previous_declaration->type = type;
prev_type = type;
}
- /* pretend no storage class means extern for function
- * declarations (except if the previous declaration is neither
- * none nor extern) */
- if (is_type_function(type)) {
- switch (old_storage_class) {
- case STORAGE_CLASS_NONE:
- old_storage_class = STORAGE_CLASS_EXTERN;
-
- case STORAGE_CLASS_EXTERN:
- if (is_function_definition) {
- if (warning.missing_prototypes &&
- prev_type->function.unspecified_parameters &&
- !is_sym_main(symbol)) {
- warningf(&declaration->source_position,
- "no previous prototype for '%#T'",
- orig_type, symbol);
- }
- } else if (new_storage_class == STORAGE_CLASS_NONE) {
- new_storage_class = STORAGE_CLASS_EXTERN;
- }
- break;
-
- default: break;
+ switch (old_storage_class) {
+ case STORAGE_CLASS_NONE:
+ old_storage_class = STORAGE_CLASS_EXTERN;
+ /* FALLTHROUGH */
+
+ case STORAGE_CLASS_EXTERN:
+ if (is_function_definition) {
+ if (warning.missing_prototypes &&
+ prev_type->function.unspecified_parameters &&
+ !is_sym_main(symbol)) {
+ warningf(&declaration->source_position,
+ "no previous prototype for '%#T'",
+ orig_type, symbol);
+ }
+ } else if (new_storage_class == STORAGE_CLASS_NONE) {
+ new_storage_class = STORAGE_CLASS_EXTERN;
}
+ break;
+
+ default:
+ break;
}
+ }
- if (old_storage_class == STORAGE_CLASS_EXTERN &&
- new_storage_class == STORAGE_CLASS_EXTERN) {
+ if (old_storage_class == STORAGE_CLASS_EXTERN &&
+ new_storage_class == STORAGE_CLASS_EXTERN) {
warn_redundant_declaration:
- if (warning.redundant_decls) {
- warningf(&declaration->source_position,
- "redundant declaration for '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
- }
- } else if (current_function == NULL) {
- if (old_storage_class != STORAGE_CLASS_STATIC &&
- new_storage_class == STORAGE_CLASS_STATIC) {
- errorf(&declaration->source_position,
- "static declaration of '%Y' follows non-static declaration (declared %P)",
- symbol, &previous_declaration->source_position);
- } else {
- if (old_storage_class != STORAGE_CLASS_EXTERN && !is_function_definition) {
- goto warn_redundant_declaration;
- }
- if (new_storage_class == STORAGE_CLASS_NONE) {
- previous_declaration->storage_class = STORAGE_CLASS_NONE;
- previous_declaration->declared_storage_class = STORAGE_CLASS_NONE;
- }
- }
- } else {
- if (old_storage_class == new_storage_class) {
- errorf(&declaration->source_position,
- "redeclaration of '%Y' (declared %P)",
- symbol, &previous_declaration->source_position);
- } else {
- errorf(&declaration->source_position,
- "redeclaration of '%Y' with different linkage (declared %P)",
- symbol, &previous_declaration->source_position);
- }
+ if (warning.redundant_decls && strcmp(previous_declaration->source_position.input_name, "<builtin>") != 0) {
+ warningf(&declaration->source_position,
+ "redundant declaration for '%Y' (declared %P)",
+ symbol, &previous_declaration->source_position);
+ }
+ } else if (current_function == NULL) {
+ if (old_storage_class != STORAGE_CLASS_STATIC &&
+ new_storage_class == STORAGE_CLASS_STATIC) {
+ errorf(&declaration->source_position,
+ "static declaration of '%Y' follows non-static declaration (declared %P)",
+ symbol, &previous_declaration->source_position);
+ } else if (old_storage_class != STORAGE_CLASS_EXTERN
+ && !is_function_definition) {
+ goto warn_redundant_declaration;
+ } else if (old_storage_class == STORAGE_CLASS_EXTERN) {
+ previous_declaration->storage_class = STORAGE_CLASS_NONE;
+ previous_declaration->declared_storage_class = STORAGE_CLASS_NONE;
}
+ } else if (old_storage_class == new_storage_class) {
+ errorf(&declaration->source_position,
+ "redeclaration of '%Y' (declared %P)",
+ symbol, &previous_declaration->source_position);
+ } else {
+ errorf(&declaration->source_position,
+ "redeclaration of '%Y' with different linkage (declared %P)",
+ symbol, &previous_declaration->source_position);
}
- return previous_declaration;
}
+
+ if (declaration->is_inline)
+ previous_declaration->is_inline = true;
+ return previous_declaration;
} else if (is_function_definition) {
if (declaration->storage_class != STORAGE_CLASS_STATIC) {
if (warning.missing_prototypes && !is_sym_main(symbol)) {
}
static bool is_declaration_specifier(const token_t *token,
- bool only_type_specifiers)
+ bool only_specifiers_qualifiers)
{
switch(token->type) {
TYPE_SPECIFIERS
+ TYPE_QUALIFIERS
return true;
case T_IDENTIFIER:
return is_typedef_symbol(token->v.symbol);
case T___extension__:
STORAGE_CLASSES
- TYPE_QUALIFIERS
- return !only_type_specifiers;
+ return !only_specifiers_qualifiers;
default:
return false;
type_t *orig_type = declaration->type;
type_t *type = skip_typeref(orig_type);
- if(declaration->init.initializer != NULL) {
+ if (declaration->init.initializer != NULL) {
parser_error_multiple_definition(declaration, HERE);
}
bool must_be_constant = false;
- if(declaration->storage_class == STORAGE_CLASS_STATIC
+ if (declaration->storage_class == STORAGE_CLASS_STATIC
|| declaration->storage_class == STORAGE_CLASS_THREAD_STATIC
|| declaration->parent_scope == global_scope) {
must_be_constant = true;
initializer_t *initializer = parse_initializer(&env);
- if(env.type != orig_type) {
+ if (env.type != orig_type) {
orig_type = env.type;
type = skip_typeref(orig_type);
declaration->type = env.type;
}
- if(is_type_function(type)) {
+ if (is_type_function(type)) {
errorf(&declaration->source_position,
"initializers not allowed for function types at declator '%Y' (type '%T')",
declaration->symbol, orig_type);
declaration->type = specifiers->type;
declaration->declared_storage_class = specifiers->declared_storage_class;
declaration->source_position = specifiers->source_position;
- declaration->modifiers = specifiers->decl_modifiers;
+ declaration->modifiers = specifiers->modifiers;
if (declaration->declared_storage_class != STORAGE_CLASS_NONE) {
warningf(&declaration->source_position,
"variable '%Y' declared 'inline'\n", declaration->symbol);
}
- if(token.type == '=') {
+ if (token.type == '=') {
parse_init_declarator_rest(declaration);
}
- if(token.type != ',')
+ if (token.type != ',')
break;
eat(',');
static declaration_t *finished_kr_declaration(declaration_t *declaration)
{
symbol_t *symbol = declaration->symbol;
- if(symbol == NULL) {
+ if (symbol == NULL) {
errorf(HERE, "anonymous declaration not valid as function parameter");
return declaration;
}
namespace_t namespc = (namespace_t) declaration->namespc;
- if(namespc != NAMESPACE_NORMAL) {
+ if (namespc != NAMESPACE_NORMAL) {
return record_declaration(declaration);
}
declaration_t *previous_declaration = get_declaration(symbol, namespc);
- if(previous_declaration == NULL ||
+ if (previous_declaration == NULL ||
previous_declaration->parent_scope != scope) {
errorf(HERE, "expected declaration of a function parameter, found '%Y'",
symbol);
return declaration;
}
- if(previous_declaration->type == NULL) {
+ if (previous_declaration->type == NULL) {
previous_declaration->type = declaration->type;
previous_declaration->declared_storage_class = declaration->declared_storage_class;
previous_declaration->storage_class = declaration->storage_class;
memset(&specifiers, 0, sizeof(specifiers));
parse_declaration_specifiers(&specifiers);
- if(token.type == ';') {
+ if (token.type == ';') {
parse_anonymous_declaration_rest(&specifiers, append_declaration);
} else {
declaration_t *declaration = parse_declarator(&specifiers, /*may_be_abstract=*/false);
}
}
-static void parse_kr_declaration_list(declaration_t *declaration)
+static type_t *get_default_promoted_type(type_t *orig_type)
{
- type_t *type = skip_typeref(declaration->type);
- if(!is_type_function(type))
- return;
+ type_t *result = orig_type;
- if(!type->function.kr_style_parameters)
- return;
+ type_t *type = skip_typeref(orig_type);
+ if (is_type_integer(type)) {
+ result = promote_integer(type);
+ } else if (type == type_float) {
+ result = type_double;
+ }
- /* push function parameters */
+ return result;
+}
+
+static void parse_kr_declaration_list(declaration_t *declaration)
+{
+ type_t *type = skip_typeref(declaration->type);
+ if (!is_type_function(type))
+ return;
+
+ if (!type->function.kr_style_parameters)
+ return;
+
+ /* push function parameters */
int top = environment_top();
scope_t *last_scope = scope;
set_scope(&declaration->scope);
declaration_t *parameter = declaration->scope.declarations;
- for( ; parameter != NULL; parameter = parameter->next) {
+ for ( ; parameter != NULL; parameter = parameter->next) {
assert(parameter->parent_scope == NULL);
parameter->parent_scope = scope;
environment_push(parameter);
}
/* parse declaration list */
- while(is_declaration_specifier(&token, false)) {
+ while (is_declaration_specifier(&token, false)) {
parse_declaration(finished_kr_declaration);
}
/* update function type */
type_t *new_type = duplicate_type(type);
- new_type->function.kr_style_parameters = false;
function_parameter_t *parameters = NULL;
function_parameter_t *last_parameter = NULL;
for( ; parameter_declaration != NULL;
parameter_declaration = parameter_declaration->next) {
type_t *parameter_type = parameter_declaration->type;
- if(parameter_type == NULL) {
+ if (parameter_type == NULL) {
if (strict_mode) {
errorf(HERE, "no type specified for function parameter '%Y'",
parameter_declaration->symbol);
semantic_parameter(parameter_declaration);
parameter_type = parameter_declaration->type;
+ /*
+ * we need the default promoted types for the function type
+ */
+ parameter_type = get_default_promoted_type(parameter_type);
+
function_parameter_t *function_parameter
= obstack_alloc(type_obst, sizeof(function_parameter[0]));
memset(function_parameter, 0, sizeof(function_parameter[0]));
function_parameter->type = parameter_type;
- if(last_parameter != NULL) {
+ if (last_parameter != NULL) {
last_parameter->next = function_parameter;
} else {
parameters = function_parameter;
}
last_parameter = function_parameter;
}
- new_type->function.parameters = parameters;
+
+ /* § 6.9.1.7: A K&R style parameter list does NOT act as a function
+ * prototype */
+ new_type->function.parameters = parameters;
+ new_type->function.unspecified_parameters = true;
type = typehash_insert(new_type);
- if(type != new_type) {
+ if (type != new_type) {
obstack_free(type_obst, new_type);
}
rem_anchor_token(';');
/* must be a declaration */
- if(token.type == ';') {
+ if (token.type == ';') {
parse_anonymous_declaration_rest(&specifiers, append_declaration);
return;
}
rem_anchor_token(';');
/* must be a declaration */
- if(token.type == ',' || token.type == '=' || token.type == ';') {
+ if (token.type == ',' || token.type == '=' || token.type == ';') {
parse_declaration_rest(ndeclaration, &specifiers, record_declaration);
return;
}
/* must be a function definition */
parse_kr_declaration_list(ndeclaration);
- if(token.type != '{') {
- parse_error_expected("while parsing function definition", '{', 0);
+ if (token.type != '{') {
+ parse_error_expected("while parsing function definition", '{', NULL);
eat_until_matching_token(';');
return;
}
/* note that we don't skip typerefs: the standard doesn't allow them here
* (so we can't use is_type_function here) */
- if(type->kind != TYPE_FUNCTION) {
+ if (type->kind != TYPE_FUNCTION) {
if (is_type_valid(type)) {
errorf(HERE, "declarator '%#T' has a body but is not a function type",
type, ndeclaration->symbol);
/* § 6.7.5.3 (14) a function definition with () means no
* parameters (and not unspecified parameters) */
- if(type->function.unspecified_parameters) {
+ if (type->function.unspecified_parameters
+ && type->function.parameters == NULL
+ && !type->function.kr_style_parameters) {
type_t *duplicate = duplicate_type(type);
duplicate->function.unspecified_parameters = false;
type = typehash_insert(duplicate);
- if(type != duplicate) {
+ if (type != duplicate) {
obstack_free(type_obst, duplicate);
}
ndeclaration->type = type;
}
declaration_t *const declaration = record_function_definition(ndeclaration);
- if(ndeclaration != declaration) {
+ if (ndeclaration != declaration) {
declaration->scope = ndeclaration->scope;
}
type = skip_typeref(declaration->type);
declaration_t *parameter = declaration->scope.declarations;
for( ; parameter != NULL; parameter = parameter->next) {
- if(parameter->parent_scope == &ndeclaration->scope) {
+ if (parameter->parent_scope == &ndeclaration->scope) {
parameter->parent_scope = scope;
}
assert(parameter->parent_scope == NULL
|| parameter->parent_scope == scope);
parameter->parent_scope = scope;
+ if (parameter->symbol == NULL) {
+ errorf(&ndeclaration->source_position, "parameter name omitted");
+ continue;
+ }
environment_push(parameter);
}
- if(declaration->init.statement != NULL) {
+ if (declaration->init.statement != NULL) {
parser_error_multiple_definition(declaration, HERE);
eat_block();
goto end_of_parse_external_declaration;
declaration_t *old_current_function = current_function;
current_function = declaration;
- declaration->init.statement = parse_compound_statement();
+ declaration->init.statement = parse_compound_statement(false);
first_err = true;
check_labels();
check_declarations();
environment_pop_to(top);
}
-static type_t *make_bitfield_type(type_t *base, expression_t *size,
+static type_t *make_bitfield_type(type_t *base_type, expression_t *size,
source_position_t *source_position)
{
- type_t *type = allocate_type_zero(TYPE_BITFIELD, source_position);
- type->bitfield.base = base;
- type->bitfield.size = size;
+ type_t *type = allocate_type_zero(TYPE_BITFIELD, source_position);
+
+ type->bitfield.base_type = base_type;
+ type->bitfield.size = size;
return type;
}
{
declaration_t *iter = compound_declaration->scope.declarations;
for( ; iter != NULL; iter = iter->next) {
- if(iter->namespc != NAMESPACE_NORMAL)
+ if (iter->namespc != NAMESPACE_NORMAL)
continue;
- if(iter->symbol == NULL) {
+ if (iter->symbol == NULL) {
type_t *type = skip_typeref(iter->type);
- if(is_type_compound(type)) {
+ if (is_type_compound(type)) {
declaration_t *result
= find_compound_entry(type->compound.declaration, symbol);
- if(result != NULL)
+ if (result != NULL)
return result;
}
continue;
}
- if(iter->symbol == symbol) {
+ if (iter->symbol == symbol) {
return iter;
}
}
const declaration_specifiers_t *specifiers)
{
declaration_t *last_declaration = struct_declaration->scope.declarations;
- if(last_declaration != NULL) {
+ if (last_declaration != NULL) {
while(last_declaration->next != NULL) {
last_declaration = last_declaration->next;
}
while(1) {
declaration_t *declaration;
- if(token.type == ':') {
+ if (token.type == ':') {
source_position_t source_position = *HERE;
next_token();
type_t *base_type = specifiers->type;
expression_t *size = parse_constant_expression();
- if(!is_type_integer(skip_typeref(base_type))) {
+ if (!is_type_integer(skip_typeref(base_type))) {
errorf(HERE, "bitfield base type '%T' is not an integer type",
base_type);
}
declaration->declared_storage_class = STORAGE_CLASS_NONE;
declaration->storage_class = STORAGE_CLASS_NONE;
declaration->source_position = source_position;
- declaration->modifiers = specifiers->decl_modifiers;
+ declaration->modifiers = specifiers->modifiers;
declaration->type = type;
} else {
declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
type_t *orig_type = declaration->type;
type_t *type = skip_typeref(orig_type);
- if(token.type == ':') {
+ if (token.type == ':') {
source_position_t source_position = *HERE;
next_token();
expression_t *size = parse_constant_expression();
- if(!is_type_integer(type)) {
+ if (!is_type_integer(type)) {
errorf(HERE, "bitfield base type '%T' is not an "
"integer type", orig_type);
}
} else {
/* TODO we ignore arrays for now... what is missing is a check
* that they're at the end of the struct */
- if(is_type_incomplete(type) && !is_type_array(type)) {
+ if (is_type_incomplete(type) && !is_type_array(type)) {
errorf(HERE,
"compound member '%Y' has incomplete type '%T'",
declaration->symbol, orig_type);
- } else if(is_type_function(type)) {
+ } else if (is_type_function(type)) {
errorf(HERE, "compound member '%Y' must not have function "
"type '%T'", declaration->symbol, orig_type);
}
/* make sure we don't define a symbol multiple times */
symbol_t *symbol = declaration->symbol;
- if(symbol != NULL) {
+ if (symbol != NULL) {
declaration_t *prev_decl
= find_compound_entry(struct_declaration, symbol);
- if(prev_decl != NULL) {
+ if (prev_decl != NULL) {
assert(prev_decl->symbol == symbol);
errorf(&declaration->source_position,
"multiple declarations of symbol '%Y' (declared %P)",
}
/* append declaration */
- if(last_declaration != NULL) {
+ if (last_declaration != NULL) {
last_declaration->next = declaration;
} else {
struct_declaration->scope.declarations = declaration;
}
last_declaration = declaration;
- if(token.type != ',')
+ if (token.type != ',')
break;
next_token();
}
}
rem_anchor_token('}');
- if(token.type == T_EOF) {
+ if (token.type == T_EOF) {
errorf(HERE, "EOF while parsing struct");
}
next_token();
declaration_specifiers_t specifiers;
memset(&specifiers, 0, sizeof(specifiers));
parse_declaration_specifiers(&specifiers);
- if(specifiers.declared_storage_class != STORAGE_CLASS_NONE) {
+ if (specifiers.declared_storage_class != STORAGE_CLASS_NONE) {
/* TODO: improve error message, user does probably not know what a
* storage class is...
*/
ntype->function.unspecified_parameters = true;
type_t *type = typehash_insert(ntype);
- if(type != ntype) {
+ if (type != ntype) {
free_type(ntype);
}
declaration->type = type;
declaration->symbol = symbol;
declaration->source_position = *source_position;
- declaration->parent_scope = global_scope;
- scope_t *old_scope = scope;
- set_scope(global_scope);
+ bool strict_prototypes_old = warning.strict_prototypes;
+ warning.strict_prototypes = false;
+ record_declaration(declaration);
+ warning.strict_prototypes = strict_prototypes_old;
- environment_push(declaration);
- /* prepends the declaration to the global declarations list */
- declaration->next = scope->declarations;
- scope->declarations = declaration;
+ return declaration;
+}
- assert(scope == global_scope);
- set_scope(old_scope);
+/**
+ * Creates a return_type (func)(argument_type) function type if not
+ * already exists.
+ */
+static type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
+ type_t *argument_type2)
+{
+ function_parameter_t *parameter2
+ = obstack_alloc(type_obst, sizeof(parameter2[0]));
+ memset(parameter2, 0, sizeof(parameter2[0]));
+ parameter2->type = argument_type2;
- return declaration;
+ function_parameter_t *parameter1
+ = obstack_alloc(type_obst, sizeof(parameter1[0]));
+ memset(parameter1, 0, sizeof(parameter1[0]));
+ parameter1->type = argument_type1;
+ parameter1->next = parameter2;
+
+ type_t *type = allocate_type_zero(TYPE_FUNCTION, &builtin_source_position);
+ type->function.return_type = return_type;
+ type->function.parameters = parameter1;
+
+ type_t *result = typehash_insert(type);
+ if (result != type) {
+ free_type(type);
+ }
+
+ return result;
}
/**
type->function.parameters = parameter;
type_t *result = typehash_insert(type);
- if(result != type) {
+ if (result != type) {
+ free_type(type);
+ }
+
+ return result;
+}
+
+static type_t *make_function_0_type(type_t *return_type)
+{
+ type_t *type = allocate_type_zero(TYPE_FUNCTION, &builtin_source_position);
+ type->function.return_type = return_type;
+ type->function.parameters = NULL;
+
+ type_t *result = typehash_insert(type);
+ if (result != type) {
free_type(type);
}
switch(symbol->ID) {
case T___builtin_alloca:
return make_function_1_type(type_void_ptr, type_size_t);
+ case T___builtin_huge_val:
+ return make_function_0_type(type_double);
case T___builtin_nan:
return make_function_1_type(type_double, type_char_ptr);
case T___builtin_nanf:
return make_function_1_type(type_long_double, type_char_ptr);
case T___builtin_va_end:
return make_function_1_type(type_void, type_valist);
+ case T___builtin_expect:
+ return make_function_2_type(type_long, type_long, type_long);
default:
internal_errorf(HERE, "not implemented builtin symbol found");
}
static type_t *automatic_type_conversion(type_t *orig_type)
{
type_t *type = skip_typeref(orig_type);
- if(is_type_array(type)) {
+ if (is_type_array(type)) {
array_type_t *array_type = &type->array;
type_t *element_type = array_type->element_type;
- unsigned qualifiers = array_type->type.qualifiers;
+ unsigned qualifiers = array_type->base.qualifiers;
return make_pointer_type(element_type, qualifiers);
}
- if(is_type_function(type)) {
+ if (is_type_function(type)) {
return make_pointer_type(orig_type, TYPE_QUALIFIER_NONE);
}
expression_t *expression = allocate_expression_zero(EXPR_REFERENCE);
reference_expression_t *ref = &expression->reference;
- ref->symbol = token.v.symbol;
+ symbol_t *const symbol = token.v.symbol;
- declaration_t *declaration = get_declaration(ref->symbol, NAMESPACE_NORMAL);
+ declaration_t *declaration = get_declaration(symbol, NAMESPACE_NORMAL);
source_position_t source_position = token.source_position;
next_token();
- if(declaration == NULL) {
+ if (declaration == NULL) {
if (! strict_mode && token.type == '(') {
/* an implicitly defined function */
if (warning.implicit_function_declaration) {
warningf(HERE, "implicit declaration of function '%Y'",
- ref->symbol);
+ symbol);
}
- declaration = create_implicit_function(ref->symbol,
+ declaration = create_implicit_function(symbol,
&source_position);
} else {
- errorf(HERE, "unknown symbol '%Y' found.", ref->symbol);
+ errorf(HERE, "unknown symbol '%Y' found.", symbol);
return create_invalid_expression();
}
}
declaration->used = true;
/* check for deprecated functions */
- if(declaration->deprecated != 0) {
+ if (declaration->deprecated != 0) {
const char *prefix = "";
if (is_type_function(declaration->type))
prefix = "function ";
rem_anchor_token(')');
expect(')');
- if(token.type == '{') {
+ if (token.type == '{') {
return parse_compound_literal(type);
}
{
expression_t *expression = allocate_expression_zero(EXPR_STATEMENT);
- statement_t *statement = parse_compound_statement();
+ statement_t *statement = parse_compound_statement(true);
expression->statement.statement = statement;
expression->base.source_position = statement->base.source_position;
TYPE_SPECIFIERS
return parse_cast();
case T_IDENTIFIER:
- if(is_typedef_symbol(token.v.symbol)) {
+ if (is_typedef_symbol(token.v.symbol)) {
return parse_cast();
}
}
designator_t *result = allocate_ast_zero(sizeof(result[0]));
result->source_position = *HERE;
- if(token.type != T_IDENTIFIER) {
+ if (token.type != T_IDENTIFIER) {
parse_error_expected("while parsing member designator",
- T_IDENTIFIER, 0);
+ T_IDENTIFIER, NULL);
return NULL;
}
result->symbol = token.v.symbol;
designator_t *last_designator = result;
while(true) {
- if(token.type == '.') {
+ if (token.type == '.') {
next_token();
- if(token.type != T_IDENTIFIER) {
+ if (token.type != T_IDENTIFIER) {
parse_error_expected("while parsing member designator",
- T_IDENTIFIER, 0);
+ T_IDENTIFIER, NULL);
return NULL;
}
designator_t *designator = allocate_ast_zero(sizeof(result[0]));
last_designator = designator;
continue;
}
- if(token.type == '[') {
+ if (token.type == '[') {
next_token();
add_anchor_token(']');
designator_t *designator = allocate_ast_zero(sizeof(result[0]));
designator->array_index = parse_expression();
rem_anchor_token(']');
expect(']');
- if(designator->array_index == NULL) {
+ if (designator->array_index == NULL) {
return NULL;
}
descend_into_subtype(&path);
- if(!walk_designator(&path, designator, true)) {
+ if (!walk_designator(&path, designator, true)) {
return create_invalid_expression();
}
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_right = skip_typeref(orig_type_right);
- if(!is_type_float(type_left) && !is_type_float(type_right)) {
+ if (!is_type_float(type_left) && !is_type_float(type_right)) {
if (is_type_valid(type_left) && is_type_valid(type_right)) {
type_error_incompatible("invalid operands in comparison",
&expression->base.source_position, orig_type_left, orig_type_right);
return create_invalid_expression();
}
+#if 0
/**
* Parses a __builtin_expect() expression.
*/
end_error:
return create_invalid_expression();
}
+#endif
/**
* Parses a MS assume() expression.
add_anchor_token(')');
add_anchor_token(',');
- if(token.type != ')') {
+ if (token.type != ')') {
while(true) {
(void)parse_assignment_expression();
- if(token.type != ',')
+ if (token.type != ',')
break;
next_token();
}
case T___builtin_offsetof: return parse_offsetof();
case T___builtin_va_start: return parse_va_start();
case T___builtin_va_arg: return parse_va_arg();
- case T___builtin_expect: return parse_builtin_expect();
+ case T___builtin_expect:
case T___builtin_alloca:
case T___builtin_nan:
case T___builtin_nand:
case T___builtin_nanf:
+ case T___builtin_huge_val:
case T___builtin_va_end: return parse_builtin_symbol();
case T___builtin_isgreater:
case T___builtin_isgreaterequal:
}
rem_anchor_token(']');
- if(token.type != ']') {
- parse_error_expected("Problem while parsing array access", ']', 0);
+ if (token.type != ']') {
+ parse_error_expected("Problem while parsing array access", ']', NULL);
return expression;
}
next_token();
return expression;
}
-static expression_t *parse_typeprop(expression_kind_t kind, unsigned precedence)
+static expression_t *parse_typeprop(expression_kind_t const kind,
+ source_position_t const pos,
+ unsigned const precedence)
{
expression_t *tp_expression = allocate_expression_zero(kind);
- tp_expression->base.type = type_size_t;
+ tp_expression->base.type = type_size_t;
+ tp_expression->base.source_position = pos;
- if(token.type == '(' && is_declaration_specifier(look_ahead(1), true)) {
+ char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof";
+
+ if (token.type == '(' && is_declaration_specifier(look_ahead(1), true)) {
next_token();
add_anchor_token(')');
- tp_expression->typeprop.type = parse_typename();
+ type_t* const orig_type = parse_typename();
+ tp_expression->typeprop.type = orig_type;
+
+ type_t const* const type = skip_typeref(orig_type);
+ char const* const wrong_type =
+ is_type_incomplete(type) ? "incomplete" :
+ type->kind == TYPE_FUNCTION ? "function designator" :
+ type->kind == TYPE_BITFIELD ? "bitfield" :
+ NULL;
+ if (wrong_type != NULL) {
+ errorf(&pos, "operand of %s expression must not be %s type '%T'",
+ what, wrong_type, type);
+ }
+
rem_anchor_token(')');
expect(')');
} else {
expression_t *expression = parse_sub_expression(precedence);
- expression->base.type = revert_automatic_type_conversion(expression);
+
+ type_t* const orig_type = revert_automatic_type_conversion(expression);
+ expression->base.type = orig_type;
+
+ type_t const* const type = skip_typeref(orig_type);
+ char const* const wrong_type =
+ is_type_incomplete(type) ? "incomplete" :
+ type->kind == TYPE_FUNCTION ? "function designator" :
+ type->kind == TYPE_BITFIELD ? "bitfield" :
+ NULL;
+ if (wrong_type != NULL) {
+ errorf(&pos, "operand of %s expression must not be expression of %s type '%T'", what, wrong_type, type);
+ }
tp_expression->typeprop.type = expression->base.type;
tp_expression->typeprop.tp_expression = expression;
static expression_t *parse_sizeof(unsigned precedence)
{
+ source_position_t pos = *HERE;
eat(T_sizeof);
- return parse_typeprop(EXPR_SIZEOF, precedence);
+ return parse_typeprop(EXPR_SIZEOF, pos, precedence);
}
static expression_t *parse_alignof(unsigned precedence)
{
+ source_position_t pos = *HERE;
eat(T___alignof__);
- return parse_typeprop(EXPR_SIZEOF, precedence);
+ return parse_typeprop(EXPR_ALIGNOF, pos, precedence);
}
static expression_t *parse_select_expression(unsigned precedence,
expression_t *select = allocate_expression_zero(EXPR_SELECT);
select->select.compound = compound;
- if(token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing select", T_IDENTIFIER, 0);
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing select", T_IDENTIFIER, NULL);
return select;
}
symbol_t *symbol = token.v.symbol;
type_t *const type = skip_typeref(orig_type);
type_t *type_left = type;
- if(is_pointer) {
+ if (is_pointer) {
if (!is_type_pointer(type)) {
if (is_type_valid(type)) {
errorf(HERE, "left hand side of '->' is not a pointer, but '%T'", orig_type);
declaration_t *const declaration = type_left->compound.declaration;
- if(!declaration->init.is_defined) {
+ if (!declaration->init.complete) {
errorf(HERE, "request for member '%Y' of incomplete type '%T'",
symbol, type_left);
return create_invalid_expression();
}
declaration_t *iter = find_compound_entry(declaration, symbol);
- if(iter == NULL) {
+ if (iter == NULL) {
errorf(HERE, "'%T' has no member named '%Y'", orig_type, symbol);
return create_invalid_expression();
}
select->select.compound_entry = iter;
select->base.type = expression_type;
- if(expression_type->kind == TYPE_BITFIELD) {
- expression_t *extract
- = allocate_expression_zero(EXPR_UNARY_BITFIELD_EXTRACT);
- extract->unary.value = select;
- extract->base.type = expression_type->bitfield.base;
-
- return extract;
+ type_t *skipped = skip_typeref(iter->type);
+ if (skipped->kind == TYPE_BITFIELD) {
+ select->base.type = skipped->bitfield.base_type;
}
return select;
}
+static void check_call_argument(const function_parameter_t *parameter,
+ call_argument_t *argument)
+{
+ type_t *expected_type = parameter->type;
+ type_t *expected_type_skip = skip_typeref(expected_type);
+ assign_error_t error = ASSIGN_ERROR_INCOMPATIBLE;
+ expression_t *arg_expr = argument->expression;
+
+ /* handle transparent union gnu extension */
+ if (is_type_union(expected_type_skip)
+ && (expected_type_skip->base.modifiers
+ & TYPE_MODIFIER_TRANSPARENT_UNION)) {
+ declaration_t *union_decl = expected_type_skip->compound.declaration;
+
+ declaration_t *declaration = union_decl->scope.declarations;
+ type_t *best_type = NULL;
+ for ( ; declaration != NULL; declaration = declaration->next) {
+ type_t *decl_type = declaration->type;
+ error = semantic_assign(decl_type, arg_expr);
+ if (error == ASSIGN_ERROR_INCOMPATIBLE
+ || error == ASSIGN_ERROR_POINTER_QUALIFIER_MISSING)
+ continue;
+
+ if (error == ASSIGN_SUCCESS) {
+ best_type = decl_type;
+ } else if (best_type == NULL) {
+ best_type = decl_type;
+ }
+ }
+
+ if (best_type != NULL) {
+ expected_type = best_type;
+ }
+ }
+
+ error = semantic_assign(expected_type, arg_expr);
+ argument->expression = create_implicit_cast(argument->expression,
+ expected_type);
+
+ /* TODO report exact scope in error messages (like "in 3rd parameter") */
+ report_assign_error(error, expected_type, arg_expr, "function call",
+ &arg_expr->base.source_position);
+}
+
/**
* Parse a call expression, ie. expression '( ... )'.
*
add_anchor_token(')');
add_anchor_token(',');
- if(token.type != ')') {
+ if (token.type != ')') {
call_argument_t *last_argument = NULL;
while(true) {
call_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
argument->expression = parse_assignment_expression();
- if(last_argument == NULL) {
+ if (last_argument == NULL) {
call->arguments = argument;
} else {
last_argument->next = argument;
}
last_argument = argument;
- if(token.type != ',')
+ if (token.type != ',')
break;
next_token();
}
rem_anchor_token(')');
expect(')');
- if(function_type != NULL) {
- function_parameter_t *parameter = function_type->parameters;
- call_argument_t *argument = call->arguments;
+ if (function_type == NULL)
+ return result;
+
+ function_parameter_t *parameter = function_type->parameters;
+ call_argument_t *argument = call->arguments;
+ if (!function_type->unspecified_parameters) {
for( ; parameter != NULL && argument != NULL;
parameter = parameter->next, argument = argument->next) {
- type_t *expected_type = parameter->type;
- /* TODO report scope in error messages */
- expression_t *const arg_expr = argument->expression;
- type_t *const res_type = semantic_assign(expected_type, arg_expr,
- "function call",
- &arg_expr->base.source_position);
- if (res_type == NULL) {
- /* TODO improve error message */
- errorf(&arg_expr->base.source_position,
- "Cannot call function with argument '%E' of type '%T' where type '%T' is expected",
- arg_expr, arg_expr->base.type, expected_type);
- } else {
- argument->expression = create_implicit_cast(argument->expression, expected_type);
- }
+ check_call_argument(parameter, argument);
}
- /* too few parameters */
- if(parameter != NULL) {
+
+ if (parameter != NULL) {
errorf(HERE, "too few arguments to function '%E'", expression);
- } else if(argument != NULL) {
- /* too many parameters */
- if(!function_type->variadic
- && !function_type->unspecified_parameters) {
- errorf(HERE, "too many arguments to function '%E'", expression);
- } else {
- /* do default promotion */
- for( ; argument != NULL; argument = argument->next) {
- type_t *type = argument->expression->base.type;
-
- type = skip_typeref(type);
- if(is_type_integer(type)) {
- type = promote_integer(type);
- } else if(type == type_float) {
- type = type_double;
- }
+ } else if (argument != NULL && !function_type->variadic) {
+ errorf(HERE, "too many arguments to function '%E'", expression);
+ }
+ }
- argument->expression
- = create_implicit_cast(argument->expression, type);
- }
+ /* do default promotion */
+ for( ; argument != NULL; argument = argument->next) {
+ type_t *type = argument->expression->base.type;
- check_format(&result->call);
- }
- } else {
- check_format(&result->call);
- }
+ type = get_default_promoted_type(type);
+
+ argument->expression
+ = create_implicit_cast(argument->expression, type);
}
+ check_format(&result->call);
+
return result;
end_error:
return create_invalid_expression();
/* 6.5.15.3 */
type_t *result_type;
- if(is_type_atomic(true_type, ATOMIC_TYPE_VOID) ||
+ if (is_type_atomic(true_type, ATOMIC_TYPE_VOID) ||
is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
if (!is_type_atomic(true_type, ATOMIC_TYPE_VOID)
|| !is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
type_t *pointer_type;
type_t *other_type;
expression_t *other_expression;
- if (is_type_pointer(true_type)) {
+ if (is_type_pointer(true_type) &&
+ (!is_type_pointer(false_type) || is_null_pointer_constant(false_expression))) {
pointer_type = true_type;
other_type = false_type;
other_expression = false_expression;
other_expression = true_expression;
}
- if(is_type_pointer(other_type)) {
- if(!pointers_compatible(true_type, false_type)) {
+ if (is_null_pointer_constant(other_expression)) {
+ result_type = pointer_type;
+ } else if (is_type_pointer(other_type)) {
+ type_t *to1 = skip_typeref(pointer_type->pointer.points_to);
+ type_t *to2 = skip_typeref(other_type->pointer.points_to);
+
+ type_t *to;
+ if (is_type_atomic(to1, ATOMIC_TYPE_VOID) ||
+ is_type_atomic(to2, ATOMIC_TYPE_VOID)) {
+ to = type_void;
+ } else if (types_compatible(get_unqualified_type(to1),
+ get_unqualified_type(to2))) {
+ to = to1;
+ } else {
warningf(&expression->base.source_position,
- "pointer types '%T' and '%T' in conditional expression are incompatible", true_type, false_type);
+ "pointer types '%T' and '%T' in conditional expression are incompatible",
+ true_type, false_type);
+ to = type_void;
}
- result_type = true_type;
- } else if(is_null_pointer_constant(other_expression)) {
- result_type = pointer_type;
- } else if(is_type_integer(other_type)) {
+
+ type_t *const copy = duplicate_type(to);
+ copy->base.qualifiers = to1->base.qualifiers | to2->base.qualifiers;
+
+ type_t *const type = typehash_insert(copy);
+ if (type != copy)
+ free_type(copy);
+
+ result_type = make_pointer_type(type, TYPE_QUALIFIER_NONE);
+ } else if (is_type_integer(other_type)) {
warningf(&expression->base.source_position,
"pointer/integer type mismatch in conditional expression ('%T' and '%T')", true_type, false_type);
result_type = pointer_type;
return create_invalid_expression();
}
+static void check_pointer_arithmetic(const source_position_t *source_position,
+ type_t *pointer_type,
+ type_t *orig_pointer_type)
+{
+ type_t *points_to = pointer_type->pointer.points_to;
+ points_to = skip_typeref(points_to);
+
+ if (is_type_incomplete(points_to) &&
+ (! (c_mode & _GNUC)
+ || !is_type_atomic(points_to, ATOMIC_TYPE_VOID))) {
+ errorf(source_position,
+ "arithmetic with pointer to incomplete type '%T' not allowed",
+ orig_pointer_type);
+ } else if (is_type_function(points_to)) {
+ errorf(source_position,
+ "arithmetic with pointer to function type '%T' not allowed",
+ orig_pointer_type);
+ }
+}
+
static void semantic_incdec(unary_expression_t *expression)
{
type_t *const orig_type = expression->value->base.type;
type_t *const type = skip_typeref(orig_type);
- /* TODO !is_type_real && !is_type_pointer */
- if(!is_type_arithmetic(type) && type->kind != TYPE_POINTER) {
- if (is_type_valid(type)) {
- /* TODO: improve error message */
- errorf(HERE, "operation needs an arithmetic or pointer type");
- }
- return;
+ if (is_type_pointer(type)) {
+ check_pointer_arithmetic(&expression->base.source_position,
+ type, orig_type);
+ } else if (!is_type_real(type) && is_type_valid(type)) {
+ /* TODO: improve error message */
+ errorf(HERE, "operation needs an arithmetic or pointer type");
}
-
expression->base.type = orig_type;
}
{
type_t *const orig_type = expression->value->base.type;
type_t *const type = skip_typeref(orig_type);
- if(!is_type_arithmetic(type)) {
+ if (!is_type_arithmetic(type)) {
if (is_type_valid(type)) {
/* TODO: improve error message */
errorf(HERE, "operation needs an arithmetic type");
{
type_t *const orig_type = expression->value->base.type;
type_t *const type = skip_typeref(orig_type);
- if(!is_type_pointer(type)) {
+ if (!is_type_pointer(type)) {
if (is_type_valid(type)) {
errorf(HERE, "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
}
expression->base.type = result_type;
}
+static void set_address_taken(expression_t *expression, bool may_be_register)
+{
+ if (expression->kind != EXPR_REFERENCE)
+ return;
+
+ declaration_t *const declaration = expression->reference.declaration;
+ /* happens for parse errors */
+ if (declaration == NULL)
+ return;
+
+ if (declaration->storage_class == STORAGE_CLASS_REGISTER && !may_be_register) {
+ errorf(&expression->base.source_position,
+ "address of register variable '%Y' requested",
+ declaration->symbol);
+ } else {
+ declaration->address_taken = 1;
+ }
+}
+
/**
* Check the semantic of the address taken expression.
*/
value->base.type = revert_automatic_type_conversion(value);
type_t *orig_type = value->base.type;
- if(!is_type_valid(orig_type))
+ if (!is_type_valid(orig_type))
return;
- if(value->kind == EXPR_REFERENCE) {
- declaration_t *const declaration = value->reference.declaration;
- if(declaration != NULL) {
- if (declaration->storage_class == STORAGE_CLASS_REGISTER) {
- errorf(&expression->base.source_position,
- "address of register variable '%Y' requested",
- declaration->symbol);
- }
- declaration->address_taken = 1;
- }
- }
+ set_address_taken(value, false);
expression->base.type = make_pointer_type(orig_type, TYPE_QUALIFIER_NONE);
}
/* TODO: handle complex + imaginary types */
/* § 6.3.1.8 Usual arithmetic conversions */
- if(type_left == type_long_double || type_right == type_long_double) {
+ if (type_left == type_long_double || type_right == type_long_double) {
return type_long_double;
- } else if(type_left == type_double || type_right == type_double) {
+ } else if (type_left == type_double || type_right == type_double) {
return type_double;
- } else if(type_left == type_float || type_right == type_float) {
+ } else if (type_left == type_float || type_right == type_float) {
return type_float;
}
type_right = promote_integer(type_right);
type_left = promote_integer(type_left);
- if(type_left == type_right)
+ if (type_left == type_right)
return type_left;
bool signed_left = is_type_signed(type_left);
bool signed_right = is_type_signed(type_right);
int rank_left = get_rank(type_left);
int rank_right = get_rank(type_right);
- if(rank_left < rank_right) {
- if(signed_left == signed_right || !signed_right) {
+ if (rank_left < rank_right) {
+ if (signed_left == signed_right || !signed_right) {
return type_right;
} else {
return type_left;
}
} else {
- if(signed_left == signed_right || !signed_left) {
+ if (signed_left == signed_right || !signed_left) {
return type_left;
} else {
return type_right;
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_right = skip_typeref(orig_type_right);
- if(!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
+ if (!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
errorf(HERE, "operation needs arithmetic types");
type_t * type_left = skip_typeref(orig_type_left);
type_t * type_right = skip_typeref(orig_type_right);
- if(!is_type_integer(type_left) || !is_type_integer(type_right)) {
+ if (!is_type_integer(type_left) || !is_type_integer(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
errorf(HERE, "operation needs integer types");
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_right = skip_typeref(orig_type_right);
- /* § 5.6.5 */
- if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+ /* § 6.5.6 */
+ if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
expression->left = create_implicit_cast(left, arithmetic_type);
expression->right = create_implicit_cast(right, arithmetic_type);
expression->base.type = arithmetic_type;
return;
- } else if(is_type_pointer(type_left) && is_type_integer(type_right)) {
+ } else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
+ check_pointer_arithmetic(&expression->base.source_position,
+ type_left, orig_type_left);
expression->base.type = type_left;
- } else if(is_type_pointer(type_right) && is_type_integer(type_left)) {
+ } else if (is_type_pointer(type_right) && is_type_integer(type_left)) {
+ check_pointer_arithmetic(&expression->base.source_position,
+ type_right, orig_type_right);
expression->base.type = type_right;
} else if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "invalid operands to binary + ('%T', '%T')", orig_type_left, orig_type_right);
+ errorf(&expression->base.source_position,
+ "invalid operands to binary + ('%T', '%T')",
+ orig_type_left, orig_type_right);
}
}
type_t *const type_right = skip_typeref(orig_type_right);
/* § 5.6.5 */
- if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+ if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
expression->left = create_implicit_cast(left, arithmetic_type);
expression->right = create_implicit_cast(right, arithmetic_type);
expression->base.type = arithmetic_type;
return;
- } else if(is_type_pointer(type_left) && is_type_integer(type_right)) {
+ } else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
+ check_pointer_arithmetic(&expression->base.source_position,
+ type_left, orig_type_left);
expression->base.type = type_left;
- } else if(is_type_pointer(type_left) && is_type_pointer(type_right)) {
- if(!pointers_compatible(type_left, type_right)) {
- errorf(HERE,
- "pointers to incompatible objects to binary '-' ('%T', '%T')",
+ } else if (is_type_pointer(type_left) && is_type_pointer(type_right)) {
+ type_t *const unqual_left = get_unqualified_type(skip_typeref(type_left->pointer.points_to));
+ type_t *const unqual_right = get_unqualified_type(skip_typeref(type_right->pointer.points_to));
+ if (!types_compatible(unqual_left, unqual_right)) {
+ errorf(&expression->base.source_position,
+ "subtracting pointers to incompatible types '%T' and '%T'",
orig_type_left, orig_type_right);
- } else {
- expression->base.type = type_ptrdiff_t;
+ } else if (!is_type_object(unqual_left)) {
+ if (is_type_atomic(unqual_left, ATOMIC_TYPE_VOID)) {
+ warningf(&expression->base.source_position,
+ "subtracting pointers to void");
+ } else {
+ errorf(&expression->base.source_position,
+ "subtracting pointers to non-object types '%T'",
+ orig_type_left);
+ }
}
+ expression->base.type = type_ptrdiff_t;
} else if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "invalid operands to binary '-' ('%T', '%T')",
+ errorf(HERE, "invalid operands of types '%T' and '%T' to binary '-'",
orig_type_left, orig_type_right);
}
}
type_t *type_right = skip_typeref(orig_type_right);
/* TODO non-arithmetic types */
- if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+ if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+ /* test for signed vs unsigned compares */
if (warning.sign_compare &&
(expression->base.kind != EXPR_BINARY_EQUAL &&
expression->base.kind != EXPR_BINARY_NOTEQUAL) &&
(is_type_signed(type_left) != is_type_signed(type_right))) {
+
+ /* check if 1 of the operands is a constant, in this case we just
+ * check wether we can safely represent the resulting constant in
+ * the type of the other operand. */
+ expression_t *const_expr = NULL;
+ expression_t *other_expr = NULL;
+
+ if (is_constant_expression(left)) {
+ const_expr = left;
+ other_expr = right;
+ } else if (is_constant_expression(right)) {
+ const_expr = right;
+ other_expr = left;
+ }
+
+ if (const_expr != NULL) {
+ type_t *other_type = skip_typeref(other_expr->base.type);
+ long val = fold_constant(const_expr);
+ /* TODO: check if val can be represented by other_type */
+ (void) other_type;
+ (void) val;
+ }
warningf(&expression->base.source_position,
"comparison between signed and unsigned");
}
expression->base.type = type_int;
}
+/**
+ * Checks if a compound type has constant fields.
+ */
+static bool has_const_fields(const compound_type_t *type)
+{
+ const scope_t *scope = &type->declaration->scope;
+ const declaration_t *declaration = scope->declarations;
+
+ for (; declaration != NULL; declaration = declaration->next) {
+ if (declaration->namespc != NAMESPACE_NORMAL)
+ continue;
+
+ const type_t *decl_type = skip_typeref(declaration->type);
+ if (decl_type->base.qualifiers & TYPE_QUALIFIER_CONST)
+ return true;
+ }
+ /* TODO */
+ return false;
+}
+
+static bool is_lvalue(const expression_t *expression)
+{
+ switch (expression->kind) {
+ case EXPR_REFERENCE:
+ case EXPR_ARRAY_ACCESS:
+ case EXPR_SELECT:
+ case EXPR_UNARY_DEREFERENCE:
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+static bool is_valid_assignment_lhs(expression_t const* const left)
+{
+ type_t *const orig_type_left = revert_automatic_type_conversion(left);
+ type_t *const type_left = skip_typeref(orig_type_left);
+
+ if (!is_lvalue(left)) {
+ errorf(HERE, "left hand side '%E' of assignment is not an lvalue",
+ left);
+ return false;
+ }
+
+ if (is_type_array(type_left)) {
+ errorf(HERE, "cannot assign to arrays ('%E')", left);
+ return false;
+ }
+ if (type_left->base.qualifiers & TYPE_QUALIFIER_CONST) {
+ errorf(HERE, "assignment to readonly location '%E' (type '%T')", left,
+ orig_type_left);
+ return false;
+ }
+ if (is_type_incomplete(type_left)) {
+ errorf(HERE, "left-hand side '%E' of assignment has incomplete type '%T'",
+ left, orig_type_left);
+ return false;
+ }
+ if (is_type_compound(type_left) && has_const_fields(&type_left->compound)) {
+ errorf(HERE, "cannot assign to '%E' because compound type '%T' has readonly fields",
+ left, orig_type_left);
+ return false;
+ }
+
+ return true;
+}
+
static void semantic_arithmetic_assign(binary_expression_t *expression)
{
expression_t *left = expression->left;
type_t *orig_type_left = left->base.type;
type_t *orig_type_right = right->base.type;
+ if (!is_valid_assignment_lhs(left))
+ return;
+
type_t *type_left = skip_typeref(orig_type_left);
type_t *type_right = skip_typeref(orig_type_right);
- if(!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
+ if (!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
errorf(HERE, "operation needs arithmetic types");
type_t *const type_left = skip_typeref(orig_type_left);
type_t *const type_right = skip_typeref(orig_type_right);
+ if (!is_valid_assignment_lhs(left))
+ return;
+
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
/* combined instructions are tricky. We can't create an implicit cast on
* the left side, because we need the uncasted form for the store.
expression->right = create_implicit_cast(right, arithmetic_type);
expression->base.type = type_left;
} else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
+ check_pointer_arithmetic(&expression->base.source_position,
+ type_left, orig_type_left);
expression->base.type = type_left;
} else if (is_type_valid(type_left) && is_type_valid(type_right)) {
errorf(HERE, "incompatible types '%T' and '%T' in assignment", orig_type_left, orig_type_right);
expression->base.type = type_int;
}
-/**
- * Checks if a compound type has constant fields.
- */
-static bool has_const_fields(const compound_type_t *type)
-{
- const scope_t *scope = &type->declaration->scope;
- const declaration_t *declaration = scope->declarations;
-
- for (; declaration != NULL; declaration = declaration->next) {
- if (declaration->namespc != NAMESPACE_NORMAL)
- continue;
-
- const type_t *decl_type = skip_typeref(declaration->type);
- if (decl_type->base.qualifiers & TYPE_QUALIFIER_CONST)
- return true;
- }
- /* TODO */
- return false;
-}
-
/**
* Check the semantic restrictions of a binary assign expression.
*/
type_t *type_left = revert_automatic_type_conversion(left);
type_left = skip_typeref(orig_type_left);
- /* must be a modifiable lvalue */
- if (is_type_array(type_left)) {
- errorf(HERE, "cannot assign to arrays ('%E')", left);
+ if (!is_valid_assignment_lhs(left))
return;
- }
- if(type_left->base.qualifiers & TYPE_QUALIFIER_CONST) {
- errorf(HERE, "assignment to readonly location '%E' (type '%T')", left,
- orig_type_left);
- return;
- }
- if(is_type_incomplete(type_left)) {
- errorf(HERE,
- "left-hand side of assignment '%E' has incomplete type '%T'",
- left, orig_type_left);
- return;
- }
- if(is_type_compound(type_left) && has_const_fields(&type_left->compound)) {
- errorf(HERE, "cannot assign to '%E' because compound type '%T' has readonly fields",
- left, orig_type_left);
- return;
- }
- type_t *const res_type = semantic_assign(orig_type_left, expression->right,
+ assign_error_t error = semantic_assign(orig_type_left, expression->right);
+ report_assign_error(error, orig_type_left, expression->right,
"assignment", &left->base.source_position);
- if (res_type == NULL) {
- errorf(&expression->base.source_position,
- "cannot assign to '%T' from '%T'",
- orig_type_left, expression->right->base.type);
- } else {
- expression->right = create_implicit_cast(expression->right, res_type);
- }
-
+ expression->right = create_implicit_cast(expression->right, orig_type_left);
expression->base.type = orig_type_left;
}
case EXPR_UNARY_CAST_IMPLICIT: return true;
case EXPR_UNARY_ASSUME: return true;
- case EXPR_UNARY_BITFIELD_EXTRACT: return false;
case EXPR_BINARY_ADD: return false;
case EXPR_BINARY_SUB: return false;
static expression_t *parse_sub_expression(unsigned precedence)
{
- if(token.type < 0) {
+ if (token.type < 0) {
return expected_expression_error();
}
source_position_t source_position = token.source_position;
expression_t *left;
- if(parser->parser != NULL) {
+ if (parser->parser != NULL) {
left = parser->parser(parser->precedence);
} else {
left = parse_primary_expression();
left->base.source_position = source_position;
while(true) {
- if(token.type < 0) {
+ if (token.type < 0) {
return expected_expression_error();
}
parser = &expression_parsers[token.type];
- if(parser->infix_parser == NULL)
+ if (parser->infix_parser == NULL)
break;
- if(parser->infix_precedence < precedence)
+ if (parser->infix_precedence < precedence)
break;
left = parser->infix_parser(parser->infix_precedence, left);
{
expression_parser_function_t *entry = &expression_parsers[token_type];
- if(entry->parser != NULL) {
+ if (entry->parser != NULL) {
diagnosticf("for token '%k'\n", (token_type_t)token_type);
panic("trying to register multiple expression parsers for a token");
}
{
expression_parser_function_t *entry = &expression_parsers[token_type];
- if(entry->infix_parser != NULL) {
+ if (entry->infix_parser != NULL) {
diagnosticf("for token '%k'\n", (token_type_t)token_type);
panic("trying to register multiple infix expression parsers for a "
"token");
register_infix_parser(parse_EXPR_UNARY_POSTFIX_DECREMENT,
T_MINUSMINUS, 30);
- register_infix_parser(parse_EXPR_BINARY_MUL, '*', 16);
- register_infix_parser(parse_EXPR_BINARY_DIV, '/', 16);
- register_infix_parser(parse_EXPR_BINARY_MOD, '%', 16);
- register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT, T_LESSLESS, 16);
- register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT, T_GREATERGREATER, 16);
- register_infix_parser(parse_EXPR_BINARY_ADD, '+', 15);
- register_infix_parser(parse_EXPR_BINARY_SUB, '-', 15);
+ register_infix_parser(parse_EXPR_BINARY_MUL, '*', 17);
+ register_infix_parser(parse_EXPR_BINARY_DIV, '/', 17);
+ register_infix_parser(parse_EXPR_BINARY_MOD, '%', 17);
+ register_infix_parser(parse_EXPR_BINARY_ADD, '+', 16);
+ register_infix_parser(parse_EXPR_BINARY_SUB, '-', 16);
+ register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT, T_LESSLESS, 15);
+ register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT, T_GREATERGREATER, 15);
register_infix_parser(parse_EXPR_BINARY_LESS, '<', 14);
register_infix_parser(parse_EXPR_BINARY_GREATER, '>', 14);
register_infix_parser(parse_EXPR_BINARY_LESSEQUAL, T_LESSEQUAL, 14);
}
/**
- * Parse a asm statement constraints specification.
+ * Parse a asm statement arguments specification.
*/
-static asm_constraint_t *parse_asm_constraints(void)
+static asm_argument_t *parse_asm_arguments(bool is_out)
{
- asm_constraint_t *result = NULL;
- asm_constraint_t *last = NULL;
+ asm_argument_t *result = NULL;
+ asm_argument_t *last = NULL;
- while(token.type == T_STRING_LITERAL || token.type == '[') {
- asm_constraint_t *constraint = allocate_ast_zero(sizeof(constraint[0]));
- memset(constraint, 0, sizeof(constraint[0]));
+ while (token.type == T_STRING_LITERAL || token.type == '[') {
+ asm_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
+ memset(argument, 0, sizeof(argument[0]));
- if(token.type == '[') {
+ if (token.type == '[') {
eat('[');
- if(token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing asm constraint",
- T_IDENTIFIER, 0);
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing asm argument",
+ T_IDENTIFIER, NULL);
return NULL;
}
- constraint->symbol = token.v.symbol;
+ argument->symbol = token.v.symbol;
expect(']');
}
- constraint->constraints = parse_string_literals();
+ argument->constraints = parse_string_literals();
expect('(');
- constraint->expression = parse_expression();
+ expression_t *expression = parse_expression();
+ argument->expression = expression;
+ if (is_out && !is_lvalue(expression)) {
+ errorf(&expression->base.source_position,
+ "asm output argument is not an lvalue");
+ }
expect(')');
- if(last != NULL) {
- last->next = constraint;
+ set_address_taken(expression, true);
+
+ if (last != NULL) {
+ last->next = argument;
} else {
- result = constraint;
+ result = argument;
}
- last = constraint;
+ last = argument;
- if(token.type != ',')
+ if (token.type != ',')
break;
eat(',');
}
asm_clobber_t *clobber = allocate_ast_zero(sizeof(clobber[0]));
clobber->clobber = parse_string_literals();
- if(last != NULL) {
+ if (last != NULL) {
last->next = clobber;
} else {
result = clobber;
}
last = clobber;
- if(token.type != ',')
+ if (token.type != ',')
break;
eat(',');
}
asm_statement_t *asm_statement = &statement->asms;
- if(token.type == T_volatile) {
+ if (token.type == T_volatile) {
next_token();
asm_statement->is_volatile = true;
}
add_anchor_token(':');
asm_statement->asm_text = parse_string_literals();
- if(token.type != ':') {
+ if (token.type != ':') {
rem_anchor_token(':');
goto end_of_asm;
}
eat(':');
- asm_statement->inputs = parse_asm_constraints();
- if(token.type != ':') {
+ asm_statement->outputs = parse_asm_arguments(true);
+ if (token.type != ':') {
rem_anchor_token(':');
goto end_of_asm;
}
eat(':');
- asm_statement->outputs = parse_asm_constraints();
- if(token.type != ':') {
+ asm_statement->inputs = parse_asm_arguments(false);
+ if (token.type != ':') {
rem_anchor_token(':');
goto end_of_asm;
}
assert(current_function != NULL);
/* if we found a label in the same function, then we already created the
* declaration */
- if(candidate != NULL
+ if (candidate != NULL
&& candidate->parent_scope == ¤t_function->scope) {
return candidate;
}
/* if source position is already set then the label is defined twice,
* otherwise it was just mentioned in a goto so far */
- if(label->source_position.input_name != NULL) {
+ if (label->source_position.input_name != NULL) {
errorf(HERE, "duplicate label '%Y' (declared %P)",
symbol, &label->source_position);
} else {
eat(':');
- if(token.type == '}') {
+ if (token.type == '}') {
/* TODO only warn? */
- if(false) {
+ if (false) {
warningf(HERE, "label at end of compound statement");
statement->label.statement = create_empty_statement();
} else {
statement->ifs.true_statement = parse_statement();
rem_anchor_token(T_else);
- if(token.type == T_else) {
+ if (token.type == T_else) {
next_token();
statement->ifs.false_statement = parse_statement();
}
statement->switchs.body = parse_statement();
current_switch = rem;
- if(warning.switch_default &&
+ if (warning.switch_default &&
find_default_label(&statement->switchs) == NULL) {
warningf(&statement->base.source_position, "switch has no default case");
}
expect('(');
add_anchor_token(')');
- if(token.type != ';') {
- if(is_declaration_specifier(&token, false)) {
+ if (token.type != ';') {
+ if (is_declaration_specifier(&token, false)) {
parse_declaration(record_declaration);
} else {
add_anchor_token(';');
expect(';');
}
- if(token.type != ';') {
+ if (token.type != ';') {
add_anchor_token(';');
statement->fors.condition = parse_expression();
rem_anchor_token(';');
}
expect(';');
- if(token.type != ')') {
+ if (token.type != ')') {
expression_t *const step = parse_expression();
statement->fors.step = step;
if (warning.unused_value && !expression_has_effect(step)) {
{
eat(T_goto);
- if(token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing goto", T_IDENTIFIER, 0);
+ if (token.type != T_IDENTIFIER) {
+ parse_error_expected("while parsing goto", T_IDENTIFIER, NULL);
eat_statement();
- return NULL;
+ goto end_error;
}
symbol_t *symbol = token.v.symbol;
next_token();
statement_t *statement;
if (current_loop == NULL) {
errorf(HERE, "continue statement not within loop");
- statement = NULL;
+ statement = create_invalid_statement();
} else {
statement = allocate_statement_zero(STATEMENT_CONTINUE);
statement_t *statement;
if (current_switch == NULL && current_loop == NULL) {
errorf(HERE, "break statement not within loop or switch");
- statement = NULL;
+ statement = create_invalid_statement();
} else {
statement = allocate_statement_zero(STATEMENT_BREAK);
return create_invalid_statement();
}
+/**
+ * Parse a __leave statement.
+ */
+static statement_t *parse_leave(void)
+{
+ statement_t *statement;
+ if (current_try == NULL) {
+ errorf(HERE, "__leave statement not within __try");
+ statement = create_invalid_statement();
+ } else {
+ statement = allocate_statement_zero(STATEMENT_LEAVE);
+
+ statement->base.source_position = token.source_position;
+ }
+
+ eat(T___leave);
+ expect(';');
+
+ return statement;
+end_error:
+ return create_invalid_statement();
+}
+
/**
* Check if a given declaration represents a local variable.
*/
case STORAGE_CLASS_AUTO:
case STORAGE_CLASS_REGISTER: {
const type_t *type = skip_typeref(declaration->type);
- if(is_type_function(type)) {
+ if (is_type_function(type)) {
return false;
} else {
return true;
* Check if a given declaration represents a variable.
*/
static bool is_var_declaration(const declaration_t *declaration) {
- if(declaration->storage_class == STORAGE_CLASS_TYPEDEF)
+ if (declaration->storage_class == STORAGE_CLASS_TYPEDEF)
return false;
const type_t *type = skip_typeref(declaration->type);
eat(T_return);
expression_t *return_value = NULL;
- if(token.type != ';') {
+ if (token.type != ';') {
return_value = parse_expression();
}
expect(';');
assert(is_type_function(func_type));
type_t *const return_type = skip_typeref(func_type->function.return_type);
- if(return_value != NULL) {
+ if (return_value != NULL) {
type_t *return_value_type = skip_typeref(return_value->base.type);
- if(is_type_atomic(return_type, ATOMIC_TYPE_VOID)
+ if (is_type_atomic(return_type, ATOMIC_TYPE_VOID)
&& !is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
warningf(&statement->base.source_position,
"'return' with a value, in function returning void");
return_value = NULL;
} else {
- type_t *const res_type = semantic_assign(return_type,
- return_value, "'return'", &statement->base.source_position);
- if (res_type == NULL) {
- errorf(&statement->base.source_position,
- "cannot return something of type '%T' in function returning '%T'",
- return_value->base.type, return_type);
- } else {
- return_value = create_implicit_cast(return_value, res_type);
- }
+ assign_error_t error = semantic_assign(return_type, return_value);
+ report_assign_error(error, return_type, return_value, "'return'",
+ &statement->base.source_position);
+ return_value = create_implicit_cast(return_value, return_type);
}
/* check for returning address of a local var */
- if (return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
+ if (return_value != NULL &&
+ return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
const expression_t *expression = return_value->unary.value;
if (is_local_variable(expression)) {
warningf(&statement->base.source_position,
}
}
} else {
- if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
+ if (!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
warningf(&statement->base.source_position,
"'return' without value, in function returning non-void");
}
declaration_t *before = last_declaration;
parse_declaration(record_declaration);
- if(before == NULL) {
+ if (before == NULL) {
statement->declaration.declarations_begin = scope->declarations;
} else {
statement->declaration.declarations_begin = before->next;
expression_t *const expr = parse_expression();
statement->expression.expression = expr;
- if (warning.unused_value && !expression_has_effect(expr)) {
- warningf(&expr->base.source_position, "statement has no effect");
- }
-
expect(';');
return statement;
return create_invalid_statement();
}
+/**
+ * Parse a microsoft __try { } __finally { } or
+ * __try{ } __except() { }
+ */
+static statement_t *parse_ms_try_statment(void) {
+ statement_t *statement = allocate_statement_zero(STATEMENT_MS_TRY);
+
+ statement->base.source_position = token.source_position;
+ eat(T___try);
+
+ ms_try_statement_t *rem = current_try;
+ current_try = &statement->ms_try;
+ statement->ms_try.try_statement = parse_compound_statement(false);
+ current_try = rem;
+
+ if (token.type == T___except) {
+ eat(T___except);
+ expect('(');
+ add_anchor_token(')');
+ expression_t *const expr = parse_expression();
+ type_t * type = skip_typeref(expr->base.type);
+ if (is_type_integer(type)) {
+ type = promote_integer(type);
+ } else if (is_type_valid(type)) {
+ errorf(&expr->base.source_position,
+ "__expect expression is not an integer, but '%T'", type);
+ type = type_error_type;
+ }
+ statement->ms_try.except_expression = create_implicit_cast(expr, type);
+ rem_anchor_token(')');
+ expect(')');
+ statement->ms_try.final_statement = parse_compound_statement(false);
+ } else if (token.type == T__finally) {
+ eat(T___finally);
+ statement->ms_try.final_statement = parse_compound_statement(false);
+ } else {
+ parse_error_expected("while parsing __try statement", T___except, T___finally, NULL);
+ return create_invalid_statement();
+ }
+ return statement;
+end_error:
+ return create_invalid_statement();
+}
+
/**
* Parse a statement.
+ * There's also parse_statement() which additionally checks for
+ * "statement has no effect" warnings
*/
-static statement_t *parse_statement(void)
+static statement_t *intern_parse_statement(void)
{
- statement_t *statement = NULL;
+ statement_t *statement = NULL;
/* declaration or statement */
add_anchor_token(';');
break;
case '{':
- statement = parse_compound_statement();
+ statement = parse_compound_statement(false);
break;
case T_if:
- statement = parse_if();
+ statement = parse_if ();
break;
case T_switch:
statement = parse_break();
break;
+ case T___leave:
+ statement = parse_leave();
+ break;
+
case T_return:
statement = parse_return();
break;
case ';':
- if(warning.empty_statement) {
+ if (warning.empty_statement) {
warningf(HERE, "statement is empty");
}
statement = create_empty_statement();
break;
case T_IDENTIFIER:
- if(look_ahead(1)->type == ':') {
+ if (look_ahead(1)->type == ':') {
statement = parse_label_statement();
break;
}
- if(is_typedef_symbol(token.v.symbol)) {
+ if (is_typedef_symbol(token.v.symbol)) {
statement = parse_declaration_statement();
break;
}
statement = parse_declaration_statement();
break;
+ case T___try:
+ statement = parse_ms_try_statment();
+ break;
+
default:
statement = parse_expression_statement();
break;
return statement;
}
+/**
+ * parse a statement and emits "statement has no effect" warning if needed
+ * (This is really a wrapper around intern_parse_statement with check for 1
+ * single warning. It is needed, because for statement expressions we have
+ * to avoid the warning on the last statement)
+ */
+static statement_t *parse_statement(void)
+{
+ statement_t *statement = intern_parse_statement();
+
+ if (statement->kind == STATEMENT_EXPRESSION && warning.unused_value) {
+ expression_t *expression = statement->expression.expression;
+ if (!expression_has_effect(expression)) {
+ warningf(&expression->base.source_position,
+ "statement has no effect");
+ }
+ }
+
+ return statement;
+}
+
/**
* Parse a compound statement.
*/
-static statement_t *parse_compound_statement(void)
+static statement_t *parse_compound_statement(bool inside_expression_statement)
{
statement_t *statement = allocate_statement_zero(STATEMENT_COMPOUND);
statement_t *last_statement = NULL;
while(token.type != '}' && token.type != T_EOF) {
- statement_t *sub_statement = parse_statement();
- if(is_invalid_statement(sub_statement)) {
+ statement_t *sub_statement = intern_parse_statement();
+ if (is_invalid_statement(sub_statement)) {
/* an error occurred. if we are at an anchor, return */
- if(at_anchor())
+ if (at_anchor())
goto end_error;
continue;
}
- if(last_statement != NULL) {
+ if (last_statement != NULL) {
last_statement->base.next = sub_statement;
} else {
statement->compound.statements = sub_statement;
last_statement = sub_statement;
}
- if(token.type == '}') {
+ if (token.type == '}') {
next_token();
} else {
errorf(&statement->base.source_position,
"end of file while looking for closing '}'");
}
+ /* look over all statements again to produce no effect warnings */
+ if (warning.unused_value) {
+ statement_t *sub_statement = statement->compound.statements;
+ for( ; sub_statement != NULL; sub_statement = sub_statement->base.next) {
+ if (sub_statement->kind != STATEMENT_EXPRESSION)
+ continue;
+ /* don't emit a warning for the last expression in an expression
+ * statement as it has always an effect */
+ if (inside_expression_statement && sub_statement->base.next == NULL)
+ continue;
+
+ expression_t *expression = sub_statement->expression.expression;
+ if (!expression_has_effect(expression)) {
+ warningf(&expression->base.source_position,
+ "statement has no effect");
+ }
+ }
+ }
+
end_error:
rem_anchor_token('}');
assert(scope == &statement->compound.scope);
return;
for (const declaration_t *decl = global_scope->declarations; decl != NULL; decl = decl->next) {
- if (decl->used || decl->storage_class != STORAGE_CLASS_STATIC)
+ if (decl->used ||
+ decl->modifiers & DM_USED ||
+ decl->storage_class != STORAGE_CLASS_STATIC)
continue;
type_t *const type = decl->type;
}
}
-/**
- * Parse a translation unit.
- */
-static translation_unit_t *parse_translation_unit(void)
+static void parse_global_asm(void)
{
- translation_unit_t *unit = allocate_ast_zero(sizeof(unit[0]));
+ eat(T_asm);
+ expect('(');
- assert(global_scope == NULL);
- global_scope = &unit->scope;
+ statement_t *statement = allocate_statement_zero(STATEMENT_ASM);
+ statement->base.source_position = token.source_position;
+ statement->asms.asm_text = parse_string_literals();
+ statement->base.next = unit->global_asm;
+ unit->global_asm = statement;
- assert(scope == NULL);
- set_scope(&unit->scope);
+ expect(')');
+ expect(';');
- initialize_builtin_types();
+end_error:;
+}
+/**
+ * Parse a translation unit.
+ */
+static void parse_translation_unit(void)
+{
while(token.type != T_EOF) {
- if (token.type == ';') {
- /* TODO error in strict mode */
- warningf(HERE, "stray ';' outside of function");
- next_token();
- } else {
- parse_external_declaration();
- }
- }
-
- assert(scope == &unit->scope);
- scope = NULL;
- last_declaration = NULL;
+ switch (token.type) {
+ case ';':
+ /* TODO error in strict mode */
+ warningf(HERE, "stray ';' outside of function");
+ next_token();
+ break;
- assert(global_scope == &unit->scope);
- check_unused_globals();
- global_scope = NULL;
+ case T_asm:
+ parse_global_asm();
+ break;
- return unit;
+ default:
+ parse_external_declaration();
+ break;
+ }
+ }
}
/**
*
* @return the translation unit or NULL if errors occurred.
*/
-translation_unit_t *parse(void)
+void start_parsing(void)
{
environment_stack = NEW_ARR_F(stack_entry_t, 0);
label_stack = NEW_ARR_F(stack_entry_t, 0);
type_set_output(stderr);
ast_set_output(stderr);
- lookahead_bufpos = 0;
- for(int i = 0; i < MAX_LOOKAHEAD + 2; ++i) {
- next_token();
- }
- translation_unit_t *unit = parse_translation_unit();
+ assert(unit == NULL);
+ unit = allocate_ast_zero(sizeof(unit[0]));
+
+ assert(global_scope == NULL);
+ global_scope = &unit->scope;
+
+ assert(scope == NULL);
+ set_scope(&unit->scope);
+
+ initialize_builtin_types();
+}
+
+translation_unit_t *finish_parsing(void)
+{
+ assert(scope == &unit->scope);
+ scope = NULL;
+ last_declaration = NULL;
+
+ assert(global_scope == &unit->scope);
+ check_unused_globals();
+ global_scope = NULL;
DEL_ARR_F(environment_stack);
DEL_ARR_F(label_stack);
- return unit;
+ translation_unit_t *result = unit;
+ unit = NULL;
+ return result;
+}
+
+void parse(void)
+{
+ lookahead_bufpos = 0;
+ for(int i = 0; i < MAX_LOOKAHEAD + 2; ++i) {
+ next_token();
+ }
+ parse_translation_unit();
}
/**
*/
void init_parser(void)
{
- if(c_mode & _MS) {
+ if (c_mode & _MS) {
/* add predefined symbols for extended-decl-modifier */
sym_align = symbol_table_insert("align");
sym_allocate = symbol_table_insert("allocate");
projects / cparser / blobdiff