X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=main.c;h=84b2b5fa3ff949c92c28c4a521d46b052941faf6;hb=fd16b92f058181088a385c3224c8814831c006d3;hp=70c5ba08aac0a51b76d3c0cb5512d467d9c5873a;hpb=6ff85b6a89c74076dc516e3a38bc26bd80c37fa5;p=cparser

diff --git a/main.c b/main.c
index 70c5ba0..84b2b5f 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
@@ -7,9 +26,36 @@
 #include <stdbool.h>
 #include <errno.h>
 #include <string.h>
-#include <unistd.h>
 #include <assert.h>
 
+#ifdef _WIN32
+
+#include <fcntl.h>
+#include <io.h>
+
+/* no eXecute on Win32 */
+#define X_OK 0
+#define W_OK 2
+#define R_OK 4
+
+#define O_RDWR          _O_RDWR
+#define O_CREAT         _O_CREAT
+#define O_EXCL          _O_EXCL
+#define O_BINARY        _O_BINARY
+
+/* remap some names, we are not in the POSIX world */
+#define access(fname, mode)      _access(fname, mode)
+#define mktemp(tmpl)             _mktemp(tmpl)
+#define open(fname, oflag, mode) _open(fname, oflag, mode)
+#define fdopen(fd, mode)         _fdopen(fd, mode)
+#define popen(cmd, mode)         _popen(cmd, mode)
+#define pclose(file)             _pclose(file)
+
+#else
+#include <unistd.h>
+#define HAVE_MKSTEMP
+#endif
+
 #ifndef WITH_LIBCORE
 #define WITH_LIBCORE
 #endif
@@ -19,39 +65,69 @@
 
 #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"
 #endif
 
 #ifndef LINKER
-#define LINKER       "gcc -m32"
+#define LINKER    "gcc -m32"
 #endif
 
 #ifndef ASSEMBLER
 #define ASSEMBLER "as --32"
 #endif
 
-#ifdef _WIN32
-/* remap some names */
-#define popen(cmd, mode)  _popen(cmd, mode)
-#define pclose(file)      _pclose(file)
-#endif /* _WIN32 */
+/** The current c mode/dialect. */
+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;
 
-/** The current c mode/dialect */
-unsigned int c_mode = _C99|_GNUC;
+/** 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  srenthesis to indicate operator precedence */
+extern bool print_parenthesis;
 
 static int            verbose;
-static bool           do_dump;
-static struct obstack cppflags_obst;
+static struct obstack cppflags_obst, ldflags_obst;
+
+#if defined(_DEBUG) || defined(FIRM_DEBUG)
+/**
+ * Debug printf implementation.
+ *
+ * @param fmt  printf style format parameter
+ */
+void dbg_printf(const char *fmt, ...)
+{
+	va_list list;
+
+	if (firm_dump.debug_print) {
+		va_start(list, fmt);
+		vprintf(fmt, list);
+		va_end(list);
+	}  /* if */
+}
+#endif /* defined(_DEBUG) || defined(FIRM_DEBUG) */
 
 static void initialize_firm(void)
 {
@@ -61,13 +137,6 @@ static void initialize_firm(void)
 	dump_keepalive_edges(1);
 }
 
-static void dump(ir_graph *irg, const char *suffix)
-{
-	if(do_dump) {
-		dump_ir_block_graph(irg, suffix);
-	}
-}
-
 static void get_output_name(char *buf, size_t buflen, const char *inputname,
                             const char *newext)
 {
@@ -118,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) {
@@ -141,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);
 	}
@@ -210,6 +282,15 @@ static const char *get_tempdir(void)
 	return tmpdir;
 }
 
+#ifndef HAVE_MKSTEMP
+/* cheap and nasty mkstemp replacement */
+static int mkstemp(char *templ)
+{
+	mktemp(templ);
+	return open(templ, O_RDWR|O_CREAT|O_EXCL|O_BINARY, 0600);
+}
+#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)...
@@ -255,26 +336,8 @@ void lower_compound_params(void)
 	lower_calls_with_compounds(&params);
 }
 
-static void create_firm_prog(translation_unit_t *unit)
-{
-	translation_unit_to_firm(unit);
-
-	int n_irgs = get_irp_n_irgs();
-	for(int i = 0; i < n_irgs; ++i) {
-		ir_graph *const irg = get_irp_irg(i);
-		dump(irg, "-start");
-	}
-
-	lower_compound_params();
-	lower_highlevel();
-
-	for(int i = 0; i < n_irgs; ++i) {
-		ir_graph *const irg = get_irp_irg(i);
-		dump(irg, "-lower");
-	}
-}
-
 typedef enum compile_mode_t {
+	BenchmarkParser,
 	ParseOnly,
 	Compile,
 	CompileDump,
@@ -294,21 +357,14 @@ int main(int argc, char **argv)
 {
 	initialize_firm();
 
-	init_symbol_table();
-	init_tokens();
-	init_types();
-	init_typehash();
-	init_lexer();
-	init_ast();
-	init_parser();
-	init_ast2firm();
-
 	const char     *input        = NULL;
 	const char     *outname      = NULL;
 	const char     *dumpfunction = NULL;
 	compile_mode_t  mode         = CompileAssembleLink;
+	int             opt_level    = 1;
 
 	obstack_init(&cppflags_obst);
+	obstack_init(&ldflags_obst);
 
 #define GET_ARG_AFTER(def, args)                                             \
 	def = &arg[sizeof(args)-1];                                              \
@@ -327,92 +383,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("no-strength-red");
+		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") == 0) {
-			do_dump = true;
-		} 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 (%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");
+					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;
@@ -427,6 +596,9 @@ int main(int argc, char **argv)
 		}
 	}
 
+	/* we do the lowering in ast2firm */
+	firm_opt.lower_bitfields = FALSE;
+
 	if(help_displayed) {
 		return !argument_errors;
 	}
@@ -435,10 +607,22 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	FILE *out;
+	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 = NULL;
 	char  outnamebuf[4096];
 	if(outname == NULL) {
 		switch(mode) {
+		case BenchmarkParser:
 		case PrintAst:
 		case PrintFluffy:
 		case LexTest:
@@ -502,9 +686,22 @@ 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 result = pclose(preprocessed_in);
+	if(result != 0) {
+		return result;
+	}
+	if(unit == NULL) {
+		/* 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) {
+		fprintf(stderr, "%u warning(s)\n", warning_count);
+	}
+
+	if(mode == BenchmarkParser) {
+		return 0;
+	}
 
 	if(mode == PrintAst) {
 		type_set_output(out);
@@ -518,8 +715,7 @@ int main(int argc, char **argv)
 		write_fluffy_decls(out, unit);
 	}
 
-	gen_firm_init();
-	create_firm_prog(unit);
+	translation_unit_to_firm(unit);
 
 	if(mode == ParseOnly) {
 		return 0;
@@ -587,6 +783,7 @@ int main(int argc, char **argv)
 	}
 
 	obstack_free(&cppflags_obst, NULL);
+	obstack_free(&ldflags_obst, NULL);
 
 	exit_ast2firm();
 	exit_parser();