X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=main.c;h=dcd5e3f5ad81922de28313c91fa3073564531f89;hb=6b556495efe4efc7eb3de854a2972fad46d9d283;hp=9a688b84582961408681bb76092a48f8b233a8ed;hpb=f928976aed1725d96a398dededac5eddcbe7870d;p=cparser

diff --git a/main.c b/main.c
index 9a688b8..dcd5e3f 100644
--- a/main.c
+++ b/main.c
@@ -1,3 +1,22 @@
+/*
+ * This file is part of cparser.
+ * Copyright (C) 2007-2008 Matthias Braun <matze@braunis.de>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
 #include <config.h>
 
 #define _GNU_SOURCE
@@ -86,7 +105,7 @@ bool strict_mode = false;
 /* to switch on printing of implicit casts */
 extern bool print_implicit_casts;
 
-/* to switch on printing of  srenthesis to indicate operator precedence */
+/* to switch on printing of parenthesis to indicate operator precedence */
 extern bool print_parenthesis;
 
 static int            verbose;
@@ -147,9 +166,9 @@ static void get_output_name(char *buf, size_t buflen, const char *inputname,
 	memcpy(buf+last_dot, newext, extlen);
 }
 
-static translation_unit_t *do_parsing(FILE *const in, const char *const input)
+static translation_unit_t *do_parsing(FILE *const in, const char *const input_name)
 {
-	lexer_open_stream(in, input);
+	lexer_open_stream(in, input_name);
 	translation_unit_t *unit = parse();
 	return unit;
 }
@@ -165,9 +184,10 @@ static void lextest(FILE *in, const char *fname)
 	} while(lexer_token.type != T_EOF);
 }
 
-static FILE* preprocess(FILE* in, const char *fname)
+static FILE *preprocess(FILE *in, const char *fname, bool to_stdout)
 {
 	char buf[4096];
+	obstack_1grow(&cppflags_obst, '\0');
 	const char *flags = obstack_finish(&cppflags_obst);
 
 	if(in != stdin) {
@@ -180,17 +200,23 @@ static FILE* preprocess(FILE* in, const char *fname)
 	if(verbose) {
 		puts(buf);
 	}
-	FILE* f = popen(buf, "r");
-	if (f == NULL) {
-		fprintf(stderr, "invoking preprocessor failed\n");
-		exit(1);
+	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;
 	}
-	return f;
 }
 
 static void do_link(const char *out, const char *in)
 {
 	char buf[4096];
+	obstack_1grow(&ldflags_obst, '\0');
 	const char *flags = obstack_finish(&ldflags_obst);
 
 	snprintf(buf, sizeof(buf), LINKER " %s -o %s %s", flags, out, in);
@@ -317,6 +343,7 @@ void lower_compound_params(void)
 
 typedef enum compile_mode_t {
 	BenchmarkParser,
+	PreprocessOnly,
 	ParseOnly,
 	Compile,
 	CompileDump,
@@ -332,6 +359,23 @@ static void usage(const char *argv0)
 	fprintf(stderr, "Usage %s input [-o output] [-c]\n", argv0);
 }
 
+static void print_cparser_version(void) {
+	firm_version_t ver;
+	firm_get_version(&ver);
+
+	printf("cparser (%s) using libFirm (%u.%u",
+		cparser_REVISION, ver.major, ver.minor);
+	if(ver.revision[0] != 0) {
+		putchar(' ');
+		fputs(ver.revision, stdout);
+	}
+	if(ver.build[0] != 0) {
+		putchar(' ');
+		fputs(ver.build, stdout);
+	}
+	puts(")\n");
+}
+
 int main(int argc, char **argv)
 {
 	initialize_firm();
@@ -340,6 +384,9 @@ int main(int argc, char **argv)
 	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";
 
 	obstack_init(&cppflags_obst);
 	obstack_init(&ldflags_obst);
@@ -363,6 +410,42 @@ int main(int argc, char **argv)
 
 #define SINGLE_OPTION(ch) (option[0] == (ch) && option[1] == '\0')
 
+	/* early options parsing (find out optimisation level) */
+	for(int i = 1; i < argc; ++i) {
+		const char *arg = argv[i];
+		if(arg[0] != '-')
+			continue;
+
+		const char *option = &arg[1];
+		if(option[0] == 'O') {
+			sscanf(&option[1], "%d", &opt_level);
+		}
+	}
+
+	/* apply optimisation level */
+	switch(opt_level) {
+	case 0:
+		firm_option("no-opt");
+		break;
+	case 1:
+		firm_option("no-inline");
+		break;
+	default:
+	case 4:
+		firm_option("strict-aliasing");
+		/* fallthrough */
+	case 3:
+		firm_option("cond-eval");
+		firm_option("if-conv");
+		/* fallthrough */
+	case 2:
+		firm_option("inline");
+		firm_option("deconv");
+		firm_be_option("omitfp");
+		break;
+	}
+
+	/* parse rest of options */
 	bool help_displayed  = false;
 	bool argument_errors = false;
 	for(int i = 1; i < argc; ++i) {
@@ -372,10 +455,18 @@ int main(int argc, char **argv)
 			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");
 			} else if(SINGLE_OPTION('c')) {
 				mode = CompileAssemble;
+			} else if(SINGLE_OPTION('E')) {
+				mode = PreprocessOnly;
 			} else if(SINGLE_OPTION('S')) {
 				mode = Compile;
+			} else if(option[0] == 'O') {
+				continue;
 			} else if(option[0] == 'I') {
 				const char *opt;
 				GET_ARG_AFTER(opt, "-I");
@@ -431,23 +522,85 @@ 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(option[0] == 'W') {
 				set_warning_opt(&option[1]);
 			} else if(option[0] == 'm') {
+				/* -m options */
 				const char *opt;
+				char arch_opt[64];
+
 				GET_ARG_AFTER(opt, "-m");
-				char *endptr;
-				long int value = strtol(opt, &endptr, 10);
-				if (*endptr != '\0') {
-					fprintf(stderr, "error: wrong option '-m %s'\n",  opt);
-					argument_errors = true;
-				}
-				if (value != 16 && value != 32 && value != 64) {
-					fprintf(stderr, "error: option -m supports only 16, 32 or 64\n");
-					argument_errors = true;
+				if(strncmp(opt, "arch=", 5) == 0) {
+					GET_ARG_AFTER(opt, "-march=");
+					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 {
+						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, "tune=", 5) == 0) {
+					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) {
+					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) {
+					GET_ARG_AFTER(opt, "-mfpmath=");
+					if(strcmp(opt, "387") == 0)
+						opt = "x87";
+					else if(strcmp(opt, "sse") == 0)
+						opt = "sse2";
+					else {
+						fprintf(stderr, "error: option -mfpumath supports only 387 or sse\n");
+						argument_errors = true;
+					}
+					if(!argument_errors) {
+						snprintf(arch_opt, sizeof(arch_opt), "%s-fpunit=%s", cpu_arch, opt);
+						int res = firm_be_option(arch_opt);
+						if (res == 0)
+							argument_errors = true;
+					}
+				} else if(strncmp(opt, "preferred-stack-boundary=", 25) == 0) {
+					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 {
-					machine_size = (unsigned int)value;
+					char *endptr;
+					long int value = strtol(opt, &endptr, 10);
+					if (*endptr != '\0') {
+						fprintf(stderr, "error: wrong option '-m %s'\n",  opt);
+						argument_errors = true;
+					}
+					if (value != 16 && value != 32 && value != 64) {
+						fprintf(stderr, "error: option -m supports only 16, 32 or 64\n");
+						argument_errors = true;
+					} else {
+						machine_size = (unsigned int)value;
+					}
 				}
 			} else if (option[0] == '\0') {
 				if(input != NULL) {
@@ -456,12 +609,24 @@ int main(int argc, char **argv)
 				} 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) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
-			} else if(option[0] == 'O' ||
-			          option[0] == 'g' ||
-			          strncmp(option, "std=", 4) == 0) {
-				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
+			} else if(strncmp(option, "std=", 4) == 0) {
+				if(strcmp(&option[4], "c99") == 0) {
+					c_mode = _C89|_C99;
+				} else if(strcmp(&option[4], "c89") == 0) {
+					c_mode = _C89;
+				} else if(strcmp(&option[4], "gnu99") == 0) {
+					c_mode = _C89|_C99|_GNUC;
+				} else if(strcmp(&option[4], "microsoft") == 0) {
+					c_mode = _C89|_C99|_MS;
+				} else
+					fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
+			} else if(strcmp(option, "version") == 0) {
+				print_cparser_version();
 			} else if (option[0] == '-') {
 				/* double dash option */
 				++option;
@@ -492,18 +657,7 @@ int main(int argc, char **argv)
 				} else if(strcmp(option, "print-fluffy") == 0) {
 					mode = PrintFluffy;
 				} else if(strcmp(option, "version") == 0) {
-					firm_version_t ver;
-					firm_get_version(&ver);
-					printf("cparser (%d.%d %s) using libFirm (%u.%u", 0, 1, cparser_REVISION, ver.major, ver.minor);
-					if(ver.revision[0] != 0) {
-						putchar(' ');
-						fputs(ver.revision, stdout);
-					}
-					if(ver.build[0] != 0) {
-						putchar(' ');
-						fputs(ver.build, stdout);
-					}
-					puts(")\n");
+					print_cparser_version();
 					exit(EXIT_SUCCESS);
 				} else if(strcmp(option, "dump-function") == 0) {
 					++i;
@@ -566,6 +720,8 @@ int main(int argc, char **argv)
 			if(outname == NULL)
 				outname = "-";
 			break;
+		case PreprocessOnly:
+			break;
 		case ParseOnly:
 			break;
 		case Compile:
@@ -582,7 +738,14 @@ int main(int argc, char **argv)
 			outname = outnamebuf;
 			break;
 		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;
+#else
 			outname = "a.out";
+#endif
 			break;
 		}
 	}
@@ -621,31 +784,37 @@ int main(int argc, char **argv)
 		return 0;
 	}
 
-	FILE *preprocessed_in = preprocess(in, input);
+	FILE *preprocessed_in = preprocess(in, input, mode == PreprocessOnly);
 	translation_unit_t *const unit = do_parsing(preprocessed_in, input);
-	int result = pclose(preprocessed_in);
-	if(result != 0) {
-		return result;
+	int res = pclose(preprocessed_in);
+	if(res != 0) {
+		return res;
 	}
-	if(unit == NULL) {
+
+	if(error_count > 0) {
 		/* parsing failed because of errors */
 		fprintf(stderr, "%u error(s), %u warning(s)\n", error_count, warning_count);
-		return EXIT_FAILURE;
-	}
-	if (warning_count > 0) {
+		result = EXIT_FAILURE;
+	} else if(warning_count > 0) {
 		fprintf(stderr, "%u warning(s)\n", warning_count);
 	}
 
 	if(mode == BenchmarkParser) {
-		return 0;
+		return result;
 	}
 
+	/* prints the AST even if errors occurred */
 	if(mode == PrintAst) {
 		type_set_output(out);
 		ast_set_output(out);
 		print_ast(unit);
-		return 0;
+		return result;
 	}
+
+	/* cannot handle other modes with errors */
+	if(result != EXIT_SUCCESS)
+		return result;
+
 	if(mode == PrintFluffy) {
 		type_set_output(out);
 		ast_set_output(out);