X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=main.c;h=a0f17a5dff9473bf1ed162d4ca25d0888e46287d;hb=2151f7ff22ee388e6a57ff024d2558101907e7f7;hp=86bb29e602a8129e4e705f197468bda8d8df44b3;hpb=a2c47f9d691b8785bf4036c4c3e02ef123d0c9c8;p=cparser

diff --git a/main.c b/main.c
index 86bb29e..a0f17a5 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
@@ -46,14 +65,18 @@
 
 #include "lexer.h"
 #include "token_t.h"
+#include "types.h"
 #include "type_hash.h"
 #include "parser.h"
 #include "ast2firm.h"
+#include "diagnostic.h"
 #include "lang_features.h"
+#include "driver/firm_opt.h"
 #include "driver/firm_cmdline.h"
 #include "adt/error.h"
 #include "write_fluffy.h"
-#include "driver/firm_opt.h"
+#include "revision.h"
+#include "warning.h"
 
 #ifndef PREPROCESSOR
 #define PREPROCESSOR "cpp -std=c99 -U__WCHAR_TYPE__ -D__WCHAR_TYPE__=int"
@@ -68,10 +91,25 @@
 #endif
 
 /** The current c mode/dialect. */
-unsigned int c_mode = _C99|_GNUC;
+unsigned int c_mode = _C89|_C99|_GNUC;
+
+/** The 'machine size', 16, 32 or 64 bit, 32bit is the default. */
+unsigned int machine_size = 32;
+
+/** true if the char type is signed. */
+bool char_is_signed = true;
+
+/** true for strict language checking. */
+bool strict_mode = 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;
+static struct obstack cppflags_obst, ldflags_obst;
 
 #if defined(_DEBUG) || defined(FIRM_DEBUG)
 /**
@@ -149,6 +187,7 @@ static void lextest(FILE *in, const char *fname)
 static FILE* preprocess(FILE* in, const char *fname)
 {
 	char buf[4096];
+	obstack_1grow(&cppflags_obst, '\0');
 	const char *flags = obstack_finish(&cppflags_obst);
 
 	if(in != stdin) {
@@ -172,8 +211,10 @@ static FILE* preprocess(FILE* in, const char *fname)
 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), "%s %s -o %s", LINKER, in, out);
+	snprintf(buf, sizeof(buf), LINKER " %s -o %s %s", flags, out, in);
 	if(verbose) {
 		puts(buf);
 	}
@@ -296,6 +337,7 @@ void lower_compound_params(void)
 }
 
 typedef enum compile_mode_t {
+	BenchmarkParser,
 	ParseOnly,
 	Compile,
 	CompileDump,
@@ -319,8 +361,11 @@ 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;
 
 	obstack_init(&cppflags_obst);
+	obstack_init(&ldflags_obst);
 
 #define GET_ARG_AFTER(def, args)                                             \
 	def = &arg[sizeof(args)-1];                                              \
@@ -339,90 +384,205 @@ 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) {
 		const char *arg = argv[i];
-		if(strncmp(arg, "-o", 2) == 0) {
-			GET_ARG_AFTER(outname, "-o");
-		} else if(strcmp(arg, "-c") == 0) {
-			mode = CompileAssemble;
-		} else if(strcmp(arg, "-S") == 0) {
-			mode = Compile;
-		} else if(strcmp(arg, "--gcc") == 0) {
-			c_mode |= _GNUC;
-		} else if(strcmp(arg, "--no-gcc") == 0) {
-			c_mode &= ~_GNUC;
-		} else if(strcmp(arg, "--ms") == 0) {
-			c_mode |= _MS;
-		} else if(strcmp(arg, "--no-ms") == 0) {
-			c_mode &= ~_MS;
-		} else if(strcmp(arg, "--lextest") == 0) {
-			mode = LexTest;
-		} else if(strcmp(arg, "--print-ast") == 0) {
-			mode = PrintAst;
-		} else if(strcmp(arg, "--print-fluffy") == 0) {
-			mode = PrintFluffy;
-		} else if(strcmp(arg, "-fsyntax-only") == 0) {
-			mode = ParseOnly;
-		} else if(strncmp(arg, "-I", 2) == 0) {
-			const char *opt;
-			GET_ARG_AFTER(opt, "-I");
-			obstack_printf(&cppflags_obst, " -I%s", opt);
-		} else if(strncmp(arg, "-D", 2) == 0) {
-			const char *opt;
-			GET_ARG_AFTER(opt, "-D");
-			obstack_printf(&cppflags_obst, " -D%s", opt);
-		} else if(strcmp(arg, "--dump-function") == 0) {
-			++i;
-			if(i >= argc) {
-				fprintf(stderr, "error: "
-				        "expected argument after '--dump-function'\n");
-				argument_errors = true;
-				break;
-			}
-			dumpfunction = argv[i];
-			mode         = CompileDump;
-		} else if(strcmp(arg, "-v") == 0) {
-			verbose = 1;
-		} else if(arg[0] == '-' && arg[1] == 'f') {
-			const char *opt;
-			GET_ARG_AFTER(opt, "-f");
-			int res = firm_option(opt);
-			if (res == 0) {
-				fprintf(stderr, "error: unknown Firm option '-f %s'\n", opt);
-				argument_errors = true;
+		if(arg[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");
+			} else if(SINGLE_OPTION('c')) {
+				mode = CompileAssemble;
+			} else if(SINGLE_OPTION('S')) {
+				mode = Compile;
+			} else if(option[0] == 'O') {
 				continue;
-			} else if (res == -1) {
-				help_displayed = true;
-			}
-		} else if(arg[0] == '-' && arg[1] == 'b') {
-			const char *opt;
-			GET_ARG_AFTER(opt, "-b");
-			int res = firm_be_option(opt);
-			if (res == 0) {
-				fprintf(stderr, "error: unknown Firm backend option '-b %s'\n",
-				        opt);
-				argument_errors = true;
-			} else if (res == -1) {
-				help_displayed = true;
-			}
-		} else if(arg[0] == '-') {
-			if (arg[1] == '\0') {
+			} else if(option[0] == 'I') {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-I");
+				obstack_printf(&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);
+			} else if(option[0] == 'U') {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-U");
+				obstack_printf(&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);
+			} else if(option[0] == 'L') {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-L");
+				obstack_printf(&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') {
+				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");
+				} 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;
+					}
+				}
+			} else if(option[0] == 'b') {
+				const char *opt;
+				GET_ARG_AFTER(opt, "-b");
+				int res = firm_be_option(opt);
+				if (res == 0) {
+					fprintf(stderr, "error: unknown Firm backend option '-b %s'\n",
+					        opt);
+					argument_errors = true;
+				} else if (res == -1) {
+					help_displayed = true;
+				}
+			} else if(option[0] == 'W') {
+				set_warning_opt(&option[1]);
+			} else if(option[0] == 'm') {
+				const char *opt;
+				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;
+				} else {
+					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(arg, "-pedantic") == 0) {
+			} else if(strcmp(option, "pedantic") == 0) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
-			} else if(arg[1] == 'O' ||
-					arg[1] == 'f' ||
-					arg[1] == 'W' ||
-					arg[1] == 'g' ||
-					strncmp(arg + 1, "std=", 4) == 0) {
+			} else if(strncmp(option, "std=", 4) == 0) {
 				fprintf(stderr, "warning: ignoring gcc option '%s'\n", arg);
+			} else if (option[0] == '-') {
+				/* double dash option */
+				++option;
+				if(strcmp(option, "gcc") == 0) {
+					c_mode |= _GNUC;
+				} else if(strcmp(option, "no-gcc") == 0) {
+					c_mode &= ~_GNUC;
+				} else if(strcmp(option, "ms") == 0) {
+					c_mode |= _MS;
+				} else if(strcmp(option, "no-ms") == 0) {
+					c_mode &= ~_MS;
+				} else if(strcmp(option, "signed-chars") == 0) {
+					char_is_signed = true;
+				} else if(strcmp(option, "unsigned-chars") == 0) {
+					char_is_signed = false;
+				} else if(strcmp(option, "strict") == 0) {
+					strict_mode = true;
+				} else if(strcmp(option, "lextest") == 0) {
+					mode = LexTest;
+				} else if(strcmp(option, "benchmark") == 0) {
+					mode = BenchmarkParser;
+				} else if(strcmp(option, "print-ast") == 0) {
+					mode = PrintAst;
+				} else if(strcmp(option, "print-implicit-cast") == 0) {
+					print_implicit_casts = true;
+				} else if(strcmp(option, "print-parenthesis") == 0) {
+					print_parenthesis = true;
+				} 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 (%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");
+					exit(EXIT_SUCCESS);
+				} else if(strcmp(option, "dump-function") == 0) {
+					++i;
+					if(i >= argc) {
+						fprintf(stderr, "error: "
+						        "expected argument after '--dump-function'\n");
+						argument_errors = true;
+						break;
+					}
+					dumpfunction = argv[i];
+					mode         = CompileDump;
+				} else {
+					fprintf(stderr, "error: unknown argument '%s'\n", arg);
+					argument_errors = true;
+				}
 			} else {
 				fprintf(stderr, "error: unknown argument '%s'\n", arg);
 				argument_errors = true;
@@ -437,6 +597,9 @@ int main(int argc, char **argv)
 		}
 	}
 
+	/* we do the lowering in ast2firm */
+	firm_opt.lower_bitfields = FALSE;
+
 	if(help_displayed) {
 		return !argument_errors;
 	}
@@ -445,19 +608,22 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
+	gen_firm_init();
 	init_symbol_table();
 	init_tokens();
 	init_types();
 	init_typehash();
+	init_basic_types();
 	init_lexer();
 	init_ast();
 	init_parser();
 	init_ast2firm();
 
-	FILE *out;
+	FILE *out = NULL;
 	char  outnamebuf[4096];
 	if(outname == NULL) {
 		switch(mode) {
+		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
 		case LexTest:
@@ -521,23 +687,41 @@ int main(int argc, char **argv)
 
 	FILE *preprocessed_in = preprocess(in, input);
 	translation_unit_t *const unit = do_parsing(preprocessed_in, input);
-	pclose(preprocessed_in);
-	if(unit == NULL)
-		return 1;
+	int res = pclose(preprocessed_in);
+	if(res != 0) {
+		return res;
+	}
+
+	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);
+	}
 
+	if(mode == BenchmarkParser) {
+		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);
 		write_fluffy_decls(out, unit);
 	}
 
-	gen_firm_init();
 	translation_unit_to_firm(unit);
 
 	if(mode == ParseOnly) {
@@ -606,6 +790,7 @@ int main(int argc, char **argv)
 	}
 
 	obstack_free(&cppflags_obst, NULL);
+	obstack_free(&ldflags_obst, NULL);
 
 	exit_ast2firm();
 	exit_parser();