Mercurial > ~dholland > hg > tradcpp > index.cgi
changeset 4:ee9a66b87c70
Initial version of toplevel and options handling.
| author | David A. Holland |
|---|---|
| date | Sun, 19 Dec 2010 17:52:59 -0500 |
| parents | bfa97d43197e |
| children | 7c489c73d62b |
| files | Makefile config.h files.h macro.h main.c mode.h version.h |
| diffstat | 7 files changed, 983 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Makefile Sun Dec 19 17:52:59 2010 -0500 @@ -0,0 +1,7 @@ +# $NetBSD$ + +PROG= tradcpp +SRCS= main.c array.c utils.c +WARNS= 5 + +.include <bsd.prog.mk>
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/config.h Sun Dec 19 17:52:59 2010 -0500 @@ -0,0 +1,14 @@ +#define CONFIG_LOCALINCLUDE "/usr/local/include" +#define CONFIG_SYSTEMINCLUDE "/usr/include" + +#define CONFIG_OS "__NetBSD__" +#define CONFIG_OS_2 "__unix__" + +#define CONFIG_CPU "__x86_64__" +#define CONFIG_CPU_2 "__amd64__" + +#define CONFIG_SIZE "__LP64__" +#define CONFIG_BINFMT "__ELF__" + +#define CONFIG_COMPILER "__NBCC__" +#define CONFIG_COMPILER_MINOR "__NBCC_MINOR__"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/files.h Sun Dec 19 17:52:59 2010 -0500 @@ -0,0 +1,6 @@ +struct place; + +void files_addquotepath(const char *dir, bool issystem); +void files_addbracketpath(const char *dir, bool issystem); + +void files_read(struct place *, const char *name);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/macro.h Sun Dec 19 17:52:59 2010 -0500 @@ -0,0 +1,4 @@ +struct place; + +void macro_define(struct place *, const char *macro, const char *expansion); +void macro_undef(const char *macro);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/main.c Sun Dec 19 17:52:59 2010 -0500 @@ -0,0 +1,914 @@ +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <err.h> + +#include "inlinedefs.h" // XXX +#include "version.h" +#include "config.h" +#include "utils.h" +#include "array.h" +#include "mode.h" +#include "files.h" +#include "macro.h" + +struct mode mode = { + .werror = false, + + .input_allow_dollars = false, + .input_tabstop = 8, + + .do_stdinc = true, + .do_stddef = true, + + .do_output = true, + .output_linenumbers = true, + .output_retain_comments = false, + .output_file = NULL, + + .do_depend = false, + .depend_report_system = false, + .depend_assume_generated = false, + .depend_issue_fakerules = false, + .depend_quote_target = true, + .depend_target = NULL, + .depend_file = NULL, + + .do_macrolist = false, + .macrolist_include_stddef = false, + .macrolist_include_expansions = false, + + .do_trace = false, + .trace_namesonly = false, + .trace_indented = false, +}; + +struct warns warns = { + .endiflabels = true, + .nestcomment = false, + .undef = false, + .unused = false, +}; + +//////////////////////////////////////////////////////////// +// commandline macros + +struct commandline_macro { + const char *macro; + const char *expansion; +}; + +static struct array commandline_macros; + +static +void +commandline_macros_init(void) +{ + array_init(&commandline_macros); +} + +static +void +commandline_macros_cleanup(void) +{ + array_cleanup(&commandline_macros); +} + +static +void +commandline_macro_add(const char *macro, const char *expansion) +{ + struct commandline_macro *cm; + + cm = domalloc(sizeof(*cm)); + cm->macro = macro; + cm->expansion = expansion; +} + +static +void +commandline_def(char *str) +{ + char *val; + + val = strchr(str, '='); + if (val != NULL) { + *val = '\0'; + val++; + } + commandline_macro_add(str, val ? val : "1"); +} + +static +void +commandline_undef(char *str) +{ + commandline_macro_add(str, NULL); +} + +static +void +apply_commandline_macros(void) +{ + struct commandline_macro *cm; + unsigned i, num; + + num = array_num(&commandline_macros); + for (i=0; i<num; i++) { + cm = array_get(&commandline_macros, i); + if (cm->expansion != NULL) { + macro_define(NULL, cm->macro, cm->expansion); + } else { + macro_undef(cm->macro); + } + free(cm); + } + array_setsize(&commandline_macros, 0); +} + +static +void +apply_builtin_macro(const char *name, const char *val) +{ + /* XXX distinguish builtin-place and commandline-place and nowhere */ + macro_define(NULL, name, val); +} + +static +void +apply_builtin_macros(void) +{ +#ifdef CONFIG_OS + apply_builtin_macro(CONFIG_OS, "1"); +#endif +#ifdef CONFIG_OS_2 + apply_builtin_macro(CONFIG_OS_2, "1"); +#endif + +#ifdef CONFIG_CPU + apply_builtin_macro(CONFIG_CPU, "1"); +#endif +#ifdef CONFIG_CPU_2 + apply_builtin_macro(CONFIG_CPU_2, "1"); +#endif + +#ifdef CONFIG_SIZE + apply_builtin_macro(CONFIG_SIZE, "1"); +#endif +#ifdef CONFIG_BINFMT + apply_builtin_macro(CONFIG_BINFMT, "1"); +#endif + +#ifdef CONFIG_COMPILER + apply_builtin_macro(CONFIG_COMPILER, VERSION_MAJOR); + apply_builtin_macro(CONFIG_COMPILER_MINOR, VERSION_MINOR); + apply_builtin_macro("__VERSION__", VERSION_LONG); +#endif +} + +//////////////////////////////////////////////////////////// +// extra included files + +struct commandline_file { + char *name; + bool suppress_output; +}; + +static struct array commandline_files; + +static +void +commandline_files_init(void) +{ + array_init(&commandline_files); +} + +static +void +commandline_files_cleanup(void) +{ + array_cleanup(&commandline_files); +} + +static +void +commandline_addfile(char *name, bool suppress_output) +{ + struct commandline_file *cf; + + cf = domalloc(sizeof(*cf)); + cf->name = name; + cf->suppress_output = suppress_output; + array_add(&commandline_files, cf, NULL); +} + +static +void +commandline_addfile_output(char *name) +{ + commandline_addfile(name, false); +} + +static +void +commandline_addfile_nooutput(char *name) +{ + commandline_addfile(name, true); +} + +static +void +read_commandline_files(void) +{ + struct commandline_file *cf; + unsigned i, num; + bool save = false; + + num = array_num(&commandline_files); + for (i=0; i<num; i++) { + cf = array_get(&commandline_files, i); + if (cf->suppress_output) { + save = mode.do_output; + mode.do_output = false; + files_read(NULL, cf->name); + mode.do_output = save; + } else { + files_read(NULL, cf->name); + } + } +} + +//////////////////////////////////////////////////////////// +// include path accumulation + +static struct stringarray incpath_quote; +static struct stringarray incpath_user; +static struct stringarray incpath_system; +static struct stringarray incpath_late; +static const char *sysroot; + +static +void +incpath_init(void) +{ + stringarray_init(&incpath_quote); + stringarray_init(&incpath_user); + stringarray_init(&incpath_system); + stringarray_init(&incpath_late); +} + +static +void +incpath_cleanup(void) +{ + stringarray_cleanup(&incpath_quote); + stringarray_cleanup(&incpath_user); + stringarray_cleanup(&incpath_system); + stringarray_cleanup(&incpath_late); +} + +static +void +commandline_isysroot(char *dir) +{ + sysroot = dir; +} + +static +void +commandline_addincpath(struct stringarray *arr, char *s) +{ + stringarray_add(arr, s, NULL); +} + +static +void +commandline_addincpath_quote(char *dir) +{ + commandline_addincpath(&incpath_quote, dir); +} + +static +void +commandline_addincpath_user(char *dir) +{ + commandline_addincpath(&incpath_user, dir); +} + +static +void +commandline_addincpath_system(char *dir) +{ + commandline_addincpath(&incpath_system, dir); +} + +static +void +commandline_addincpath_late(char *dir) +{ + commandline_addincpath(&incpath_late, dir); +} + +static +void +loadincludepath(void) +{ + unsigned i, num; + const char *dir; + char *t; + + num = stringarray_num(&incpath_quote); + for (i=0; i<num; i++) { + dir = stringarray_get(&incpath_quote, i); + files_addquotepath(dir, false); + } + files_addquotepath(".", false); + + num = stringarray_num(&incpath_user); + for (i=0; i<num; i++) { + dir = stringarray_get(&incpath_user, i); + files_addquotepath(dir, false); + files_addbracketpath(dir, false); + } + + if (mode.do_stdinc) { + if (sysroot != NULL) { + t = dostrdup3(sysroot, "/", CONFIG_LOCALINCLUDE); + freestringlater(t); + dir = t; + } else { + dir = CONFIG_LOCALINCLUDE; + } + files_addquotepath(dir, true); + files_addbracketpath(dir, true); + + if (sysroot != NULL) { + t = dostrdup3(sysroot, "/", CONFIG_SYSTEMINCLUDE); + freestringlater(t); + dir = t; + } else { + dir = CONFIG_SYSTEMINCLUDE; + } + files_addquotepath(dir, true); + files_addbracketpath(dir, true); + } + + num = stringarray_num(&incpath_system); + for (i=0; i<num; i++) { + dir = stringarray_get(&incpath_system, i); + files_addquotepath(dir, true); + files_addbracketpath(dir, true); + } + + num = stringarray_num(&incpath_late); + for (i=0; i<num; i++) { + dir = stringarray_get(&incpath_late, i); + files_addquotepath(dir, false); + files_addbracketpath(dir, false); + } +} + +//////////////////////////////////////////////////////////// +// silly commandline stuff + +static const char *commandline_prefix; + +static +void +commandline_setprefix(char *prefix) +{ + commandline_prefix = prefix; +} + +static +void +commandline_addincpath_user_withprefix(char *dir) +{ + char *s; + + if (commandline_prefix == NULL) { + warnx("-iprefix needed"); + die(); + } + s = dostrdup3(commandline_prefix, "/", dir); + freestringlater(s); + commandline_addincpath_user(s); +} + +static +void +commandline_addincpath_late_withprefix(char *dir) +{ + char *s; + + if (commandline_prefix == NULL) { + warnx("-iprefix needed"); + die(); + } + s = dostrdup3(commandline_prefix, "/", dir); + freestringlater(s); + commandline_addincpath_late(s); +} + +static +void +commandline_setstd(char *std) +{ + if (!strcmp(std, "krc")) { + return; + } + warnx("Standard %s not supported by this preprocessor", std); + die(); +} + +static +void +commandline_setlang(char *lang) +{ + if (!strcmp(lang, "c") || !strcmp(lang, "assembler-with-cpp")) { + return; + } + warnx("Language %s not supported by this preprocessor", lang); + die(); +} + +//////////////////////////////////////////////////////////// +// complex modes + +static +void +commandline_iremap(char *str) +{ + /* XXX */ + warnx("-iremap not supported"); + die(); +} + +static +void +commandline_tabstop(char *s) +{ + char *t; + unsigned long val; + + t = strchr(s, '='); + if (t == NULL) { + /* should not happen */ + warnx("Invalid tabstop"); + die(); + } + t++; + errno = 0; + val = strtoul(t, &t, 10); + if (errno || *t != '\0') { + warnx("Invalid tabstop"); + die(); + } + if (val > 64) { + warnx("Preposterously large tabstop"); + die(); + } + mode.input_tabstop = val; +} + +/* + * macrolist + */ + +static +void +commandline_dD(void) +{ + mode.do_macrolist = true; + mode.macrolist_include_stddef = false; + mode.macrolist_include_expansions = true; +} + +static +void +commandline_dM(void) +{ + mode.do_macrolist = true; + mode.macrolist_include_stddef = true; + mode.macrolist_include_expansions = true; + mode.do_output = false; +} + +static +void +commandline_dN(void) +{ + mode.do_macrolist = true; + mode.macrolist_include_stddef = false; + mode.macrolist_include_expansions = false; +} + +/* + * include trace + */ + +static +void +commandline_dI(void) +{ + mode.do_trace = true; + mode.trace_namesonly = false; + mode.trace_indented = false; +} + +static +void +commandline_H(void) +{ + mode.do_trace = true; + mode.trace_namesonly = true; + mode.trace_indented = true; +} + +/* + * depend + */ + +static +void +commandline_setdependtarget(char *str) +{ + mode.depend_target = str; + mode.depend_quote_target = false; +} + +static +void +commandline_setdependtarget_quoted(char *str) +{ + mode.depend_target = str; + mode.depend_quote_target = true; +} + +static +void +commandline_setdependoutput(char *str) +{ + mode.depend_file = str; +} + +static +void +commandline_M(void) +{ + mode.do_depend = true; + mode.depend_report_system = true; + mode.do_output = false; +} + +static +void +commandline_MM(void) +{ + mode.do_depend = true; + mode.depend_report_system = false; + mode.do_output = false; +} + +static +void +commandline_MD(void) +{ + mode.do_depend = true; + mode.depend_report_system = true; +} + +static +void +commandline_MMD(void) +{ + mode.do_depend = true; + mode.depend_report_system = false; +} + +static +void +commandline_wall(void) +{ + warns.nestcomment = true; + warns.undef = true; + warns.unused = true; +} + +static +void +commandline_wnoall(void) +{ + warns.nestcomment = false; + warns.undef = false; + warns.unused = false; +} + +static +void +commandline_wnone(void) +{ + warns.nestcomment = false; + warns.endiflabels = false; + warns.undef = false; + warns.unused = false; +} + +//////////////////////////////////////////////////////////// +// options + +struct flag_option { + const char *string; + bool *flag; + bool setto; +}; + +struct act_option { + const char *string; + void (*func)(void); +}; + +struct prefix_option { + const char *string; + void (*func)(char *); +}; + +struct arg_option { + const char *string; + void (*func)(char *); +}; + +static const struct flag_option flag_options[] = { + { "C", &mode.output_retain_comments, true }, + { "CC", &mode.output_retain_comments, true }, + { "fdollars-in-identifiers", &mode.input_allow_dollars, true }, + { "fno-dollars-in-identifiers", &mode.input_allow_dollars, false }, + { "MG", &mode.depend_assume_generated, true }, + { "MP", &mode.depend_issue_fakerules, true }, + { "nostdinc", &mode.do_stdinc, false }, + { "P", &mode.output_linenumbers, false }, + { "undef", &mode.do_stddef, false }, + { "Wcomment", &warns.nestcomment, true }, + { "Wendif-labels", &warns.endiflabels, true }, + { "Werror", &mode.werror, true }, + { "Wno-comment", &warns.nestcomment, false }, + { "Wno-endif-labels", &warns.endiflabels, false }, + { "Wno-error", &mode.werror, false }, + { "Wno-undef", &warns.undef, false }, + { "Wno-unused-macros", &warns.unused, false }, + { "Wundef", &warns.undef, true }, + { "Wunused-macros", &warns.unused, true }, +}; +static const unsigned num_flag_options = HOWMANY(flag_options); + +static const struct act_option act_options[] = { + { "dD", commandline_dD }, + { "dI", commandline_dI }, + { "dM", commandline_dM }, + { "dN", commandline_dN }, + { "H", commandline_H }, + { "M", commandline_M }, + { "MD", commandline_MD }, + { "MM", commandline_MM }, + { "MMD", commandline_MMD }, + { "Wall", commandline_wall }, + { "Wno-all", commandline_wnoall }, + { "w", commandline_wnone }, +}; +static const unsigned num_act_options = HOWMANY(act_options); + +static const struct prefix_option prefix_options[] = { + { "D", commandline_def }, + { "ftabstop=", commandline_tabstop }, + { "I", commandline_addincpath_user }, + { "std=", commandline_setstd }, + { "U", commandline_undef }, +}; +static const unsigned num_prefix_options = HOWMANY(prefix_options); + +static const struct arg_option arg_options[] = { + { "idirafter", commandline_addincpath_late }, + { "imacros", commandline_addfile_nooutput }, + { "include", commandline_addfile_output }, + { "iprefix", commandline_setprefix }, + { "iquote", commandline_addincpath_quote }, + { "iremap", commandline_iremap }, + { "isysroot", commandline_isysroot }, + { "isystem", commandline_addincpath_system }, + { "iwithprefix", commandline_addincpath_late_withprefix }, + { "iwithprefixbefore", commandline_addincpath_user_withprefix }, + { "MF", commandline_setdependoutput }, + { "MT", commandline_setdependtarget }, + { "MQ", commandline_setdependtarget_quoted }, + { "x", commandline_setlang }, +}; +static const unsigned num_arg_options = HOWMANY(arg_options); + +static +bool +check_flag_option(const char *opt) +{ + unsigned i; + int r; + + for (i=0; i<num_flag_options; i++) { + r = strcmp(opt, flag_options[i].string); + if (r == 0) { + *flag_options[i].flag = flag_options[i].setto; + return true; + } + if (r < 0) { + break; + } + } + return false; +} + +static +bool +check_act_option(const char *opt) +{ + unsigned i; + int r; + + for (i=0; i<num_act_options; i++) { + r = strcmp(opt, act_options[i].string); + if (r == 0) { + act_options[i].func(); + return true; + } + if (r < 0) { + break; + } + } + return false; +} + +static +bool +check_prefix_option(char *opt) +{ + unsigned i; + int r; + + for (i=0; i<num_prefix_options; i++) { + r = strncmp(opt, prefix_options[i].string, + strlen(prefix_options[i].string)); + if (r == 0) { + prefix_options[i].func(opt); + return true; + } + if (r < 0) { + break; + } + } + return false; +} + +static +bool +check_arg_option(const char *opt, char *arg) +{ + unsigned i; + int r; + + for (i=0; i<num_arg_options; i++) { + r = strcmp(opt, arg_options[i].string); + if (r == 0) { + if (arg == NULL) { + warnx("Option -%s requires an argument", opt); + die(); + } + arg_options[i].func(arg); + return true; + } + if (r < 0) { + break; + } + } + return false; +} + +static +void +usage(void) +{ + fprintf(stderr, "Usage: %s [options] [infile [outfile]]\n", + getprogname()); + fprintf(stderr, "Common options:\n"); + fprintf(stderr, " -C Retain comments\n"); + fprintf(stderr, " -Dmacro[=def] Predefine macro\n"); + fprintf(stderr, " -Idir Add to include path\n"); + fprintf(stderr, " -M Issue depend info\n"); + fprintf(stderr, " -MD Issue depend info and output\n"); + fprintf(stderr, " -MM -M w/o system headers\n"); + fprintf(stderr, " -MMD -MD w/o system headers\n"); + fprintf(stderr, " -nostdinc Drop default include path\n"); + fprintf(stderr, " -Umacro Undefine macro\n"); + fprintf(stderr, " -undef Undefine everything\n"); + fprintf(stderr, " -Wall Enable all warnings\n"); + fprintf(stderr, " -Werror Make warnings into errors\n"); + fprintf(stderr, " -w Disable all warnings\n"); + die(); +} + +//////////////////////////////////////////////////////////// +// exit and cleanup + +static struct stringarray freestrings; + +static +void +init(void) +{ + stringarray_init(&freestrings); + incpath_init(); + commandline_macros_init(); + commandline_files_init(); +} + +static +void +cleanup(void) +{ + unsigned i, num; + + commandline_files_cleanup(); + commandline_macros_cleanup(); + incpath_cleanup(); + + num = stringarray_num(&freestrings); + for (i=0; i<num; i++) { + free(stringarray_get(&freestrings, i)); + } + stringarray_setsize(&freestrings, 0); + stringarray_cleanup(&freestrings); +} + +void +die(void) +{ + cleanup(); + exit(EXIT_FAILURE); +} + +void +freestringlater(char *s) +{ + stringarray_add(&freestrings, s, NULL); +} + +//////////////////////////////////////////////////////////// +// main + +int +main(int argc, char *argv[]) +{ + const char *inputfile = NULL; + const char *outputfile = NULL; + int i; + + init(); + + for (i=1; i<argc; i++) { + if (argv[i][0] != '-') { + break; + } + if (check_flag_option(argv[i]+1)) { + continue; + } + if (check_act_option(argv[i]+1)) { + continue; + } + if (check_prefix_option(argv[i]+1)) { + continue; + } + if (check_arg_option(argv[i]+1, argv[i+1])) { + i++; + continue; + } + usage(); + } + if (i < argc) { + inputfile = argv[i++]; + } + if (i < argc) { + outputfile = argv[i++]; + } + if (i < argc) { + usage(); + } + + mode.output_file = outputfile; + + loadincludepath(); + apply_builtin_macros(); + apply_commandline_macros(); + read_commandline_files(); + files_read(NULL, inputfile); + + cleanup(); + return EXIT_SUCCESS; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mode.h Sun Dec 19 17:52:59 2010 -0500 @@ -0,0 +1,34 @@ +struct mode { + bool werror; + bool input_allow_dollars; + unsigned input_tabstop; + bool do_stdinc; + bool do_stddef; + bool do_output; + bool output_linenumbers; + bool output_retain_comments; + const char *output_file; + bool do_depend; + bool depend_report_system; + bool depend_assume_generated; + bool depend_issue_fakerules; + bool depend_quote_target; + const char *depend_target; + const char *depend_file; + bool do_macrolist; + bool macrolist_include_stddef; + bool macrolist_include_expansions; + bool do_trace; + bool trace_namesonly; + bool trace_indented; +}; + +struct warns { + bool endiflabels; + bool nestcomment; + bool undef; + bool unused; +}; + +extern struct mode mode; +extern struct warns warns;