| /* | |
| * options.c - Process options from "treecc" input files. | |
| * | |
| * Copyright (C) 2001 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 "system.h" | |
| #include "input.h" | |
| #include "info.h" | |
| #include "options.h" | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| /* | |
| * "track_lines": track line numbers when creating new nodes. | |
| */ | |
| static int TrackLinesOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->track_lines = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "no_singletons": suppress special create code for singletons. | |
| */ | |
| static int NoSingletonsOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->no_singletons = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "reentrant": generate re-entrant tree handling code. | |
| */ | |
| static int ReentrantOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->reentrant = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "force": force source files to be created even if unchanged. | |
| */ | |
| static int ForceOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->force = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "virtual_factory": use virtual factory methods. | |
| */ | |
| static int VirtualFactoryOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->virtual_factory = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "abstract_factory": use abstract factory methods. | |
| */ | |
| static int AbstractFactoryOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->abstract_factory = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "kind_in_vtable": put the kind value in the vtable, and not the node. | |
| */ | |
| static int KindInVtableOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->kind_in_vtable = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "prefix": specify the prefix to use instead of "yy". | |
| */ | |
| static int PrefixOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(!value) | |
| { | |
| return TREECC_OPT_NEED_VALUE; | |
| } | |
| else | |
| { | |
| context->yy_replacement = value; | |
| return TREECC_OPT_KEEP_VALUE; | |
| } | |
| } | |
| /* | |
| * "state_type": specify the type name to use for re-entrant state. | |
| */ | |
| static int StateTypeOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(!value) | |
| { | |
| return TREECC_OPT_NEED_VALUE; | |
| } | |
| else | |
| { | |
| context->state_type = value; | |
| return TREECC_OPT_KEEP_VALUE; | |
| } | |
| } | |
| /* | |
| * "namespace": specify the namespace to use for subsequent definitions. | |
| */ | |
| static int NamespaceOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(!value) | |
| { | |
| return TREECC_OPT_NEED_VALUE; | |
| } | |
| else if(*value == '\0') | |
| { | |
| /* Put following declarations into the global namespace */ | |
| context->namespace = 0; | |
| return TREECC_OPT_OK; | |
| } | |
| else | |
| { | |
| context->namespace = value; | |
| return TREECC_OPT_KEEP_VALUE; | |
| } | |
| } | |
| /* | |
| * "base": specify a new base to use for node type identifiers. | |
| */ | |
| static int BaseOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(!value) | |
| { | |
| return TREECC_OPT_NEED_VALUE; | |
| } | |
| else if(*value == '\0') | |
| { | |
| return TREECC_OPT_INVALID_VALUE; | |
| } | |
| else | |
| { | |
| int num = 0; | |
| while(*value >= '0' && *value <= '9') | |
| { | |
| num = num * 10 + (int)(*value - '0'); | |
| ++value; | |
| } | |
| if(*value != '\0') | |
| { | |
| return TREECC_OPT_INVALID_VALUE; | |
| } | |
| context->nodeNumber = num; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "lang": specify the source language to use in the output files. | |
| */ | |
| static int LangOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(!value) | |
| { | |
| return TREECC_OPT_NEED_VALUE; | |
| } | |
| else | |
| { | |
| if(!strcmp(value, "c") || !strcmp(value, "C")) | |
| { | |
| context->language = TREECC_LANG_C; | |
| } | |
| else if(!strcmp(value, "c++") || !strcmp(value, "C++")) | |
| { | |
| context->language = TREECC_LANG_CPP; | |
| } | |
| else if(!strcmp(value, "java") || !strcmp(value, "Java")) | |
| { | |
| context->language = TREECC_LANG_JAVA; | |
| } | |
| else if(!strcmp(value, "c#") || !strcmp(value, "C#") || | |
| !strcmp(value, "csharp")) | |
| { | |
| context->language = TREECC_LANG_CSHARP; | |
| } | |
| else if(!strcmp(value, "ruby") || !strcmp(value, "Ruby")) | |
| { | |
| context->language = TREECC_LANG_RUBY; | |
| } | |
| else if(!strcmp(value, "php") || !strcmp(value, "PHP")) | |
| { | |
| context->language = TREECC_LANG_PHP; | |
| } | |
| else | |
| { | |
| return TREECC_OPT_INVALID_VALUE; | |
| } | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "block_size": specify a new block size for C and C++ allocators. | |
| */ | |
| static int BlockSizeOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(!value) | |
| { | |
| return TREECC_OPT_NEED_VALUE; | |
| } | |
| else if(*value == '\0') | |
| { | |
| return TREECC_OPT_INVALID_VALUE; | |
| } | |
| else | |
| { | |
| int num = 0; | |
| while(*value >= '0' && *value <= '9') | |
| { | |
| num = num * 10 + (int)(*value - '0'); | |
| ++value; | |
| } | |
| if(*value != '\0') | |
| { | |
| return TREECC_OPT_INVALID_VALUE; | |
| } | |
| context->block_size = num; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "print_lines": print out line number directives. | |
| */ | |
| static int PrintLineNumberOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->print_lines = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "strip_filenames": strip filenames in #line directives down | |
| * to their base name, with no directory information. | |
| */ | |
| static int StripFilenamesOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->strip_filenames = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "internal_access": use "internal" access on classes in C#, instead | |
| * of using "public". "public_access" is used to select "public". | |
| */ | |
| static int InternalAccessOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->internal_access = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "allocator": use (or don't use) the standard treecc allocator for C/C++. | |
| */ | |
| static int AllocatorOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->use_allocator = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "gc_allocator": use (or don't use) the libgc treecc allocator for C/C++. | |
| */ | |
| static int GCAllocatorOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(value) | |
| { | |
| return TREECC_OPT_NO_VALUE; | |
| } | |
| else | |
| { | |
| context->use_gc_allocator = flag; | |
| return TREECC_OPT_OK; | |
| } | |
| } | |
| /* | |
| * "base_type": use the type as the base type for the root treecc node | |
| */ | |
| static int BaseTypeOption(TreeCCContext *context, char *value, int flag) | |
| { | |
| if(!value) | |
| { | |
| return TREECC_OPT_NEED_VALUE; | |
| } | |
| else if(value == '\0') | |
| { | |
| context->baseType = 0; | |
| return TREECC_OPT_OK; | |
| } | |
| else | |
| { | |
| context->baseType = value; | |
| return TREECC_OPT_KEEP_VALUE; | |
| } | |
| } | |
| /* | |
| * Table of option handlers. | |
| */ | |
| static struct | |
| { | |
| const char *name; | |
| int (*func)(TreeCCContext *context, char *value, int flag); | |
| int flag; | |
| } const OptionHandlers[] = { | |
| {"track_lines", TrackLinesOption, 1}, | |
| {"no_track_lines", TrackLinesOption, 0}, | |
| {"no_singletons", NoSingletonsOption, 1}, | |
| {"singletons", NoSingletonsOption, 0}, | |
| {"reentrant", ReentrantOption, 1}, | |
| {"no_reentrant", ReentrantOption, 0}, | |
| {"force", ForceOption, 1}, | |
| {"no_force", ForceOption, 0}, | |
| {"virtual_factory", VirtualFactoryOption, 1}, | |
| {"no_virtual_factory", VirtualFactoryOption, 0}, | |
| {"abstract_factory", AbstractFactoryOption, 1}, | |
| {"no_abstract_factory", AbstractFactoryOption, 0}, | |
| {"kind_in_vtable", KindInVtableOption, 1}, | |
| {"kind_in_node", KindInVtableOption, 0}, | |
| {"prefix", PrefixOption, 0}, | |
| {"state_type", StateTypeOption, 0}, | |
| {"namespace", NamespaceOption, 0}, | |
| {"package", NamespaceOption, 0}, | |
| {"base", BaseOption, 0}, | |
| {"lang", LangOption, 0}, | |
| {"block_size", BlockSizeOption, 0}, | |
| {"strip_filenames", StripFilenamesOption, 1}, | |
| {"print_lines", PrintLineNumberOption, 1}, | |
| {"no_print_lines", PrintLineNumberOption, 0}, | |
| {"no_strip_filenames", StripFilenamesOption, 0}, | |
| {"internal_access", InternalAccessOption, 1}, | |
| {"public_access", InternalAccessOption, 0}, | |
| {"allocator", AllocatorOption, 1}, | |
| {"no_allocator", AllocatorOption, 0}, | |
| {"gc_allocator", GCAllocatorOption, 1}, | |
| {"no_gc_allocator", GCAllocatorOption, 0}, | |
| {"base_type", BaseTypeOption, 0}, | |
| {0, 0, 0}, | |
| }; | |
| int TreeCCOptionProcess(TreeCCContext *context, char *name, char *value) | |
| { | |
| int opt = 0; | |
| while(OptionHandlers[opt].name != 0) | |
| { | |
| if(!strcmp(name, OptionHandlers[opt].name)) | |
| { | |
| return (*(OptionHandlers[opt].func)) | |
| (context, value, OptionHandlers[opt].flag); | |
| } | |
| ++opt; | |
| } | |
| return TREECC_OPT_UNKNOWN; | |
| } | |
| #ifdef __cplusplus | |
| }; | |
| #endif |