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 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;
++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).
*/
/**
* Report a parse error because an expected token was not found.
*/
-static __attribute__((sentinel))
+static
+#if defined __GNUC__ && __GNUC__ >= 4
+__attribute__((sentinel))
+#endif
void parse_error_expected(const char *message, ...)
{
if(message != NULL) {
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; \
} \
[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",
attribute->have_arguments = false;
return attribute;
- return attribute;
}
/**
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(')');
+ expect(T_IDENTIFIER);
+ rem_anchor_token(')');
+ expect(')');
+ return;
+end_error:
+ attribute->invalid = true;
+}
+
/**
* parse one interrupt argument.
*/
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__);
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_MAY_ALIAS:
case GNU_AK_MS_STRUCT:
case GNU_AK_GCC_STRUCT:
+ check_no_argument(attribute, name);
+ break;
+
+ case GNU_AK_PURE:
+ check_no_argument(attribute, name);
+ modifiers |= DM_PURE;
+ break;
+
+ case GNU_AK_ALWAYS_INLINE:
+ check_no_argument(attribute, name);
+ modifiers |= DM_FORCEINLINE;
+ break;
+
case GNU_AK_DLLIMPORT:
+ check_no_argument(attribute, name);
+ modifiers |= DM_DLLIMPORT;
+ break;
+
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;
- }
+ check_no_argument(attribute, name);
+ modifiers |= DM_DLLEXPORT;
+ break;
+
+ case GNU_AK_PACKED:
+ check_no_argument(attribute, name);
+ modifiers |= DM_PACKED;
+ break;
+
+ case GNU_AK_NOINLINE:
+ check_no_argument(attribute, name);
+ modifiers |= DM_NOINLINE;
+ break;
+
+ case GNU_AK_NORETURN:
+ check_no_argument(attribute, name);
+ modifiers |= DM_NORETURN;
+ break;
+
+ case GNU_AK_NOTHROW:
+ check_no_argument(attribute, name);
+ modifiers |= DM_NOTHROW;
+ break;
+
+ case GNU_AK_TRANSPARENT_UNION:
+ check_no_argument(attribute, name);
+ modifiers |= DM_TRANSPARENT_UNION;
+ break;
+
+ case GNU_AK_CONSTRUCTOR:
+ check_no_argument(attribute, name);
+ modifiers |= DM_CONSTRUCTOR;
+ break;
+
+ case GNU_AK_DESTRUCTOR:
+ check_no_argument(attribute, name);
+ modifiers |= DM_DESTRUCTOR;
break;
case GNU_AK_ALIGNED:
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)
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);
+ modifiers |= parse_gnu_attribute(attributes);
break;
}
case T_asm:
attributes_finished:
end_error:
- return;
+ return modifiers;
}
static designator_t *parse_designation(void)
= 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;
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;
}
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;
+ gnu_attribute_t *attributes = NULL;
+ decl_modifiers_t modifiers = 0;
if(is_struct) {
eat(T_struct);
} else {
declaration_t *declaration = NULL;
if (token.type == T___attribute__) {
- parse_attributes(&attributes);
+ modifiers |= parse_attributes(&attributes);
}
if(token.type == T_IDENTIFIER) {
(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);
}
}
if(token.type == '{') {
- if(declaration->init.is_defined) {
+ if (declaration->init.complete) {
assert(symbol != NULL);
- errorf(HERE, "multiple definitions of '%s %Y'",
- is_struct ? "struct" : "union", symbol);
+ errorf(HERE, "multiple definitions of '%s %Y' (previous definition at %P)",
+ is_struct ? "struct" : "union", symbol,
+ &declaration->source_position);
declaration->scope.declarations = NULL;
}
- declaration->init.is_defined = true;
+ declaration->init.complete = true;
parse_compound_type_entries(declaration);
- parse_attributes(&attributes);
+ modifiers |= parse_attributes(&attributes);
}
+ declaration->modifiers |= modifiers;
return declaration;
}
type->enumt.declaration = declaration;
if(token.type == '{') {
- if(declaration->init.is_defined) {
+ 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);
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) {
case T__forceinline:
/* only in microsoft mode */
- specifiers->decl_modifiers |= DM_FORCEINLINE;
+ specifiers->modifiers |= DM_FORCEINLINE;
case T_inline:
next_token();
break;
case T___attribute__:
- parse_attributes(&specifiers->gnu_attributes);
+ specifiers->modifiers
+ |= parse_attributes(&specifiers->gnu_attributes);
break;
case T_IDENTIFIER: {
}
last_declaration = declaration;
- if(token.type != ',')
+ if (token.type != ',') {
break;
+ }
next_token();
} while(token.type == T_IDENTIFIER);
static declaration_t *parse_parameters(function_type_t *type)
{
+ 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)) {
type->kr_style_parameters = true;
- return parse_identifier_list();
+ declarations = parse_identifier_list();
+ goto parameters_finished;
}
}
if(token.type == ')') {
type->unspecified_parameters = 1;
- return NULL;
+ goto parameters_finished;
}
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__:
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 {
static construct_type_t *parse_function_declarator(declaration_t *declaration)
{
- eat('(');
- add_anchor_token(')');
-
type_t *type;
if(declaration != NULL) {
type = allocate_type_zero(TYPE_FUNCTION, &declaration->source_position);
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;
}
}
/* TODO: find out if this is correct */
- parse_attributes(&attributes);
+ decl_modifiers_t modifiers = parse_attributes(&attributes);
+ if (declaration != NULL)
+ declaration->modifiers |= modifiers;
construct_type_t *inner_types = NULL;
}
declarator_finished:
- parse_attributes(&attributes);
+ modifiers = parse_attributes(&attributes);
+ if (declaration != NULL)
+ declaration->modifiers |= modifiers;
/* append inner_types at the end of the list, we don't to set last anymore
* as it's not needed anymore */
{
declaration_t *const declaration = allocate_declaration_zero();
declaration->declared_storage_class = specifiers->declared_storage_class;
- declaration->decl_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;
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;
+
+ 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 (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);
}
- 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;
declaration->type = specifiers->type;
declaration->declared_storage_class = specifiers->declared_storage_class;
declaration->source_position = specifiers->source_position;
- declaration->decl_modifiers = specifiers->decl_modifiers;
+ declaration->modifiers = specifiers->modifiers;
if (declaration->declared_storage_class != STORAGE_CLASS_NONE) {
warningf(&declaration->source_position,
}
}
+static type_t *get_default_promoted_type(type_t *orig_type)
+{
+ type_t *result = orig_type;
+
+ type_t *type = skip_typeref(orig_type);
+ if(is_type_integer(type)) {
+ result = promote_integer(type);
+ } else if(type == type_float) {
+ result = type_double;
+ }
+
+ return result;
+}
+
static void parse_kr_declaration_list(declaration_t *declaration)
{
type_t *type = skip_typeref(declaration->type);
- if(!is_type_function(type))
+ if (!is_type_function(type))
return;
- if(!type->function.kr_style_parameters)
+ if (!type->function.kr_style_parameters)
return;
/* push function parameters */
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;
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]));
}
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) {
/* § 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;
declaration->declared_storage_class = STORAGE_CLASS_NONE;
declaration->storage_class = STORAGE_CLASS_NONE;
declaration->source_position = source_position;
- declaration->decl_modifiers = specifiers->decl_modifiers;
+ declaration->modifiers = specifiers->modifiers;
declaration->type = type;
} else {
declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
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);
- environment_push(declaration);
- /* prepends the declaration to the global declarations list */
- declaration->next = scope->declarations;
- scope->declarations = declaration;
-
- assert(scope == global_scope);
- set_scope(old_scope);
+ bool strict_prototypes_old = warning.strict_prototypes;
+ warning.strict_prototypes = false;
+ record_declaration(declaration);
+ warning.strict_prototypes = strict_prototypes_old;
return declaration;
}
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);
+ }
+
+ return result;
+}
+
/**
* Creates a function type for some function like builtins.
*
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:
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:
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) {
+ if (token.type != T_IDENTIFIER) {
parse_error_expected("while parsing select", T_IDENTIFIER, NULL);
return select;
}
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_type;
-
- return extract;
+ type_t *skipped = skip_typeref(iter->type);
+ if (skipped->kind == TYPE_BITFIELD) {
+ select->base.type = skipped->bitfield.base_type;
}
return select;
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);
+ "function call",
+ &arg_expr->base.source_position);
if (res_type == NULL) {
/* TODO improve error message */
errorf(&arg_expr->base.source_position,
argument->expression = create_implicit_cast(argument->expression, expected_type);
}
}
- /* 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();
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 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);
}
}
expression->base.type = arithmetic_type;
return;
} 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)) {
other_expr = left;
}
- type_t *other_type = skip_typeref(other_expr->base.type);
if(const_expr != NULL) {
- long val = fold_constant(const_expr);
+ 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;
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);
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);
- 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);
+ if (!is_valid_assignment_lhs(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,
"assignment", &left->base.source_position);
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;
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]));
+ asm_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
+ memset(argument, 0, sizeof(argument[0]));
if(token.type == '[') {
eat('[');
if(token.type != T_IDENTIFIER) {
- parse_error_expected("while parsing asm constraint",
+ 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();
+ argument->expression = parse_expression();
+ if (is_out && !is_lvalue(argument->expression)) {
+ errorf(&argument->expression->base.source_position,
+ "asm output argument is not an lvalue");
+ }
expect(')');
if(last != NULL) {
- last->next = constraint;
+ last->next = argument;
} else {
- result = constraint;
+ result = argument;
}
- last = constraint;
+ last = argument;
if(token.type != ',')
break;
}
eat(':');
- asm_statement->inputs = parse_asm_constraints();
+ asm_statement->outputs = parse_asm_arguments(true);
if(token.type != ':') {
rem_anchor_token(':');
goto end_of_asm;
}
eat(':');
- asm_statement->outputs = parse_asm_constraints();
+ asm_statement->inputs = parse_asm_arguments(false);
if(token.type != ':') {
rem_anchor_token(':');
goto end_of_asm;
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();
}
}
/* 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,
/**
* Parse a translation unit.
*/
-static translation_unit_t *parse_translation_unit(void)
+static void parse_translation_unit(void)
{
- translation_unit_t *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();
-
while(token.type != T_EOF) {
if (token.type == ';') {
/* TODO error in strict mode */
parse_external_declaration();
}
}
-
- assert(scope == &unit->scope);
- scope = NULL;
- last_declaration = NULL;
-
- assert(global_scope == &unit->scope);
- check_unused_globals();
- global_scope = NULL;
-
- return unit;
}
/**
*
* @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();
}
/**
projects / cparser / blobdiff