Do not use reserved names as macro names and kill trailing whitespace.

mallon · mallon · commit 99737f3e9a3a · 2007-04-05T22:22:58.000Z
git-svn-id: svn+ssh://ssh.info.uni-karlsruhe.de/ben/matze/svnrepos/mlang/trunk@192 b442430d-8a1f-0410-8bd7-ec13687f2f42
diff --git a/Makefile b/Makefile
@@ -59,7 +59,7 @@ endif
 
 $(GOAL): build/adt $(OBJECTS)
 	@echo "===> LD $@"
-	$(Q)$(CC) $(OBJECTS) $(LFLAGS) -o $(GOAL) 
+	$(Q)$(CC) $(OBJECTS) $(LFLAGS) -o $(GOAL)
 
 build/adt:
 	@echo "===> MKDIR $@"
diff --git a/ast.c b/ast.c
@@ -40,7 +40,7 @@ void pop_environment(environment_t *environment)
 {
 	assert(top_environment == environment);
 	assert(environment->on_stack);
-	
+
 	/* remove from environment stack */
 	top_environment = environment->up;
 	top_environment->down = NULL;
diff --git a/ast2firm.c b/ast2firm.c
@@ -255,7 +255,7 @@ ir_node *variable_reference_to_firm(const reference_expression_t *ref)
 	ir_mode                          *mode     = get_ir_mode(variable->type);
 
 	value_numbers[variable->value_number] = variable;
-	
+
 	return get_value(variable->value_number, mode);
 }
 
@@ -272,7 +272,7 @@ ir_node *assign_expression_to_firm(const binary_expression_t *assign)
 	value_numbers[variable->value_number] = variable;
 
 	ir_node *val = expression_to_firm(right);
-	
+
 	set_value(variable->value_number, val);
 
 	return val;
@@ -413,7 +413,7 @@ ir_node *call_expression_to_firm(const call_expression_t *call)
 	assert(method->datatype->type == TYPE_METHOD);
 	method_type_t *method_type    = (method_type_t*) method->datatype;
 	ir_type       *ir_method_type = get_ir_type((type_t*) method_type);
-	
+
 	ir_node       *callee         = expression_to_firm(method);
 	int            n_parameters   = get_method_n_params(ir_method_type);
 	ir_node       *in[n_parameters];
@@ -644,4 +644,3 @@ void ast2firm(namespace_t *namespace)
 		entry = entry->next;
 	}
 }
-
diff --git a/ast2firm.h b/ast2firm.h
@@ -1,5 +1,5 @@
-#ifndef _AST2FIRM_H_
-#define _AST2FIRM_H_
+#ifndef AST2FIRM_H
+#define AST2FIRM_H
 
 #include "ast.h"
 
@@ -9,4 +9,3 @@ void initialize_firm(void);
 void exit_firm(void);
 
 #endif
-
diff --git a/ast_t.h b/ast_t.h
@@ -233,4 +233,3 @@ struct namespace_t {
 };
 
 #endif
-
diff --git a/config.h b/config.h
@@ -1,2 +1 @@
 #define INLINE inline
-
diff --git a/known_symbols.h b/known_symbols.h
@@ -1,5 +1,5 @@
-#ifndef _KNOWN_SYMBOLS_H_
-#define _KNOWN_SYMBOLS_H_
+#ifndef KNOWN_SYMBOLS_H
+#define KNOWN_SYMBOLS_H
 
 #include "token_t.h"
 #include "symbol_table.h"
@@ -15,5 +15,3 @@ enum TokenId {
 void put_known_symbols_into_symbol_table(symbol_table_t *symbol_table);
 
 #endif
-
-	
diff --git a/lexer.c b/lexer.c
@@ -108,7 +108,7 @@ void parse_number_hex(lexer_t *this, token_t *token)
 	}
 }
 
-static 
+static
 void parse_number_oct(lexer_t *this, token_t *token)
 {
 	int value = 0;
@@ -124,7 +124,7 @@ void parse_number_oct(lexer_t *this, token_t *token)
 	}
 }
 
-static 
+static
 void parse_number_dec(lexer_t *this, token_t *token)
 {
 	int value = 0;
@@ -415,4 +415,3 @@ void lexer_destroy(lexer_t *this)
 {
 	(void) this;
 }
-
diff --git a/lexer.h b/lexer.h
@@ -1,5 +1,5 @@
-#ifndef _LEXER_H_
-#define _LEXER_H_
+#ifndef LEXER_H
+#define LEXER_H
 
 #include "symbol_table_t.h"
 #include "token_t.h"
@@ -14,4 +14,3 @@ void lexer_destroy(lexer_t *lexer);
 token_t lexer_next_token(lexer_t *lexer);
 
 #endif
-
diff --git a/lexer_t.h b/lexer_t.h
@@ -22,4 +22,3 @@ struct lexer_t {
 };
 
 #endif
-
diff --git a/main.c b/main.c
@@ -55,4 +55,3 @@ int main(int argc, char **argv)
 
 	return 0;
 }
-
diff --git a/parser.c b/parser.c
@@ -345,7 +345,7 @@ expression_t *parse_call_expression(parser_env_t *env, expression_t *expression)
 		call_argument_t *last_argument = NULL;
 
 		while(1) {
-			call_argument_t *argument 
+			call_argument_t *argument
 				= obstack_alloc(&env->obst, sizeof(argument[0]));
 			memset(argument, 0, sizeof(argument[0]));
 
@@ -464,7 +464,7 @@ unsigned get_level(int c)
 	case T_LESSLESS:
 	case T_GREATERGREATER:
 		return 16;
-	
+
 	default:
 		return 0;
 	}
@@ -480,11 +480,11 @@ expression_t *parse_expression_prec(parser_env_t *env, unsigned level)
 		unsigned op_level = get_level(op);
 		if(op_level < level)
 			return left;
-		
+
 		next_token(env);
 		expression_t *right = parse_expression_prec(env, op_level + 1);
 
-		binary_expression_t *binexpr 
+		binary_expression_t *binexpr
 			= obstack_alloc(&env->obst, sizeof(binexpr[0]));
 		memset(binexpr, 0, sizeof(binexpr[0]));
 		binexpr->expression.type = EXPR_BINARY;
@@ -514,7 +514,7 @@ statement_t *parse_return_statement(parser_env_t *env)
 		obstack_alloc(&env->obst, sizeof(return_statement[0]));
 	memset(return_statement, 0, sizeof(return_statement[0]));
 
-	return_statement->statement.type = STATEMENT_RETURN;	
+	return_statement->statement.type = STATEMENT_RETURN;
 	next_token(env);
 
 	if(env->token.type != ';') {
@@ -591,7 +591,7 @@ statement_t *parse_variable_declaration(parser_env_t *env)
 	variable_declaration_statement_t *decl;
 
 	type_t                           *type = parse_type(env);
-	
+
 	while(1) {
 		decl = obstack_alloc(&env->obst, sizeof(decl[0]));
 		memset(decl, 0, sizeof(decl[0]));
@@ -673,7 +673,7 @@ statement_t *parse_statement(parser_env_t *env)
 			statement = parse_variable_declaration(env);
 			break;
 		}
-		
+
 		/* must be some expression starting with a variable reference */
 		expression_statement_t *expression_statement
 			= obstack_alloc(&env->obst, sizeof(expression_statement[0]));
@@ -760,7 +760,7 @@ void parse_parameter_declaration(parser_env_t *env,
 			type = parse_type(env);
 
 			if(parameter_types != NULL) {
-				method_parameter_type_t *param_type 
+				method_parameter_type_t *param_type
 					= obstack_alloc(&env->obst, sizeof(param_type[0]));
 				memset(param_type, 0, sizeof(param_type[0]));
 				param_type->type = type;
@@ -829,11 +829,11 @@ namespace_entry_t *parse_method_or_var(parser_env_t *env)
 
 		method_t *method = obstack_alloc(&env->obst, sizeof(method[0]));
 		memset(method, 0, sizeof(method[0]));
-		
+
 		method->namespace_entry.type = NAMESPACE_ENTRY_METHOD;
 		method->symbol               = symbol;
 
-		method_type_t *method_type 
+		method_type_t *method_type
 			= obstack_alloc(&env->obst, sizeof(method_type[0]));
 		memset(method_type, 0, sizeof(method_type[0]));
 
@@ -881,7 +881,7 @@ namespace_entry_t *parse_extern_method(parser_env_t *env)
 	const char              *abi_style   = NULL;
 	type_t                  *result_type;
 
-	extern_method_t *extern_method 
+	extern_method_t *extern_method
 		= obstack_alloc(&env->obst, sizeof(extern_method[0]));
 	memset(extern_method, 0, sizeof(extern_method[0]));
 
@@ -907,7 +907,7 @@ namespace_entry_t *parse_extern_method(parser_env_t *env)
 	extern_method->symbol = env->token.symbol;
 	next_token(env);
 
-	method_type_t *method_type 
+	method_type_t *method_type
 		= obstack_alloc(&env->obst, sizeof(method_type[0]));
 	memset(method_type, 0, sizeof(method_type[0]));
 
@@ -1008,4 +1008,3 @@ namespace_t *parse(FILE *in, const char *input_name)
 
 	return unit;
 }
-
diff --git a/parser.h b/parser.h
@@ -1,10 +1,9 @@
-#ifndef _PARSER_H_
-#define _PARSER_H_
+#ifndef PARSER_H
+#define PARSER_H
 
 #include <stdio.h>
 #include "ast.h"
 
 namespace_t *parse(FILE *in, const char *input_name);
 
 #endif
-
diff --git a/semantic.c b/semantic.c
@@ -51,7 +51,7 @@ struct semantic_env_t {
 static inline
 environment_entry_t *environment_push(semantic_env_t *env, symbol_t *symbol)
 {
-	environment_entry_t *entry 
+	environment_entry_t *entry
 		= obstack_alloc(&env->symbol_obstack, sizeof(entry[0]));
 	memset(entry, 0, sizeof(entry[0]));
 
@@ -127,7 +127,7 @@ void check_reference_expression(semantic_env_t *env,
 	variable_t                       *global_variable;
 	symbol_t                         *symbol = ref->symbol;
 	environment_entry_t              *entry  = symbol->thing;
-	
+
 	if(entry == NULL) {
 		fprintf(stderr, "Error: No known definition for '%s'\n", symbol->string);
 		env->found_errors = 1;
@@ -454,7 +454,7 @@ void check_expression_statement(semantic_env_t *env,
 		return;
 
 	int is_assign = 0;
-	if(expression->type == EXPR_BINARY && 
+	if(expression->type == EXPR_BINARY &&
 			((binary_expression_t*) expression)->binexpr_type == BINEXPR_ASSIGN)
 		is_assign = 1;
 
@@ -565,7 +565,7 @@ void check_namespace(semantic_env_t *env, namespace_t *namespace)
 		default:
 			break;
 		}
-		
+
 		entry = entry->next;
 	}
 
@@ -612,4 +612,3 @@ int check_static_semantic(namespace_t *namespace)
 
 	return !env.found_errors;
 }
-
diff --git a/semantic.h b/semantic.h
@@ -9,4 +9,3 @@ typedef struct environment_entry_t environment_entry_t;
 int check_static_semantic(namespace_t *namespace);
 
 #endif
-
diff --git a/symbol_table.c b/symbol_table.c
@@ -1,4 +1,4 @@
-#include <config.h> 
+#include <config.h>
 
 #include "symbol_table_t.h"
 #include "adt/hash_string.h"
@@ -62,4 +62,3 @@ void iter_test(symbol_table_t *this)
 		printf("Entry: '%s'\n", entry->string);
 	}
 }
-
diff --git a/symbol_table.h b/symbol_table.h
@@ -1,5 +1,5 @@
-#ifndef _SYMBOL_TABLE_H_
-#define _SYMBOL_TABLE_H_
+#ifndef SYMBOL_TABLE_H
+#define SYMBOL_TABLE_H
 
 #include "symbol.h"
 
@@ -8,4 +8,3 @@ typedef struct symbol_table_t symbol_table_t;
 symbol_t *symbol_table_insert(symbol_table_t *symbol_table, const char *symbol);
 
 #endif
-
diff --git a/symbol_table_t.h b/symbol_table_t.h
@@ -1,5 +1,5 @@
-#ifndef _SYMBOL_TABLE_T_H_
-#define _SYMBOL_TABLE_T_H_
+#ifndef SYMBOL_TABLE_T_H
+#define SYMBOL_TABLE_T_H
 
 #include "symbol_table.h"
 #include "adt/obst.h"
@@ -26,4 +26,3 @@ void symbol_table_init(symbol_table_t *symbol_table);
 void symbol_table_destroy(symbol_table_t *symbol_table);
 
 #endif
-
diff --git a/token.c b/token.c
@@ -11,7 +11,7 @@ void print_token_type(FILE *f, token_type_t token_type)
 	if(token_type >= 0 && token_type < 256) {
 		fprintf(f, "'%c'", token_type);
 		return;
-	} 
+	}
 
 	switch(token_type) {
 		case T_EQUALEQUAL:     fputs("'=='",            f); break;
diff --git a/token_t.h b/token_t.h
@@ -37,4 +37,3 @@ void print_token_type(FILE *out, token_type_t token_type);
 void print_token(FILE *out, const token_t *token);
 
 #endif
-
diff --git a/type_hash.c b/type_hash.c
@@ -177,4 +177,3 @@ type_t *typehash_insert(type_t *type)
 {
 	return _typehash_insert(&typehash, type);
 }
-
diff --git a/type_hash.h b/type_hash.h
@@ -9,4 +9,3 @@ void typehash_destroy(void);
 type_t *typehash_insert(type_t *type);
 
 #endif
-

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ void pop_environment(environment_t *environment)`
`40`	`40`	`{`
`41`	`41`	`assert(top_environment == environment);`
`42`	`42`	`assert(environment->on_stack);`
`43`		`-`
	`43`	`+`
`44`	`44`	`/* remove from environment stack */`
`45`	`45`	`top_environment = environment->up;`
`46`	`46`	`top_environment->down = NULL;`
Original file line number	Diff line number	Diff line change
`@@ -233,4 +233,3 @@ struct namespace_t {`
`233`	`233`	`};`
`234`	`234`
`235`	`235`	`#endif`
`236`		`-`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ void parse_number_hex(lexer_t this, token_t token)`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`-static`
	`111`	`+static`
`112`	`112`	`void parse_number_oct(lexer_t this, token_t token)`
`113`	`113`	`{`
`114`	`114`	`int value = 0;`
`@@ -124,7 +124,7 @@ void parse_number_oct(lexer_t this, token_t token)`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`-static`
	`127`	`+static`
`128`	`128`	`void parse_number_dec(lexer_t this, token_t token)`
`129`	`129`	`{`
`130`	`130`	`int value = 0;`
`@@ -415,4 +415,3 @@ void lexer_destroy(lexer_t *this)`
`415`	`415`	`{`
`416`	`416`	`(void) this;`
`417`	`417`	`}`
`418`		`-`
Original file line number	Diff line number	Diff line change
`@@ -22,4 +22,3 @@ struct lexer_t {`
`22`	`22`	`};`
`23`	`23`
`24`	`24`	`#endif`
`25`		`-`