X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=b38325bdfc512ef34f3ae43982cc867b4e8a9d53;hb=cf80e941ca33006ab52321c2c74c6c30a7a4d10a;hp=c31a54aa7e41a472781401e21cc2d383bce3f718;hpb=15e6a2ced0ec2d85c7054120efc5a4d771b4b84a;p=cparser

diff --git a/main.c b/main.c
index c31a54a..b38325b 100644
--- a/main.c
+++ b/main.c
@@ -75,11 +75,12 @@
 #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"
+#define PREPROCESSOR "cpp -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int -U__SIZE_TYPE__ -D__SIZE_TYPE__=__SIZE_TYPE__ -m32"
 #endif
 
 #ifndef LINKER
@@ -102,6 +103,9 @@ 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;
 
@@ -111,6 +115,13 @@ extern bool print_parenthesis;
 static int            verbose;
 static struct obstack cppflags_obst, ldflags_obst;
 
+typedef struct file_list_entry_t file_list_entry_t;
+
+struct file_list_entry_t {
+	const char        *filename;
+	file_list_entry_t *next;
+};
+
 #if defined(_DEBUG) || defined(FIRM_DEBUG)
 /**
  * Debug printf implementation.
@@ -166,10 +177,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;
 }
 
@@ -184,7 +206,41 @@ 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, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+
+	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;
+		}
+	}
+
+	va_end(ap);
+}
+
+static FILE *preprocess(FILE *in, const char *fname)
 {
 	char buf[4096];
 	obstack_1grow(&cppflags_obst, '\0');
@@ -200,17 +256,13 @@ static FILE *preprocess(FILE *in, const char *fname, bool to_stdout)
 	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);
-		}
-		return f;
+
+	FILE *f = popen(buf, "r");
+	if(f == NULL) {
+		fprintf(stderr, "invoking preprocessor failed\n");
+		exit(1);
 	}
+	return f;
 }
 
 static void do_link(const char *out, const char *in)
@@ -351,7 +403,9 @@ typedef enum compile_mode_t {
 	CompileAssembleLink,
 	LexTest,
 	PrintAst,
-	PrintFluffy
+	PrintFluffy,
+	PrintCaml,
+	Link,
 } compile_mode_t;
 
 static void usage(const char *argv0)
@@ -376,20 +430,51 @@ 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");
+		}
+	}
+}
+
 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";
+	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;
+	struct obstack     file_obst;
 
 	obstack_init(&cppflags_obst);
 	obstack_init(&ldflags_obst);
+	obstack_init(&file_obst);
 
 #define GET_ARG_AFTER(def, args)                                             \
 	def = &arg[sizeof(args)-1];                                              \
@@ -425,23 +510,24 @@ 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;
 	}
 
@@ -450,15 +536,15 @@ int main(int argc, char **argv)
 	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')) {
@@ -470,27 +556,43 @@ 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(strcmp(option, "M") == 0) {
+				mode = PreprocessOnly;
+				add_flag(&cppflags_obst, "-M");
+			} else if(strcmp(option, "MMD") == 0
+					|| strcmp(option, "MD") == 0
+					|| strcmp(option, "MM") == 0) {
+				add_flag(&cppflags_obst, "-%s", option);
+			} else if(strcmp(option, "MT") == 0
+					|| strcmp(option, "MQ") == 0
+					|| strcmp(option, "MF") == 0) {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-MT");
+				add_flag(&cppflags_obst, "-%s", option);
+				add_flag(&cppflags_obst, "%s", opt);
+			} else if(strcmp(option, "pipe") == 0) {
+				/* here for gcc compatibility */
 			} else if(option[0] == 'f') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-f");
@@ -498,9 +600,19 @@ int main(int argc, char **argv)
 				if(strcmp(opt, "syntax-only") == 0) {
 					mode = ParseOnly;
 				} else if(strcmp(opt, "omit-frame-pointer") == 0) {
-					firm_be_option("omitfp");
+					set_be_option("omitfp");
 				} else if(strcmp(opt, "no-omit-frame-pointer") == 0) {
-					firm_be_option("omitfp=no");
+					set_be_option("omitfp=no");
+				} else if(strcmp(opt, "strength-reduce") == 0) {
+					firm_option("strength-red");
+				} else if(strcmp(opt, "fast-math") == 0
+						|| strcmp(opt, "unroll-loops") == 0
+						|| strcmp(opt, "expensive-optimizations") == 0
+						|| strcmp(opt, "no-common") == 0
+						|| strncmp(opt, "align-loops=", sizeof("align-loops=")-1) == 0
+						|| strncmp(opt, "align-jumps=", sizeof("align-jumps=")-1) == 0
+						|| strncmp(opt, "align-functions=", sizeof("align-functions=")-1) == 0) {
+					fprintf(stderr, "ignoring gcc option '-f %s'\n", opt);
 				} else {
 					int res = firm_option(opt);
 					if (res == 0) {
@@ -580,8 +692,10 @@ int main(int argc, char **argv)
 					int res = firm_be_option(arch_opt);
 					if (res == 0)
 						argument_errors = true;
-				} else if(strcmp(opt, "32") == 0) {
-					/* ignore -m32, we are always 32bit */
+				} else if(strcmp(opt, "omit-leaf-frame-pointer") == 0) {
+					set_be_option("omitleaffp=1");
+				} else if(strcmp(opt, "no-omit-leaf-frame-pointer") == 0) {
+					set_be_option("omitleaffp=0");
 				} else {
 					char *endptr;
 					long int value = strtol(opt, &endptr, 10);
@@ -604,8 +718,8 @@ int main(int argc, char **argv)
 					input = arg;
 				}
 			} else if(strcmp(option, "pg") == 0) {
-				firm_be_option("-b gprof");
-				obstack_printf(&ldflags_obst, " -pg");
+				set_be_option("gprof");
+				add_flag(&ldflags_obst, "-pg");
 			} else if(strcmp(option, "pedantic") == 0) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
 			} else if(strncmp(option, "std=", 4) == 0) {
@@ -650,6 +764,8 @@ int main(int argc, char **argv)
 					print_parenthesis = true;
 				} else if(strcmp(option, "print-fluffy") == 0) {
 					mode = PrintFluffy;
+				} else if(strcmp(option, "print-caml") == 0) {
+					mode = PrintCaml;
 				} else if(strcmp(option, "version") == 0) {
 					print_cparser_version();
 					exit(EXIT_SUCCESS);
@@ -672,22 +788,59 @@ int main(int argc, char **argv)
 				argument_errors = true;
 			}
 		} else {
-			if(input != NULL) {
-				fprintf(stderr, "error: multiple input files specified\n");
-				argument_errors = true;
+
+			file_list_entry_t *entry
+				= obstack_alloc(&file_obst, sizeof(entry[0]));
+			entry->filename = arg;
+
+			size_t len = strlen(arg);
+			if (len < 2) {
+				if (arg[0] == '-') {
+					/* exception: '-' as name reads C from stdin */
+					entry->next = c_files;
+					c_files     = entry;
+					continue;
+				}
+				fprintf(stderr, "'%s': file format not recognized\n", input);
+				continue;
+			}
+
+			if (strcmp(arg+len-2, ".c") == 0
+					|| strcmp(arg+len-2, ".h") == 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;
 			} else {
-				input = arg;
+				fprintf(stderr, "'%s': file format not recognized\n", input);
 			}
 		}
 	}
 
+	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 {
+		if (c_files == NULL) {
+			fprintf(stderr, "error: no input files specified\n");
+		} else {
+			fprintf(stderr, "error: multiple input files specified\n");
+		}
+		argument_errors = true;
+	}
+
 	/* we do the lowering in ast2firm */
 	firm_opt.lower_bitfields = FALSE;
 
-	if(help_displayed) {
+	if (help_displayed) {
 		return !argument_errors;
 	}
-	if(argument_errors) {
+	if (argument_errors) {
 		usage(argv[0]);
 		return 1;
 	}
@@ -710,11 +863,10 @@ int main(int argc, char **argv)
 		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
+		case PrintCaml:
 		case LexTest:
-			if(outname == NULL)
-				outname = "-";
-			break;
 		case PreprocessOnly:
+			outname = "-";
 			break;
 		case ParseOnly:
 			break;
@@ -731,6 +883,7 @@ int main(int argc, char **argv)
 			                ".vcg");
 			outname = outnamebuf;
 			break;
+		case Link:
 		case CompileAssembleLink:
 #ifdef _WIN32
 			/* Windows compiler typically derive the output name from
@@ -744,6 +897,32 @@ 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);
+
+		for (file_list_entry_t *entry = o_files; entry != NULL;
+				entry = entry->next) {
+			obstack_printf(&file_obst, " %s", entry->filename);
+		}
+
+		obstack_printf(&file_obst, " -o %s %s", outname, flags);
+
+		char *buf = obstack_finish(&file_obst);
+
+		if(verbose) {
+			puts(buf);
+		}
+		int err = system(buf);
+		if(err != 0) {
+			fprintf(stderr, "linker reported an error\n");
+			exit(1);
+		}
+		return 0;
+	}
+
 	if(outname != NULL) {
 		if(strcmp(outname, "-") == 0) {
 			out = stdout;
@@ -778,10 +957,15 @@ int main(int argc, char **argv)
 		return 0;
 	}
 
-	FILE *preprocessed_in = preprocess(in, input, mode == PreprocessOnly);
+	FILE *preprocessed_in = preprocess(in, input);
+	if (mode == PreprocessOnly) {
+		copy_file(out, preprocessed_in);
+		return pclose(preprocessed_in);
+	}
+
 	translation_unit_t *const unit = do_parsing(preprocessed_in, input);
 	int res = pclose(preprocessed_in);
-	if(res != 0) {
+	if (res != 0) {
 		return res;
 	}
 
@@ -810,10 +994,11 @@ int main(int argc, char **argv)
 		return result;
 
 	if(mode == PrintFluffy) {
-		type_set_output(out);
-		ast_set_output(out);
 		write_fluffy_decls(out, unit);
 	}
+	if (mode == PrintCaml) {
+		write_caml_decls(out, unit);
+	}
 
 	translation_unit_to_firm(unit);
 
@@ -884,6 +1069,7 @@ int main(int argc, char **argv)
 
 	obstack_free(&cppflags_obst, NULL);
 	obstack_free(&ldflags_obst, NULL);
+	obstack_free(&file_obst, NULL);
 
 	exit_ast2firm();
 	exit_parser();