| /* | |
| * main.c - Main program entry point for "treecc". | |
| * | |
| * Copyright (C) 2001, 2002 Southern Storm Software, Pty Ltd. | |
| * | |
| * 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 "parse.h" | |
| #include "errors.h" | |
| #include "gen.h" | |
| #include "options.h" | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| static void Usage(char *progname); | |
| static void Version(void); | |
| static int ExtraOptions(TreeCCContext *context, char **options, int num); | |
| static char *GetDefault(const char *filename, const char *extension); | |
| int main(int argc, char *argv[]) | |
| { | |
| char *progname = argv[0]; | |
| char *opt; | |
| char *outputFile = NULL; | |
| char *headerFile = NULL; | |
| char *extension = "c"; | |
| char *outputDir = NULL; | |
| int forceCreate = 0; | |
| TreeCCInput input; | |
| TreeCCContext *context; | |
| int sawStdin = 0; | |
| int generateOutput = 1; | |
| FILE *file; | |
| int len, result; | |
| char **options = (char **)malloc(sizeof(char *) * argc); | |
| int num_options = 0; | |
| /* Allocate the array for external "%option" values */ | |
| options = (char **)malloc(sizeof(char *) * argc); | |
| if(!options) | |
| { | |
| TreeCCOutOfMemory(0); | |
| } | |
| /* Parse the command-line options */ | |
| while(argc > 1 && argv[1][0] == '-') | |
| { | |
| if(argv[1][1] == '\0') | |
| { | |
| /* The input is stdin */ | |
| break; | |
| } | |
| else if(argv[1][1] == '-') | |
| { | |
| /* The option begins with "--" */ | |
| if(argv[1][2] == '\0') | |
| { | |
| /* End of options, and start of filenames */ | |
| --argc; | |
| ++argv; | |
| break; | |
| } | |
| if(!strcmp(argv[1], "--output")) | |
| { | |
| --argc; | |
| ++argv; | |
| if(argc <= 1) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| outputFile = argv[1]; | |
| } | |
| else if(!strcmp(argv[1], "--header")) | |
| { | |
| --argc; | |
| ++argv; | |
| if(argc <= 1) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| headerFile = argv[1]; | |
| } | |
| else if(!strcmp(argv[1], "--output-dir")) | |
| { | |
| --argc; | |
| ++argv; | |
| if(argc <= 1) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| outputDir = argv[1]; | |
| } | |
| else if(!strcmp(argv[1], "--skeleton-dir")) | |
| { | |
| /* This option is obsolete: we still parse it just in | |
| case there are older build systems that expect it */ | |
| --argc; | |
| ++argv; | |
| if(argc <= 1) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| } | |
| else if(!strcmp(argv[1], "--extension")) | |
| { | |
| --argc; | |
| ++argv; | |
| if(argc <= 1) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| extension = argv[1]; | |
| } | |
| else if(!strcmp(argv[1], "--option")) | |
| { | |
| --argc; | |
| ++argv; | |
| if(argc <= 1) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| options[num_options++] = argv[1]; | |
| } | |
| else if(!strcmp(argv[1], "--force-create")) | |
| { | |
| forceCreate = 1; | |
| } | |
| else if(!strcmp(argv[1], "--no-output")) | |
| { | |
| generateOutput = 0; | |
| } | |
| else if(!strcmp(argv[1], "--help")) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| else if(!strcmp(argv[1], "--version")) | |
| { | |
| Version(); | |
| return 0; | |
| } | |
| else | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| } | |
| else | |
| { | |
| /* Single-character option */ | |
| opt = argv[1] + 1; | |
| while(*opt != '\0') | |
| { | |
| switch(*opt++) | |
| { | |
| case 'o': | |
| { | |
| if(*opt != '\0') | |
| { | |
| outputFile = opt; | |
| opt = ""; | |
| } | |
| else if(argc <= 2) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| else | |
| { | |
| --argc; | |
| ++argv; | |
| outputFile = argv[1]; | |
| } | |
| } | |
| break; | |
| case 'h': | |
| { | |
| if(*opt != '\0') | |
| { | |
| headerFile = opt; | |
| opt = ""; | |
| } | |
| else if(argc <= 2) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| else | |
| { | |
| --argc; | |
| ++argv; | |
| headerFile = argv[1]; | |
| } | |
| } | |
| break; | |
| case 'd': | |
| { | |
| if(*opt != '\0') | |
| { | |
| outputDir = opt; | |
| opt = ""; | |
| } | |
| else if(argc <= 2) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| else | |
| { | |
| --argc; | |
| ++argv; | |
| outputDir = argv[1]; | |
| } | |
| } | |
| break; | |
| case 's': | |
| { | |
| /* This option is obsolete: we still parse it just in | |
| case there are older build systems that expect it */ | |
| if(*opt != '\0') | |
| { | |
| opt = ""; | |
| } | |
| else if(argc <= 2) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| else | |
| { | |
| --argc; | |
| ++argv; | |
| } | |
| } | |
| break; | |
| case 'e': | |
| { | |
| if(*opt != '\0') | |
| { | |
| extension = opt; | |
| opt = ""; | |
| } | |
| else if(argc <= 2) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| else | |
| { | |
| --argc; | |
| ++argv; | |
| extension = argv[1]; | |
| } | |
| } | |
| break; | |
| case 'O': | |
| { | |
| if(*opt != '\0') | |
| { | |
| options[num_options++] = opt; | |
| opt = ""; | |
| } | |
| else if(argc <= 2) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| else | |
| { | |
| --argc; | |
| ++argv; | |
| options[num_options++] = argv[1]; | |
| } | |
| } | |
| break; | |
| case 'f': | |
| { | |
| forceCreate = 1; | |
| } | |
| break; | |
| case 'n': | |
| { | |
| generateOutput = 0; | |
| } | |
| break; | |
| case 'v': | |
| { | |
| Version(); | |
| return 0; | |
| } | |
| /* Not reached */ | |
| default: | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| /* Not reached */ | |
| } | |
| } | |
| } | |
| --argc; | |
| ++argv; | |
| } | |
| if(argc <= 1) | |
| { | |
| Usage(progname); | |
| return 1; | |
| } | |
| /* Determine the default output and header filenames */ | |
| if(!outputFile) | |
| { | |
| if(*extension == '.') | |
| { | |
| ++extension; | |
| } | |
| outputFile = GetDefault(argv[1], extension); | |
| } | |
| if(!headerFile) | |
| { | |
| headerFile = GetDefault(outputFile, "h"); | |
| } | |
| /* Initialize the input routines */ | |
| TreeCCOpen(&input, progname, NULL, NULL); | |
| /* Determine the default Java output directory */ | |
| if(!outputDir) | |
| { | |
| len = strlen(argv[1]); | |
| while(len > 0 && argv[1][len - 1] != '/' && argv[1][len - 1] != '\\') | |
| { | |
| --len; | |
| } | |
| if(len > 0) | |
| { | |
| --len; | |
| } | |
| if(len > 0) | |
| { | |
| outputDir = (char *)malloc(len + 1); | |
| if(!outputDir) | |
| { | |
| TreeCCOutOfMemory(&input); | |
| } | |
| strncpy(outputDir, argv[1], len); | |
| outputDir[len] = '\0'; | |
| } | |
| } | |
| /* Create the parsing context */ | |
| context = TreeCCContextCreate(&input); | |
| if(!context) | |
| { | |
| TreeCCOutOfMemory(&input); | |
| } | |
| context->force = forceCreate; | |
| context->outputDirectory = outputDir; | |
| /* Process additional options from the command-line */ | |
| if(!ExtraOptions(context, options, num_options)) | |
| { | |
| return 1; | |
| } | |
| free(options); | |
| /* Create the default source and header streams */ | |
| context->sourceStream = TreeCCStreamCreate(context, outputFile, | |
| NULL, 0); | |
| context->sourceStream->defaultFile = 1; | |
| context->headerStream = TreeCCStreamCreate(context, headerFile, | |
| NULL, 1); | |
| context->headerStream->defaultFile = 1; | |
| /* Process the input files */ | |
| while(argc > 1) | |
| { | |
| if(!strcmp(argv[1], "-")) | |
| { | |
| /* Parse stdin, but only once */ | |
| if(!sawStdin) | |
| { | |
| TreeCCOpen(&input, progname, stdin, "stdin"); | |
| TreeCCParse(context); | |
| TreeCCClose(&input, 0); | |
| sawStdin = 1; | |
| } | |
| } | |
| else | |
| { | |
| /* Parse some other file */ | |
| if((file = fopen(argv[1], "r")) == NULL) | |
| { | |
| perror(argv[1]); | |
| input.errors = 1; | |
| } | |
| else | |
| { | |
| TreeCCOpen(&input, progname, file, argv[1]); | |
| TreeCCParse(context); | |
| TreeCCClose(&input, 1); | |
| } | |
| } | |
| --argc; | |
| ++argv; | |
| } | |
| /* Validate node and operation coverage */ | |
| TreeCCNodeValidate(context); | |
| TreeCCOperationValidate(context); | |
| /* Abort if we encountered errors during parsing and validation */ | |
| if(input.errors) | |
| { | |
| TreeCCContextDestroy(context); | |
| return 1; | |
| } | |
| /* Generate the output files */ | |
| result = 0; | |
| if(generateOutput) | |
| { | |
| TreeCCStream *stream; | |
| TreeCCGenerate(context); | |
| stream = context->streamList; | |
| while(stream != 0) | |
| { | |
| if(!TreeCCStreamFlush(stream)) | |
| { | |
| result = 1; | |
| } | |
| stream = stream->nextStream; | |
| } | |
| } | |
| /* Done */ | |
| TreeCCContextDestroy(context); | |
| return result; | |
| } | |
| static void Usage(char *progname) | |
| { | |
| fprintf(stderr, "TREECC " VERSION " - Tree Compiler-Compiler\n"); | |
| fprintf(stderr, "Copyright (c) 2001, 2002 Southern Storm Software, Pty Ltd.\n"); | |
| fprintf(stderr, "\n"); | |
| fprintf(stderr, "Usage: %s [options] input ...\n", progname); | |
| fprintf(stderr, "\n"); | |
| fprintf(stderr, " -o file, --output file\n"); | |
| fprintf(stderr, " Set the name of the output file.\n"); | |
| fprintf(stderr, " -h file, --header file\n"); | |
| fprintf(stderr, " Set the name of the header output file.\n"); | |
| fprintf(stderr, " -d dir, --output-dir file\n"); | |
| fprintf(stderr, " Set the name of the Java output directory.\n"); | |
| fprintf(stderr, " -e ext, --extension ext\n"); | |
| fprintf(stderr, " Set the output file extension (default is \".c\").\n"); | |
| fprintf(stderr, " -f, --force-create\n"); | |
| fprintf(stderr, " Force the creation of unchanged output files.\n"); | |
| fprintf(stderr, " -O opt, --option opt\n"); | |
| fprintf(stderr, " Set a treecc source option value.\n"); | |
| fprintf(stderr, " --help\n"); | |
| fprintf(stderr, " Print this help message.\n"); | |
| fprintf(stderr, " -v, --version\n"); | |
| fprintf(stderr, " Print the program version.\n"); | |
| } | |
| static void Version(void) | |
| { | |
| printf("TREECC " VERSION " - Tree Compiler-Compiler\n"); | |
| printf("Copyright (c) 2001, 2002 Southern Storm Software, Pty Ltd.\n"); | |
| printf("\n"); | |
| printf("TREECC comes with ABSOLUTELY NO WARRANTY. This is free software,\n"); | |
| printf("and you are welcome to redistribute it under the terms of the\n"); | |
| printf("GNU General Public License. See the file COPYING for further details.\n"); | |
| printf("\n"); | |
| printf("Use the `--help' option to get help on the command-line options.\n"); | |
| } | |
| /* | |
| * Process extra treecc "%option" values from the command-line. | |
| */ | |
| static int ExtraOptions(TreeCCContext *context, char **options, int num) | |
| { | |
| char *name; | |
| char *value; | |
| while(num-- > 0) | |
| { | |
| name = *options++; | |
| value = name; | |
| while(*value != '\0' && *value != '=') | |
| { | |
| ++value; | |
| } | |
| if(*value == '\0') | |
| { | |
| value = 0; | |
| } | |
| else | |
| { | |
| *value++ = '\0'; | |
| } | |
| if(TreeCCOptionProcess(context, name, value) != TREECC_OPT_OK) | |
| { | |
| fprintf(stderr, "%s: unknown option or invalid value\n", name); | |
| return 0; | |
| } | |
| } | |
| return 1; | |
| } | |
| /* | |
| * Get a default output or header filename from an input filename. | |
| */ | |
| static char *GetDefault(const char *filename, const char *extension) | |
| { | |
| int len; | |
| char *name; | |
| /* USe a default filename pattern if we are reading from stdin */ | |
| if(!strcmp(filename, "-")) | |
| { | |
| filename = "yy_tree.tc"; | |
| } | |
| /* Find the end of the input filename, without its extension */ | |
| len = strlen(filename); | |
| while(len > 0 && filename[len - 1] != '/' && filename[len - 1] != '\\' && | |
| filename[len - 1] != '.') | |
| { | |
| --len; | |
| } | |
| /* Construct the new filename */ | |
| if(len > 0 && filename[len - 1] == '.') | |
| { | |
| name = (char *)malloc(len + strlen(extension) + 1); | |
| if(!name) | |
| { | |
| TreeCCOutOfMemory((TreeCCInput *)0); | |
| } | |
| strncpy(name, filename, len); | |
| strcpy(name + len, extension); | |
| } | |
| else | |
| { | |
| len = strlen(filename); | |
| name = (char *)malloc(len + strlen(extension) + 2); | |
| if(!name) | |
| { | |
| TreeCCOutOfMemory((TreeCCInput *)0); | |
| } | |
| strcpy(name, filename); | |
| name[len] = '.'; | |
| strcpy(name + len + 1, extension); | |
| } | |
| return name; | |
| } | |
| #ifdef __cplusplus | |
| }; | |
| #endif |