X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=parser.c;h=7d9b3347762a90999398158718d0e5bf4fbc0460;hb=65dfc72272eeb6beba7d3a53ebd9a46488000c81;hp=c7d39db1192224a422ece3af72414c6203c09c61;hpb=220bd1d88703eede6a4891f3014708c8259b303e;p=cparser

diff --git a/parser.c b/parser.c
index c7d39db..7d9b334 100644
--- a/parser.c
+++ b/parser.c
@@ -39,15 +39,19 @@ struct declaration_specifiers_t {
 
 typedef declaration_t* (*parsed_declaration_func) (declaration_t *declaration);
 
-static token_t         token;
-static token_t         lookahead_buffer[MAX_LOOKAHEAD];
-static int             lookahead_bufpos;
-static stack_entry_t  *environment_stack = NULL;
-static stack_entry_t  *label_stack       = NULL;
-static context_t      *global_context    = NULL;
-static context_t      *context           = NULL;
-static declaration_t  *last_declaration  = NULL;
-static declaration_t  *current_function  = NULL;
+static token_t             token;
+static token_t             lookahead_buffer[MAX_LOOKAHEAD];
+static int                 lookahead_bufpos;
+static stack_entry_t      *environment_stack = NULL;
+static stack_entry_t      *label_stack       = NULL;
+static context_t          *global_context    = NULL;
+static context_t          *context           = NULL;
+static declaration_t      *last_declaration  = NULL;
+static declaration_t      *current_function  = NULL;
+static switch_statement_t *current_switch    = NULL;
+static statement_t        *current_loop      = NULL;
+static goto_statement_t   *goto_first        = NULL;
+static goto_statement_t   *goto_last         = NULL;
 static struct obstack  temp_obst;
 
 /** The current source position. */
@@ -2323,6 +2327,11 @@ static declaration_t *internal_record_declaration(
 	assert(declaration != previous_declaration);
 	if (previous_declaration != NULL
 			&& previous_declaration->parent_context == context) {
+		/* can happen for K&R style declarations */
+		if(previous_declaration->type == NULL) {
+			previous_declaration->type = declaration->type;
+		}
+
 		const type_t *const prev_type = skip_typeref(previous_declaration->type);
 		if (!types_compatible(type, prev_type)) {
 			errorf(declaration->source_position,
@@ -2558,11 +2567,32 @@ static void parse_declaration_rest(declaration_t *ndeclaration,
 
 static declaration_t *finished_kr_declaration(declaration_t *declaration)
 {
-	/* TODO: check that it was actually a parameter that gets a type */
+	symbol_t *symbol  = declaration->symbol;
+	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) {
+		return record_declaration(declaration);
+	}
 
-	/* we should have a declaration for the parameter in the current
-	 * scope */
-	return record_declaration(declaration);
+	declaration_t *previous_declaration = get_declaration(symbol, namespc);
+	if(previous_declaration == NULL ||
+			previous_declaration->parent_context != context) {
+		errorf(HERE, "expected declaration of a function parameter, found '%Y'",
+		       symbol);
+		return declaration;
+	}
+
+	if(previous_declaration->type == NULL) {
+		previous_declaration->type           = declaration->type;
+		previous_declaration->storage_class  = declaration->storage_class;
+		previous_declaration->parent_context = context;
+		return previous_declaration;
+	} else {
+		return record_declaration(declaration);
+	}
 }
 
 static void parse_declaration(parsed_declaration_func finished_declaration)
@@ -2658,6 +2688,31 @@ static void parse_kr_declaration_list(declaration_t *declaration)
 	declaration->type = type;
 }
 
+/**
+ * Check if all labels are defined in the current function.
+ */
+static void check_for_missing_labels(void)
+{
+	bool first_err = true;
+	for (const goto_statement_t *goto_statement = goto_first;
+	     goto_statement != NULL;
+	     goto_statement = goto_statement->next) {
+		 const declaration_t *label = goto_statement->label;
+
+		 if (label->source_position.input_name == NULL) {
+			 if (first_err) {
+				 first_err = false;
+				 diagnosticf("%s: In function '%Y':\n",
+					 current_function->source_position.input_name,
+					 current_function->symbol);
+			 }
+			 errorf(goto_statement->statement.source_position,
+				 "label '%Y' used but not defined", label->symbol);
+		 }
+	}
+	goto_first = goto_last = NULL;
+}
+
 static void parse_external_declaration(void)
 {
 	/* function-definitions and declarations both start with declaration
@@ -2699,7 +2754,8 @@ static void parse_external_declaration(void)
 	/* 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) {
-		errorf(HERE, "declarator '%#T' has a body but is not a function type", type, ndeclaration->symbol);
+		errorf(HERE, "declarator '%#T' has a body but is not a function type",
+		       type, ndeclaration->symbol);
 		eat_block();
 		return;
 	}
@@ -2730,7 +2786,11 @@ static void parse_external_declaration(void)
 
 	declaration_t *parameter = declaration->context.declarations;
 	for( ; parameter != NULL; parameter = parameter->next) {
-		assert(parameter->parent_context == NULL || parameter->parent_context == context);
+		if(parameter->parent_context == &ndeclaration->context) {
+			parameter->parent_context = context;
+		}
+		assert(parameter->parent_context == NULL
+				|| parameter->parent_context == context);
 		parameter->parent_context = context;
 		environment_push(parameter);
 	}
@@ -2746,6 +2806,7 @@ static void parse_external_declaration(void)
 		current_function                    = declaration;
 
 		declaration->init.statement = parse_compound_statement();
+		check_for_missing_labels();
 
 		assert(current_function == declaration);
 		current_function = old_current_function;
@@ -2952,10 +3013,17 @@ static declaration_t *create_implicit_function(symbol_t *symbol,
 	declaration->source_position = source_position;
 	declaration->parent_context  = global_context;
 
+	context_t *old_context = context;
+	set_context(global_context);
+
 	environment_push(declaration);
+	/* prepend the declaration to the global declarations list */
 	declaration->next     = context->declarations;
 	context->declarations = declaration;
 
+	assert(context == global_context);
+	set_context(old_context);
+
 	return declaration;
 }
 
@@ -4809,11 +4877,45 @@ static statement_t *parse_case_statement(void)
 	statement->case_label.expression = parse_expression();
 
 	expect(':');
+
+	if (! is_constant_expression(statement->case_label.expression)) {
+		errorf(statement->base.source_position,
+			"case label does not reduce to an integer constant");
+	} else {
+		/* TODO: check if the case label is already known */
+		if (current_switch != NULL) {
+			/* link all cases into the switch statement */
+			if (current_switch->last_case == NULL) {
+				current_switch->first_case =
+				current_switch->last_case  = &statement->case_label;
+			} else {
+				current_switch->last_case->next = &statement->case_label;
+			}
+		} else {
+			errorf(statement->base.source_position,
+				"case label not within a switch statement");
+		}
+	}
 	statement->case_label.label_statement = parse_statement();
 
 	return statement;
 }
 
+/**
+ * Finds an existing default label of a switch statement.
+ */
+static case_label_statement_t *
+find_default_label(const switch_statement_t *statement)
+{
+	for (case_label_statement_t *label = statement->first_case;
+	     label != NULL;
+		 label = label->next) {
+		if (label->expression == NULL)
+			return label;
+	}
+	return NULL;
+}
+
 /**
  * Parse a default statement.
  */
@@ -4826,6 +4928,25 @@ static statement_t *parse_default_statement(void)
 	statement->base.source_position = token.source_position;
 
 	expect(':');
+	if (current_switch != NULL) {
+		const case_label_statement_t *def_label = find_default_label(current_switch);
+		if (def_label != NULL) {
+			errorf(HERE, "multiple default labels in one switch");
+			errorf(def_label->statement.source_position,
+				"this is the first default label");
+		} else {
+			/* link all cases into the switch statement */
+			if (current_switch->last_case == NULL) {
+				current_switch->first_case =
+					current_switch->last_case  = &statement->case_label;
+			} else {
+				current_switch->last_case->next = &statement->case_label;
+			}
+		}
+	} else {
+		errorf(statement->base.source_position,
+			"'default' label not within a switch statement");
+	}
 	statement->label.label_statement = parse_statement();
 
 	return statement;
@@ -4935,11 +5056,24 @@ static statement_t *parse_switch(void)
 	type_t       *const type = promote_integer(skip_typeref(expr->base.datatype));
 	statement->expression = create_implicit_cast(expr, type);
 	expect(')');
+
+	switch_statement_t *rem = current_switch;
+	current_switch  = statement;
 	statement->body = parse_statement();
+	current_switch  = rem;
 
 	return (statement_t*) statement;
 }
 
+static statement_t *parse_loop_body(statement_t *const loop)
+{
+	statement_t *const rem = current_loop;
+	current_loop = loop;
+	statement_t *const body = parse_statement();
+	current_loop = rem;
+	return body;
+}
+
 /**
  * Parse a while statement.
  */
@@ -4954,7 +5088,8 @@ static statement_t *parse_while(void)
 	expect('(');
 	statement->condition = parse_expression();
 	expect(')');
-	statement->body = parse_statement();
+
+	statement->body = parse_loop_body((statement_t*)statement);
 
 	return (statement_t*) statement;
 }
@@ -4970,7 +5105,7 @@ static statement_t *parse_do(void)
 	statement->statement.kind            = STATEMENT_DO_WHILE;
 	statement->statement.source_position = token.source_position;
 
-	statement->body = parse_statement();
+	statement->body = parse_loop_body((statement_t*)statement);
 	expect(T_while);
 	expect('(');
 	statement->condition = parse_expression();
@@ -5016,7 +5151,7 @@ static statement_t *parse_for(void)
 		statement->step = parse_expression();
 	}
 	expect(')');
-	statement->body = parse_statement();
+	statement->body = parse_loop_body((statement_t*)statement);
 
 	assert(context == &statement->context);
 	set_context(last_context);
@@ -5049,6 +5184,13 @@ static statement_t *parse_goto(void)
 
 	statement->label = label;
 
+	/* remember the goto's in a list for later checking */
+	if (goto_last == NULL) {
+		goto_first = goto_last = statement;
+	} else {
+		goto_last->next = statement;
+	}
+
 	expect(';');
 
 	return (statement_t*) statement;
@@ -5059,14 +5201,20 @@ static statement_t *parse_goto(void)
  */
 static statement_t *parse_continue(void)
 {
+	statement_base_t *statement;
+	if (current_loop == NULL) {
+		errorf(HERE, "continue statement not within loop");
+		statement = NULL;
+	} else {
+		statement                  = allocate_ast_zero(sizeof(statement[0]));
+		statement->kind            = STATEMENT_CONTINUE;
+		statement->source_position = token.source_position;
+	}
+
 	eat(T_continue);
 	expect(';');
 
-	statement_t *statement          = allocate_ast_zero(sizeof(statement[0]));
-	statement->kind                 = STATEMENT_CONTINUE;
-	statement->base.source_position = token.source_position;
-
-	return statement;
+	return (statement_t*)statement;
 }
 
 /**
@@ -5074,14 +5222,20 @@ static statement_t *parse_continue(void)
  */
 static statement_t *parse_break(void)
 {
+	statement_base_t *statement;
+	if (current_switch == NULL && current_loop == NULL) {
+		errorf(HERE, "break statement not within loop or switch");
+		statement = NULL;
+	} else {
+		statement                  = allocate_ast_zero(sizeof(statement[0]));
+		statement->kind            = STATEMENT_BREAK;
+		statement->source_position = token.source_position;
+	}
+
 	eat(T_break);
 	expect(';');
 
-	statement_t *statement          = allocate_ast_zero(sizeof(statement[0]));
-	statement->kind                 = STATEMENT_BREAK;
-	statement->base.source_position = token.source_position;
-
-	return statement;
+	return (statement_t*)statement;
 }
 
 /**