X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=2497541ca6e0648e93bdfbb0dcaafa935c73c7f1;hb=9d562f8239c1c0232c7254f53b78e2b74325e1a7;hp=7b4d0c1807c03c028ceb4d089779abf00ee9e5d5;hpb=5769a3764aafa57d0276ec23a2ae7044577047c3;p=cparser

diff --git a/main.c b/main.c
index 7b4d0c1..2497541 100644
--- a/main.c
+++ b/main.c
@@ -75,11 +75,16 @@
 #include "driver/firm_cmdline.h"
 #include "adt/error.h"
 #include "write_fluffy.h"
+#include "write_caml.h"
 #include "revision.h"
 #include "warning.h"
 
 #ifndef PREPROCESSOR
-#define PREPROCESSOR "cpp -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int -m32"
+#ifdef __APPLE__
+#define PREPROCESSOR "gcc -E -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int -U__SIZE_TYPE__ -D__SIZE_TYPE__=unsigned\\ long -m32 -U__STRICT_ANSI__"
+#else
+#define PREPROCESSOR "cpp -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int -U__SIZE_TYPE__ -D__SIZE_TYPE__=unsigned\\ long -m32 -U__STRICT_ANSI__"
+#endif
 #endif
 
 #ifndef LINKER
@@ -87,8 +92,12 @@
 #endif
 
 #ifndef ASSEMBLER
+#ifdef __APPLE__
+#define ASSEMBLER "gcc -c -xassembler"
+#else
 #define ASSEMBLER "as --32"
 #endif
+#endif
 
 /** The current c mode/dialect. */
 unsigned int c_mode = _C89|_C99|_GNUC;
@@ -102,19 +111,35 @@ bool char_is_signed = true;
 /** true for strict language checking. */
 bool strict_mode = false;
 
+/** use builtins for some libc functions */
+bool use_builtins = false;
+
 /* to switch on printing of implicit casts */
 extern bool print_implicit_casts;
 
 /* to switch on printing of parenthesis to indicate operator precedence */
 extern bool print_parenthesis;
 
-static int            verbose;
-static struct obstack cppflags_obst, ldflags_obst;
+static int             verbose;
+static struct obstack  cppflags_obst, ldflags_obst;
+static char            dep_target[1024];
+static const char     *outname;
 
 typedef struct file_list_entry_t file_list_entry_t;
 
+typedef enum filetype_t {
+	FILETYPE_AUTODETECT,
+	FILETYPE_C,
+	FILETYPE_PREPROCESSED_C,
+	FILETYPE_ASSEMBLER,
+	FILETYPE_PREPROCESSED_ASSEMBLER,
+	FILETYPE_OBJECT,
+	FILETYPE_UNKNOWN
+} filetype_t;
+
 struct file_list_entry_t {
-	const char        *filename;
+	const char        *name; /**< filename or NULL for stdin */
+	filetype_t         type;
 	file_list_entry_t *next;
 };
 
@@ -173,10 +198,21 @@ static void get_output_name(char *buf, size_t buflen, const char *inputname,
 	memcpy(buf+last_dot, newext, extlen);
 }
 
+#include "builtins.h"
+
 static translation_unit_t *do_parsing(FILE *const in, const char *const input_name)
 {
+	start_parsing();
+
+	if (use_builtins) {
+		lexer_open_buffer(builtins, sizeof(builtins)-1, "<builtin>");
+		parse();
+	}
+
 	lexer_open_stream(in, input_name);
-	translation_unit_t *unit = parse();
+	parse();
+
+	translation_unit_t *unit = finish_parsing();
 	return unit;
 }
 
@@ -191,50 +227,72 @@ static void lextest(FILE *in, const char *fname)
 	} while(lexer_token.type != T_EOF);
 }
 
-static FILE *preprocess(FILE *in, const char *fname, bool to_stdout)
+static void add_flag(struct obstack *obst, const char *format, ...)
 {
-	char buf[4096];
-	obstack_1grow(&cppflags_obst, '\0');
-	const char *flags = obstack_finish(&cppflags_obst);
-
-	if(in != stdin) {
-		snprintf(buf, sizeof(buf), PREPROCESSOR " %s %s", flags, fname);
-	} else {
-		/* read from stdin */
-		snprintf(buf, sizeof(buf), PREPROCESSOR " %s -", flags);
-	}
+	va_list ap;
+	va_start(ap, format);
 
-	if(verbose) {
-		puts(buf);
-	}
-	if(to_stdout) {
-		int res = system(buf);
-		exit(res);
-	} else {
-		FILE *f = popen(buf, "r");
-		if(f == NULL) {
-			fprintf(stderr, "invoking preprocessor failed\n");
-			exit(1);
+	char buf[4096];
+	vsnprintf(buf, sizeof(buf), format, ap);
+
+	/* escape stuff... */
+	obstack_1grow(obst, ' ');
+	for (char *c = buf; *c != '\0'; ++c) {
+		switch(*c) {
+		case '"':
+		case '\'':
+		case '`':
+		case ' ':
+		case '\t':
+		case '\n':
+		case '\r':
+		case '\\':
+		case '$':
+		case '(':
+		case ')':
+			obstack_1grow(obst, '\\');
+			/* fallthrough */
+		default:
+			obstack_1grow(obst, *c);
+			break;
 		}
-		return f;
 	}
+
+	va_end(ap);
 }
 
-static void do_link(const char *out, const char *in)
+static FILE *preprocess(const char *fname)
 {
-	char buf[4096];
-	obstack_1grow(&ldflags_obst, '\0');
-	const char *flags = obstack_finish(&ldflags_obst);
+	obstack_1grow(&cppflags_obst, '\0');
+	const char *flags = obstack_finish(&cppflags_obst);
+
+	obstack_printf(&cppflags_obst, "%s", PREPROCESSOR);
+	if (dep_target[0] != '\0') {
+		add_flag(&cppflags_obst, "-MF");
+		add_flag(&cppflags_obst, "%s", dep_target);
+		if (outname != NULL) {
+				add_flag(&cppflags_obst, "-MQ");
+				add_flag(&cppflags_obst, "%s", outname);
+		}
+	}
+	if (flags[0] != '\0') {
+		obstack_printf(&cppflags_obst, " %s", flags);
+	}
+	add_flag(&cppflags_obst, "%s", fname);
 
-	snprintf(buf, sizeof(buf), LINKER " %s -o %s %s", flags, out, in);
+	obstack_1grow(&cppflags_obst, '\0');
+	const char *buf = obstack_finish(&cppflags_obst);
 	if(verbose) {
 		puts(buf);
 	}
-	int err = system(buf);
-	if(err != 0) {
-		fprintf(stderr, "linker reported an error\n");
+
+	FILE *f = popen(buf, "r");
+	if(f == NULL) {
+		fprintf(stderr, "invoking preprocessor failed\n");
 		exit(1);
 	}
+
+	return f;
 }
 
 static void assemble(const char *out, const char *in)
@@ -304,19 +362,14 @@ static int mkstemp(char *templ)
 #endif
 
 /**
- * an own version of tmpnam, which: writes in a buffer, appends a user specified
- * suffix, emits no warnings during linking (like glibc/gnu ld do for tmpnam)...
+ * an own version of tmpnam, which: writes in a buffer, emits no warnings
+ * during linking (like glibc/gnu ld do for tmpnam)...
  */
-static FILE *make_temp_file(char *buffer, size_t buflen,
-                            const char *prefix, const char *suffix)
+static FILE *make_temp_file(char *buffer, size_t buflen, const char *prefix)
 {
 	const char *tempdir = get_tempdir();
 
-	/* oh well... mkstemp doesn't accept a suffix after XXXXXX... */
-	(void) suffix;
-	suffix = "";
-
-	snprintf(buffer, buflen, "%s/%sXXXXXX%s", tempdir, prefix, suffix);
+	snprintf(buffer, buflen, "%s/%sXXXXXX", tempdir, prefix);
 
 	int fd = mkstemp(buffer);
 	if(fd == -1) {
@@ -359,7 +412,7 @@ typedef enum compile_mode_t {
 	LexTest,
 	PrintAst,
 	PrintFluffy,
-	Link
+	PrintCaml
 } compile_mode_t;
 
 static void usage(const char *argv0)
@@ -384,20 +437,88 @@ static void print_cparser_version(void) {
 	puts(")\n");
 }
 
+static void set_be_option(const char *arg)
+{
+	int res = firm_be_option(arg);
+	(void) res;
+	assert(res);
+}
+
+static void set_option(const char *arg)
+{
+	int res = firm_option(arg);
+	(void) res;
+	assert(res);
+}
+
+static void copy_file(FILE *dest, FILE *input)
+{
+	char buf[16384];
+
+	while (!feof(input) && !ferror(dest)) {
+		size_t read = fread(buf, 1, sizeof(buf), input);
+		if(fwrite(buf, 1, read, dest) != read) {
+			perror("couldn't write output");
+		}
+	}
+}
+
+static inline bool streq(char const* a, char const* b)
+{
+	return strcmp(a, b) == 0;
+}
+
+static inline bool strstart(char const* str, char const* start)
+{
+	do {
+		if (*start == '\0')
+			return true;
+	} while (*str++ == *start++);
+	return false;
+}
+
+static FILE *open_file(const char *filename)
+{
+	if (streq(filename, "-")) {
+		return stdin;
+	}
+
+	FILE *in = fopen(filename, "r");
+	if(in == NULL) {
+		fprintf(stderr, "Couldn't open '%s': %s\n", filename,
+				strerror(errno));
+		exit(1);
+	}
+
+	return in;
+}
+
+static filetype_t get_filetype_from_string(const char *string)
+{
+	if (streq(string, "c") || streq(string, "c-header"))
+		return FILETYPE_C;
+	if (streq(string, "assembler"))
+		return FILETYPE_PREPROCESSED_ASSEMBLER;
+	if (streq(string, "assembler-with-cpp"))
+		return FILETYPE_ASSEMBLER;
+	if (streq(string, "none"))
+		return FILETYPE_AUTODETECT;
+
+	return FILETYPE_UNKNOWN;
+}
+
 int main(int argc, char **argv)
 {
 	initialize_firm();
 
-	const char        *input        = NULL;
-	const char        *outname      = NULL;
-	const char        *dumpfunction = NULL;
-	compile_mode_t     mode         = CompileAssembleLink;
-	int                opt_level    = 1;
-	int                result       = EXIT_SUCCESS;
-	char               cpu_arch[16] = "ia32";
-	file_list_entry_t *c_files      = NULL;
-	file_list_entry_t *s_files      = NULL;
-	file_list_entry_t *o_files      = NULL;
+	const char        *dumpfunction         = NULL;
+	compile_mode_t     mode                 = CompileAssembleLink;
+	int                opt_level            = 1;
+	int                result               = EXIT_SUCCESS;
+	char               cpu_arch[16]         = "ia32";
+	file_list_entry_t *files                = NULL;
+	file_list_entry_t *last_file            = NULL;
+	bool               construct_dep_target = false;
 	struct obstack     file_obst;
 
 	obstack_init(&cppflags_obst);
@@ -438,40 +559,47 @@ int main(int argc, char **argv)
 	/* apply optimisation level */
 	switch(opt_level) {
 	case 0:
-		firm_option("no-opt");
+		set_option("no-opt");
 		break;
 	case 1:
-		firm_option("no-inline");
+		set_option("no-inline");
 		break;
 	default:
 	case 4:
-		firm_option("strict-aliasing");
+		set_option("strict-aliasing");
 		/* fallthrough */
 	case 3:
-		firm_option("cond-eval");
-		firm_option("if-conv");
+		set_option("cond-eval");
+		set_option("if-conv");
+		use_builtins = true;
 		/* fallthrough */
 	case 2:
-		firm_option("inline");
-		firm_option("deconv");
-		firm_be_option("omitfp");
+		set_option("inline");
+		set_option("deconv");
+		set_be_option("omitfp");
 		break;
 	}
 
+#ifdef __APPLE__
+	/* Darwin expects the stack to be aligned to 16byte boundary */
+	firm_be_option("ia32-stackalign=4");
+#endif
+
 	/* parse rest of options */
-	bool help_displayed  = false;
-	bool argument_errors = false;
+	filetype_t  forced_filetype = FILETYPE_AUTODETECT;
+	bool        help_displayed  = false;
+	bool        argument_errors = false;
 	for(int i = 1; i < argc; ++i) {
 		const char *arg = argv[i];
-		if(arg[0] == '-') {
+		if(arg[0] == '-' && arg[1] != 0) {
 			/* an option */
 			const char *option = &arg[1];
 			if(option[0] == 'o') {
 				GET_ARG_AFTER(outname, "-o");
 			} else if(option[0] == 'g') {
-				firm_be_option("stabs=yes");
-				firm_be_option("omitfp=no");
-				firm_be_option("ia32-nooptcc=yes");
+				set_be_option("debuginfo=stabs");
+				set_be_option("omitfp=no");
+				set_be_option("ia32-nooptcc=yes");
 			} else if(SINGLE_OPTION('c')) {
 				mode = CompileAssemble;
 			} else if(SINGLE_OPTION('E')) {
@@ -483,49 +611,103 @@ int main(int argc, char **argv)
 			} else if(option[0] == 'I') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-I");
-				obstack_printf(&cppflags_obst, " -I%s", opt);
+				add_flag(&cppflags_obst, "-I%s", opt);
 			} else if(option[0] == 'D') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-D");
-				obstack_printf(&cppflags_obst, " -D%s", opt);
+				add_flag(&cppflags_obst, "-D%s", opt);
 			} else if(option[0] == 'U') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-U");
-				obstack_printf(&cppflags_obst, " -U%s", opt);
+				add_flag(&cppflags_obst, "-U%s", opt);
 			} else if(option[0] == 'l') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-l");
-				obstack_printf(&ldflags_obst, " -l%s", opt);
+				add_flag(&ldflags_obst, "-l%s", opt);
 			} else if(option[0] == 'L') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-L");
-				obstack_printf(&ldflags_obst, " -L%s", opt);
+				add_flag(&ldflags_obst, "-L%s", opt);
 			} else if(SINGLE_OPTION('v')) {
 				verbose = 1;
 			} else if(SINGLE_OPTION('w')) {
 				inhibit_all_warnings = true;
-			} else if(option[0] == 'f') {
+			} else if(option[0] == 'x') {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-x");
+				forced_filetype = get_filetype_from_string(opt);
+				if (forced_filetype == FILETYPE_UNKNOWN) {
+					fprintf(stderr, "Unknown language '%s'\n", opt);
+					argument_errors = true;
+				}
+			} else if (streq(option, "M")) {
+				mode = PreprocessOnly;
+				add_flag(&cppflags_obst, "-M");
+			} else if (streq(option, "MMD") ||
+			           streq(option, "MD")) {
+			    construct_dep_target = true;
+				add_flag(&cppflags_obst, "-%s", option);
+			} else if(streq(option, "MM")  ||
+			           streq(option, "MP")) {
+				add_flag(&cppflags_obst, "-%s", option);
+			} else if (streq(option, "MT") ||
+			           streq(option, "MQ") ||
+			           streq(option, "MF")) {
 				const char *opt;
-				GET_ARG_AFTER(opt, "-f");
-
-				if(strcmp(opt, "syntax-only") == 0) {
-					mode = ParseOnly;
-				} else if(strcmp(opt, "omit-frame-pointer") == 0) {
-					firm_be_option("omitfp");
-				} else if(strcmp(opt, "no-omit-frame-pointer") == 0) {
-					firm_be_option("omitfp=no");
+				GET_ARG_AFTER(opt, "-MT");
+				add_flag(&cppflags_obst, "-%s", option);
+				add_flag(&cppflags_obst, "%s", opt);
+			} else if (streq(option, "pipe")) {
+				/* here for gcc compatibility */
+			} else if (option[0] == 'f') {
+				char const *orig_opt;
+				GET_ARG_AFTER(orig_opt, "-f");
+
+				if (strstart(orig_opt, "align-loops=") ||
+				    strstart(orig_opt, "align-jumps=") ||
+				    strstart(orig_opt, "align-functions=")) {
+					fprintf(stderr, "ignoring gcc option '-f%s'\n", orig_opt);
 				} else {
-					int res = firm_option(opt);
-					if (res == 0) {
-						fprintf(stderr, "error: unknown Firm option '-f %s'\n",
-						        opt);
-						argument_errors = true;
-						continue;
-					} else if (res == -1) {
-						help_displayed = true;
+					char const *opt         = orig_opt;
+					bool        truth_value = true;
+					if (opt[0] == 'n' && opt[1] == 'o' && opt[2] == '-') {
+						truth_value = false;
+						opt += 3;
+					}
+
+					if (streq(opt, "dollars-in-identifiers")) {
+						allow_dollar_in_symbol = truth_value;
+					} else if (streq(opt, "short-wchar")) {
+						opt_short_wchar_t = truth_value;
+					} else if (streq(opt, "syntax-only")) {
+						mode = truth_value ? ParseOnly : CompileAssembleLink;
+					} else if (streq(opt, "omit-frame-pointer")) {
+						set_be_option(truth_value ? "omitfp" : "omitfp=no");
+					} else if (streq(opt, "strength-reduce")) {
+						firm_option(truth_value ? "strength-red" : "no-strength-red");
+					} else if (streq(opt, "fast-math")               ||
+					           streq(opt, "jump-tables")             ||
+					           streq(opt, "unroll-loops")            ||
+					           streq(opt, "expensive-optimizations") ||
+					           streq(opt, "common")                  ||
+					           streq(opt, "PIC")                     ||
+					           streq(opt, "align-loops")             ||
+					           streq(opt, "align-jumps")             ||
+					           streq(opt, "align-functions")) {
+						fprintf(stderr, "ignoring gcc option '-f%s'\n", orig_opt);
+					} else {
+						int res = firm_option(orig_opt);
+						if (res == 0) {
+							fprintf(stderr, "error: unknown Firm option '-f%s'\n",
+							        orig_opt);
+							argument_errors = true;
+							continue;
+						} else if (res == -1) {
+							help_displayed = true;
+						}
 					}
 				}
-			} else if(option[0] == 'b') {
+			} else if (option[0] == 'b') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-b");
 				int res = firm_be_option(opt);
@@ -535,19 +717,24 @@ int main(int argc, char **argv)
 					argument_errors = true;
 				} else if (res == -1) {
 					help_displayed = true;
-				} else {
-					if (strncmp(opt, "isa=", 4) == 0)
-						strncpy(cpu_arch, opt, sizeof(cpu_arch));
+				} else if (strstart(opt, "isa=")) {
+					strncpy(cpu_arch, opt, sizeof(cpu_arch));
+				}
+			} else if (option[0] == 'W') {
+				if (strstart(option + 1, "l,")) // a gcc-style linker option
+				{
+					const char *opt;
+					GET_ARG_AFTER(opt, "-Wl,");
+					add_flag(&ldflags_obst, "-Wl,%s", opt);
 				}
-			} else if(option[0] == 'W') {
-				set_warning_opt(&option[1]);
+				else set_warning_opt(&option[1]);
 			} else if(option[0] == 'm') {
 				/* -m options */
 				const char *opt;
 				char arch_opt[64];
 
 				GET_ARG_AFTER(opt, "-m");
-				if(strncmp(opt, "arch=", 5) == 0) {
+				if (strstart(opt, "arch=")) {
 					GET_ARG_AFTER(opt, "-march=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-arch=%s", cpu_arch, opt);
 					int res = firm_be_option(arch_opt);
@@ -559,23 +746,23 @@ int main(int argc, char **argv)
 						if (res == 0)
 							argument_errors = true;
 					}
-				} else if(strncmp(opt, "tune=", 5) == 0) {
+				} else if (strstart(opt, "tune=")) {
 					GET_ARG_AFTER(opt, "-mtune=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-opt=%s", cpu_arch, opt);
 					int res = firm_be_option(arch_opt);
 					if (res == 0)
 						argument_errors = true;
-				} else if(strncmp(opt, "cpu=", 4) == 0) {
+				} else if (strstart(opt, "cpu=")) {
 					GET_ARG_AFTER(opt, "-mcpu=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-arch=%s", cpu_arch, opt);
 					int res = firm_be_option(arch_opt);
 					if (res == 0)
 						argument_errors = true;
-				} else if(strncmp(opt, "fpmath=", 7) == 0) {
+				} else if (strstart(opt, "fpmath=")) {
 					GET_ARG_AFTER(opt, "-mfpmath=");
-					if(strcmp(opt, "387") == 0)
+					if (streq(opt, "387"))
 						opt = "x87";
-					else if(strcmp(opt, "sse") == 0)
+					else if (streq(opt, "sse"))
 						opt = "sse2";
 					else {
 						fprintf(stderr, "error: option -mfpumath supports only 387 or sse\n");
@@ -587,20 +774,16 @@ int main(int argc, char **argv)
 						if (res == 0)
 							argument_errors = true;
 					}
-				} else if(strncmp(opt, "preferred-stack-boundary=", 25) == 0) {
+				} else if (strstart(opt, "preferred-stack-boundary=")) {
 					GET_ARG_AFTER(opt, "-mpreferred-stack-boundary=");
 					snprintf(arch_opt, sizeof(arch_opt), "%s-stackalign=%s", cpu_arch, opt);
 					int res = firm_be_option(arch_opt);
 					if (res == 0)
 						argument_errors = true;
-				} else if(strcmp(opt, "omit-leaf-frame-pointer") == 0) {
-					int res = firm_be_option("omitleaffp=1");
-					if (res == 0)
-						argument_errors = true;
-				} else if(strcmp(opt, "no-omit-leaf-frame-pointer") == 0) {
-					int res = firm_be_option("omitleaffp=0");
-					if (res == 0)
-						argument_errors = true;
+				} else if (streq(opt, "omit-leaf-frame-pointer")) {
+					set_be_option("omitleaffp=1");
+				} else if (streq(opt, "no-omit-leaf-frame-pointer")) {
+					set_be_option("omitleaffp=0");
 				} else {
 					char *endptr;
 					long int value = strtol(opt, &endptr, 10);
@@ -615,64 +798,62 @@ int main(int argc, char **argv)
 						machine_size = (unsigned int)value;
 					}
 				}
-			} else if (option[0] == '\0') {
-				if(input != NULL) {
-					fprintf(stderr, "error: multiple input files specified\n");
-					argument_errors = true;
-				} else {
-					input = arg;
-				}
-			} else if(strcmp(option, "pg") == 0) {
-				firm_be_option("-b gprof");
-				obstack_printf(&ldflags_obst, " -pg");
-			} else if(strcmp(option, "pedantic") == 0) {
+			} else if (streq(option, "pg")) {
+				set_be_option("gprof");
+				add_flag(&ldflags_obst, "-pg");
+			} else if (streq(option, "pedantic") ||
+			           streq(option, "ansi")) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
-			} else if(strncmp(option, "std=", 4) == 0) {
-				if(strcmp(&option[4], "c99") == 0) {
+			} else if (streq(option, "shared")) {
+				add_flag(&ldflags_obst, "-shared");
+			} else if (strstart(option, "std=")) {
+				if (streq(&option[4], "c99")) {
 					c_mode = _C89|_C99;
-				} else if(strcmp(&option[4], "c89") == 0) {
+				} else if (streq(&option[4], "c89")) {
 					c_mode = _C89;
-				} else if(strcmp(&option[4], "gnu99") == 0) {
+				} else if (streq(&option[4], "gnu99")) {
 					c_mode = _C89|_C99|_GNUC;
-				} else if(strcmp(&option[4], "microsoft") == 0) {
+				} else if (streq(&option[4], "microsoft")) {
 					c_mode = _C89|_C99|_MS;
 				} else
 					fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
-			} else if(strcmp(option, "version") == 0) {
+			} else if (streq(option, "version")) {
 				print_cparser_version();
 			} else if (option[0] == '-') {
 				/* double dash option */
 				++option;
-				if(strcmp(option, "gcc") == 0) {
+				if (streq(option, "gcc")) {
 					c_mode |= _GNUC;
-				} else if(strcmp(option, "no-gcc") == 0) {
+				} else if (streq(option, "no-gcc")) {
 					c_mode &= ~_GNUC;
-				} else if(strcmp(option, "ms") == 0) {
+				} else if (streq(option, "ms")) {
 					c_mode |= _MS;
-				} else if(strcmp(option, "no-ms") == 0) {
+				} else if (streq(option, "no-ms")) {
 					c_mode &= ~_MS;
-				} else if(strcmp(option, "signed-chars") == 0) {
+				} else if (streq(option, "signed-chars")) {
 					char_is_signed = true;
-				} else if(strcmp(option, "unsigned-chars") == 0) {
+				} else if (streq(option, "unsigned-chars")) {
 					char_is_signed = false;
-				} else if(strcmp(option, "strict") == 0) {
+				} else if (streq(option, "strict")) {
 					strict_mode = true;
-				} else if(strcmp(option, "lextest") == 0) {
+				} else if (streq(option, "lextest")) {
 					mode = LexTest;
-				} else if(strcmp(option, "benchmark") == 0) {
+				} else if (streq(option, "benchmark")) {
 					mode = BenchmarkParser;
-				} else if(strcmp(option, "print-ast") == 0) {
+				} else if (streq(option, "print-ast")) {
 					mode = PrintAst;
-				} else if(strcmp(option, "print-implicit-cast") == 0) {
+				} else if (streq(option, "print-implicit-cast")) {
 					print_implicit_casts = true;
-				} else if(strcmp(option, "print-parenthesis") == 0) {
+				} else if (streq(option, "print-parenthesis")) {
 					print_parenthesis = true;
-				} else if(strcmp(option, "print-fluffy") == 0) {
+				} else if (streq(option, "print-fluffy")) {
 					mode = PrintFluffy;
-				} else if(strcmp(option, "version") == 0) {
+				} else if (streq(option, "print-caml")) {
+					mode = PrintCaml;
+				} else if (streq(option, "version")) {
 					print_cparser_version();
 					exit(EXIT_SUCCESS);
-				} else if(strcmp(option, "dump-function") == 0) {
+				} else if (streq(option, "dump-function")) {
 					++i;
 					if(i >= argc) {
 						fprintf(stderr, "error: "
@@ -691,43 +872,56 @@ int main(int argc, char **argv)
 				argument_errors = true;
 			}
 		} else {
+			filetype_t  type     = forced_filetype;
+			const char *filename = arg;
+			if (type == FILETYPE_AUTODETECT) {
+				size_t const len = strlen(arg);
+				if (len < 2 && arg[0] == '-') {
+					/* - implicitly means C source file */
+					type     = FILETYPE_C;
+					filename = NULL;
+				} else if (len > 2 && arg[len - 2] == '.') {
+					switch (arg[len - 1]) {
+					case 'c': type = FILETYPE_C;                      break;
+					case 'h': type = FILETYPE_C;                      break;
+					case 's': type = FILETYPE_PREPROCESSED_ASSEMBLER; break;
+					case 'S': type = FILETYPE_ASSEMBLER;              break;
+
+					case 'a':
+					case 'o': type = FILETYPE_OBJECT;                 break;
+					}
+				} else if (len > 3 && arg[len - 3] == '.') {
+					if (streq(arg + len - 2, "so")) {
+						type = FILETYPE_OBJECT;
+					}
+				}
 
-			size_t len = strlen(arg);
-			if (len < 2) {
-				fprintf(stderr, "'%s': file format not recognized\n", input);
-				continue;
+				if (type == FILETYPE_AUTODETECT) {
+					fprintf(stderr, "'%s': file format not recognized\n", arg);
+					continue;
+				}
 			}
 
 			file_list_entry_t *entry
 				= obstack_alloc(&file_obst, sizeof(entry[0]));
-			entry->filename = arg;
-			if (strcmp(arg+len-2, ".c") == 0) {
-				entry->next = c_files;
-				c_files     = entry;
-			} else if (strcmp(arg+len-2, ".s") == 0) {
-				entry->next = s_files;
-				s_files     = entry;
-			} else if (strcmp(arg+len-2, ".o") == 0) {
-				entry->next = o_files;
-				o_files     = entry;
+			memset(entry, 0, sizeof(entry[0]));
+			entry->name = arg;
+			entry->type = type;
+
+			if (last_file != NULL) {
+				last_file->next = entry;
 			} else {
-				fprintf(stderr, "'%s': file format not recognized\n", input);
+				files = entry;
 			}
+			last_file = entry;
 		}
 	}
 
-	if (c_files == NULL && s_files == NULL && o_files != NULL) {
-		mode = Link;
-	} else if (c_files != NULL && c_files->next == NULL) {
-		input = c_files->filename;
-	} else {
-		fprintf(stderr, "error: multiple input files specified\n");
+	if (files == NULL) {
+		fprintf(stderr, "error: no input files specified\n");
 		argument_errors = true;
 	}
 
-	/* we do the lowering in ast2firm */
-	firm_opt.lower_bitfields = FALSE;
-
 	if (help_displayed) {
 		return !argument_errors;
 	}
@@ -736,6 +930,9 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
+	/* we do the lowering in ast2firm */
+	firm_opt.lower_bitfields = FALSE;
+
 	gen_firm_init();
 	init_symbol_table();
 	init_tokens();
@@ -747,27 +944,37 @@ int main(int argc, char **argv)
 	init_parser();
 	init_ast2firm();
 
-	FILE *out = NULL;
-	char  outnamebuf[4096];
-	if(outname == NULL) {
+	if (construct_dep_target) {
+		if (outname != 0 && strlen(outname) >= 2) {
+			get_output_name(dep_target, sizeof(dep_target), outname, ".d");
+		} else {
+			get_output_name(dep_target, sizeof(dep_target), files->name, ".d");
+		}
+	} else {
+		dep_target[0] = '\0';
+	}
+
+	char outnamebuf[4096];
+	if (outname == NULL) {
+		const char *filename = files->name;
+
 		switch(mode) {
 		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
+		case PrintCaml:
 		case LexTest:
-			if(outname == NULL)
-				outname = "-";
-			break;
 		case PreprocessOnly:
+			outname = "-";
 			break;
 		case ParseOnly:
 			break;
 		case Compile:
-			get_output_name(outnamebuf, sizeof(outnamebuf), input, ".s");
+			get_output_name(outnamebuf, sizeof(outnamebuf), filename, ".s");
 			outname = outnamebuf;
 			break;
 		case CompileAssemble:
-			get_output_name(outnamebuf, sizeof(outnamebuf), input, ".o");
+			get_output_name(outnamebuf, sizeof(outnamebuf), filename, ".o");
 			outname = outnamebuf;
 			break;
 		case CompileDump:
@@ -775,13 +982,9 @@ int main(int argc, char **argv)
 			                ".vcg");
 			outname = outnamebuf;
 			break;
-		case Link:
 		case CompileAssembleLink:
 #ifdef _WIN32
-			/* Windows compiler typically derive the output name from
-			   the first source file */
-			get_output_name(outnamebuf, sizeof(outnamebuf), input, ".exe");
-			outname = outnamebuf;
+			outname = "a.exe";
 #else
 			outname = "a.out";
 #endif
@@ -789,168 +992,226 @@ int main(int argc, char **argv)
 		}
 	}
 
-	if (mode == Link) {
-		obstack_1grow(&ldflags_obst, '\0');
-		const char *flags = obstack_finish(&ldflags_obst);
-
-		obstack_printf(&file_obst, "%s", LINKER);
+	assert(outname != NULL);
 
-		for (file_list_entry_t *entry = o_files; entry != NULL;
-				entry = entry->next) {
-			obstack_printf(&file_obst, " %s", entry->filename);
+	FILE *out;
+	if (streq(outname, "-")) {
+		out = stdout;
+	} else {
+		out = fopen(outname, "w");
+		if(out == NULL) {
+			fprintf(stderr, "Couldn't open '%s' for writing: %s\n", outname,
+					strerror(errno));
+			return 1;
 		}
+	}
 
-		obstack_printf(&file_obst, " -o %s %s", outname, flags);
+	file_list_entry_t *file;
+	for (file = files; file != NULL; file = file->next) {
+		char        asm_tempfile[1024];
+		const char *filename = file->name;
+		filetype_t  filetype = file->type;
 
-		char *buf = obstack_finish(&file_obst);
+		if (file->type == FILETYPE_OBJECT)
+			continue;
 
-		if(verbose) {
-			puts(buf);
-		}
-		int err = system(buf);
-		if(err != 0) {
-			fprintf(stderr, "linker reported an error\n");
-			exit(1);
+		FILE *in = NULL;
+		if (mode == LexTest) {
+			if (in == NULL)
+				in = open_file(filename);
+			lextest(in, filename);
+			fclose(in);
+			exit(EXIT_SUCCESS);
 		}
-		return 0;
-	}
 
-	if(outname != NULL) {
-		if(strcmp(outname, "-") == 0) {
-			out = stdout;
-		} else {
-			out = fopen(outname, "w");
-			if(out == NULL) {
-				fprintf(stderr, "Couldn't open '%s' for writing: %s\n", outname,
-				        strerror(errno));
-				return 1;
+		FILE *preprocessed_in = NULL;
+		if (filetype == FILETYPE_C || filetype == FILETYPE_ASSEMBLER) {
+			/* no support for input on FILE* yet */
+			if (in != NULL)
+				panic("internal compiler error: in for preprocessor != NULL");
+
+			preprocessed_in = preprocess(filename);
+			if (mode == PreprocessOnly) {
+				copy_file(out, preprocessed_in);
+				int result = pclose(preprocessed_in);
+				fclose(out);
+				return result;
+			}
+
+			if (filetype == FILETYPE_C) {
+				filetype = FILETYPE_PREPROCESSED_C;
+			} else if (filetype == FILETYPE_ASSEMBLER) {
+				filetype = FILETYPE_PREPROCESSED_ASSEMBLER;
+			} else {
+				panic("internal compiler error: unknown filetype at preproc");
 			}
+
+			in = preprocessed_in;
 		}
-	}
 
-	FILE *in;
-	if(input == NULL) {
-		fprintf(stderr, "%s: no input files\n", argv[0]);
-		return 1;
-	} else if(strcmp(input, "-") == 0) {
-		in    = stdin;
-		input = "<stdin>";
-	} else {
-		in = fopen(input, "r");
-		if(in == NULL) {
-			fprintf(stderr, "Couldn't open '%s': %s\n", input, strerror(errno));
-			return 1;
+		FILE *asm_out;
+		if(mode == Compile) {
+			asm_out = out;
+		} else {
+			asm_out = make_temp_file(asm_tempfile, sizeof(asm_tempfile),
+			                         "ccs");
 		}
-	}
 
-	if(mode == LexTest) {
-		lextest(in, input);
-		fclose(in);
-		return 0;
-	}
+		if (in == NULL)
+			in = open_file(filename);
 
-	FILE *preprocessed_in = preprocess(in, input, mode == PreprocessOnly);
-	translation_unit_t *const unit = do_parsing(preprocessed_in, input);
-	int res = pclose(preprocessed_in);
-	if(res != 0) {
-		return res;
-	}
+		/* preprocess and compile */
+		if (filetype == FILETYPE_PREPROCESSED_C) {
+			translation_unit_t *const unit = do_parsing(in, filename);
+			if (in == preprocessed_in) {
+				int pp_result = pclose(preprocessed_in);
+				if (pp_result != EXIT_SUCCESS) {
+					exit(EXIT_FAILURE);
+				}
+			}
 
-	if(error_count > 0) {
-		/* parsing failed because of errors */
-		fprintf(stderr, "%u error(s), %u warning(s)\n", error_count, warning_count);
-		result = EXIT_FAILURE;
-	} else if(warning_count > 0) {
-		fprintf(stderr, "%u warning(s)\n", warning_count);
-	}
+			/* prints the AST even if errors occurred */
+			if (mode == PrintAst) {
+				type_set_output(out);
+				ast_set_output(out);
+				print_ast(unit);
+			}
 
-	if(mode == BenchmarkParser) {
-		return result;
-	}
+			if(error_count > 0) {
+				/* parsing failed because of errors */
+				fprintf(stderr, "%u error(s), %u warning(s)\n", error_count,
+				        warning_count);
+				result = EXIT_FAILURE;
+				continue;
+			} else if(warning_count > 0) {
+				fprintf(stderr, "%u warning(s)\n", warning_count);
+			}
 
-	/* prints the AST even if errors occurred */
-	if(mode == PrintAst) {
-		type_set_output(out);
-		ast_set_output(out);
-		print_ast(unit);
-		return result;
-	}
+			if(mode == BenchmarkParser) {
+				return result;
+			} else if(mode == PrintFluffy) {
+				write_fluffy_decls(out, unit);
+				continue;
+			} else if (mode == PrintCaml) {
+				write_caml_decls(out, unit);
+				continue;
+			}
 
-	/* cannot handle other modes with errors */
-	if(result != EXIT_SUCCESS)
-		return result;
+			translation_unit_to_firm(unit);
 
-	if(mode == PrintFluffy) {
-		type_set_output(out);
-		ast_set_output(out);
-		write_fluffy_decls(out, unit);
-	}
+			if (mode == ParseOnly) {
+				continue;
+			}
+
+			if (mode == CompileDump) {
+				/* find irg */
+				ident    *id     = new_id_from_str(dumpfunction);
+				ir_graph *irg    = NULL;
+				int       n_irgs = get_irp_n_irgs();
+				for(int i = 0; i < n_irgs; ++i) {
+					ir_graph *tirg   = get_irp_irg(i);
+					ident    *irg_id = get_entity_ident(get_irg_entity(tirg));
+					if(irg_id == id) {
+						irg = tirg;
+						break;
+					}
+				}
 
-	translation_unit_to_firm(unit);
+				if(irg == NULL) {
+					fprintf(stderr, "No graph for function '%s' found\n",
+					        dumpfunction);
+					exit(1);
+				}
 
-	if(mode == ParseOnly) {
-		return 0;
-	}
+				dump_ir_block_graph_file(irg, out);
+				fclose(out);
+				exit(0);
+			}
 
-	FILE *asm_out;
-	char  asm_tempfile[1024];
-	if(mode == CompileDump) {
-		asm_out = NULL;
-		firm_be_opt.selection = BE_NONE;
-	} else if(mode == Compile) {
-		asm_out = out;
-	} else {
-		asm_out
-			= make_temp_file(asm_tempfile, sizeof(asm_tempfile), "cc", ".s");
-	}
-	gen_firm_finish(asm_out, input, /*c_mode=*/1, /*firm_const_exists=*/0);
-
-	if(mode == CompileDump) {
-		/* find irg */
-		ident    *id     = new_id_from_str(dumpfunction);
-		ir_graph *irg    = NULL;
-		int       n_irgs = get_irp_n_irgs();
-		for(int i = 0; i < n_irgs; ++i) {
-			ir_graph *tirg   = get_irp_irg(i);
-			ident    *irg_id = get_entity_ident(get_irg_entity(tirg));
-			if(irg_id == id) {
-				irg = tirg;
-				break;
+			gen_firm_finish(asm_out, filename, /*c_mode=*/1,
+			                /*firm_const_exists=*/0);
+			if (asm_out != out) {
+				fclose(asm_out);
 			}
-		}
 
-		if(irg == NULL) {
-			fprintf(stderr, "No graph for function '%s' found\n", dumpfunction);
-			return 1;
+		} else if (filetype == FILETYPE_PREPROCESSED_ASSEMBLER) {
+			copy_file(asm_out, in);
+			if (in == preprocessed_in) {
+				int pp_result = pclose(preprocessed_in);
+				if (pp_result != EXIT_SUCCESS) {
+					return pp_result;
+				}
+			}
+			if(asm_out != out) {
+				fclose(asm_out);
+			}
 		}
 
-		dump_ir_block_graph_file(irg, out);
-		fclose(out);
-		return 0;
-	}
+		if (mode == Compile)
+			continue;
+
+		/* if we're here then we have preprocessed assembly */
+		filename = asm_tempfile;
+		filetype = FILETYPE_PREPROCESSED_ASSEMBLER;
+
+		/* assemble */
+		if (filetype == FILETYPE_PREPROCESSED_ASSEMBLER) {
+			char        temp[1024];
+			const char *filename_o;
+			if(mode == CompileAssemble) {
+				fclose(out);
+				filename_o = outname;
+			} else {
+				FILE *tempf = make_temp_file(temp, sizeof(temp), "cco");
+				fclose(tempf);
+				filename_o = temp;
+			}
 
-	fclose(asm_out);
+			assemble(filename_o, filename);
 
-	/* assemble assembler and create object file */
-	char obj_tfile[1024];
-	if(mode == CompileAssemble || mode == CompileAssembleLink) {
-		const char *obj_outfile;
-		if(mode == CompileAssemble) {
-			fclose(out);
-			obj_outfile = outname;
-		} else {
-			FILE *tempf
-				= make_temp_file(obj_tfile, sizeof(obj_tfile), "cc", ".o");
-			fclose(tempf);
-			obj_outfile = obj_tfile;
+			size_t len = strlen(filename_o) + 1;
+			filename = obstack_copy(&file_obst, filename_o, len);
+			filetype = FILETYPE_OBJECT;
 		}
 
-		assemble(obj_outfile, asm_tempfile);
+		/* ok we're done here, process next file */
+		file->name = filename;
+		file->type = filetype;
 	}
 
-	/* link object file */
+	if (result != EXIT_SUCCESS)
+		return result;
+
+	/* link program file */
 	if(mode == CompileAssembleLink) {
-		do_link(outname, obj_tfile);
+		obstack_1grow(&ldflags_obst, '\0');
+		const char *flags = obstack_finish(&ldflags_obst);
+
+		/* construct commandline */
+		obstack_printf(&file_obst, "%s", LINKER);
+		for (file_list_entry_t *entry = files; entry != NULL;
+				entry = entry->next) {
+			if (entry->type != FILETYPE_OBJECT)
+				continue;
+
+			add_flag(&file_obst, "%s", entry->name);
+		}
+
+		add_flag(&file_obst, "-o");
+		add_flag(&file_obst, outname);
+		obstack_printf(&file_obst, "%s", flags);
+		obstack_1grow(&file_obst, '\0');
+
+		char *commandline = obstack_finish(&file_obst);
+
+		if(verbose) {
+			puts(commandline);
+		}
+		int err = system(commandline);
+		if(err != EXIT_SUCCESS) {
+			fprintf(stderr, "linker reported an error\n");
+			exit(1);
+		}
 	}
 
 	obstack_free(&cppflags_obst, NULL);