build system: remove loeftover (two empty dirs)
No binary (build failed)
—
(log yok)
| @@ -1,255 +0,0 @@ | |
| - | Introduction |
| - | ------------ |
| - | |
| - | The configuration database is collection of configuration options |
| - | organized in a tree structure: |
| - | |
| - | +- Code maturity level options |
| - | | +- Prompt for development and/or incomplete code/drivers |
| - | +- General setup |
| - | | +- Networking support |
| - | | +- System V IPC |
| - | | +- BSD Process Accounting |
| - | | +- Sysctl support |
| - | +- Loadable module support |
| - | | +- Enable loadable module support |
| - | | +- Set version information on all module symbols |
| - | | +- Kernel module loader |
| - | +- ... |
| - | |
| - | Every entry has its own dependencies. These dependencies are used |
| - | to determine the visible of an entry. Any child entry is only |
| - | visible if its parent entry is also visible. |
| - | |
| - | Menu entries |
| - | ------------ |
| - | |
| - | Most entries define a config option, all other entries help to organize |
| - | them. A single configuration option is defined like this: |
| - | |
| - | config MODVERSIONS |
| - | bool "Set version information on all module symbols" |
| - | depends MODULES |
| - | help |
| - | Usually, modules have to be recompiled whenever you switch to a new |
| - | kernel. ... |
| - | |
| - | Every line starts with a key word and can be followed by multiple |
| - | arguments. "config" starts a new config entry. The following lines |
| - | define attributes for this config option. Attributes can be the type of |
| - | the config option, input prompt, dependencies, help text and default |
| - | values. A config option can be defined multiple times with the same |
| - | name, but every definition can have only a single input prompt and the |
| - | type must not conflict. |
| - | |
| - | Menu attributes |
| - | --------------- |
| - | |
| - | A menu entry can have a number of attributes. Not all of them are |
| - | applicable everywhere (see syntax). |
| - | |
| - | - type definition: "bool"/"tristate"/"string"/"hex"/"integer" |
| - | Every config option must have a type. There are only two basic types: |
| - | tristate and string, the other types base on these two. The type |
| - | definition optionally accepts an input prompt, so these two examples |
| - | are equivalent: |
| - | |
| - | bool "Networking support" |
| - | and |
| - | bool |
| - | prompt "Networking support" |
| - | |
| - | - input prompt: "prompt" <prompt> ["if" <expr>] |
| - | Every menu entry can have at most one prompt, which is used to display |
| - | to the user. Optionally dependencies only for this prompt can be added |
| - | with "if". |
| - | |
| - | - default value: "default" <symbol> ["if" <expr>] |
| - | A config option can have any number of default values. If multiple |
| - | default values are visible, only the first defined one is active. |
| - | Default values are not limited to the menu entry, where they are |
| - | defined, this means the default can be defined somewhere else or be |
| - | overridden by an earlier definition. |
| - | The default value is only assigned to the config symbol if no other |
| - | value was set by the user (via the input prompt above). If an input |
| - | prompt is visible the default value is presented to the user and can |
| - | be overridden by him. |
| - | Optionally dependencies only for this default value can be added with |
| - | "if". |
| - | |
| - | - dependencies: "depends on"/"requires" <expr> |
| - | This defines a dependency for this menu entry. If multiple |
| - | dependencies are defined they are connected with '&&'. Dependencies |
| - | are applied to all other options within this menu entry (which also |
| - | accept "if" expression), so these two examples are equivalent: |
| - | |
| - | bool "foo" if BAR |
| - | default y if BAR |
| - | and |
| - | depends on BAR |
| - | bool "foo" |
| - | default y |
| - | |
| - | - help text: "help" |
| - | This defines a help text. The end of the help text is determined by |
| - | the level indentation, this means it ends at the first line which has |
| - | a smaller indentation than the first line of the help text. |
| - | |
| - | |
| - | Menu dependencies |
| - | ----------------- |
| - | |
| - | Dependencies define the visibility of a menu entry and can also reduce |
| - | the input range of tristate symbols. The tristate logic used in the |
| - | expressions uses one more state than normal boolean logic to express the |
| - | module state. Dependency expressions have the following syntax: |
| - | |
| - | <expr> ::= <symbol> (1) |
| - | <symbol> '=' <symbol> (2) |
| - | <symbol> '!=' <symbol> (3) |
| - | '(' <expr> ')' (4) |
| - | '!' <expr> (5) |
| - | <expr> '||' <expr> (6) |
| - | <expr> '&&' <expr> (7) |
| - | |
| - | Expressions are listed in decreasing order of precedence. |
| - | |
| - | (1) Convert the symbol into an expression. Boolean and tristate symbols |
| - | are simply converted into the respective expression values. All |
| - | other symbol types result in 'n'. |
| - | (2) If the values of both symbols are equal, it returns 'y', |
| - | otherwise 'n'. |
| - | (3) If the values of both symbols are equal, it returns 'n', |
| - | otherwise 'y'. |
| - | (4) Returns the value of the expression. Used to override precedence. |
| - | (5) Returns the result of (2-/expr/). |
| - | (6) Returns the result of min(/expr/, /expr/). |
| - | (7) Returns the result of max(/expr/, /expr/). |
| - | |
| - | An expression can have a value of 'n', 'm' or 'y' (or 0, 1, 2 |
| - | respectively for calculations). A menu entry becomes visible when it's |
| - | expression evaluates to 'm' or 'y'. |
| - | |
| - | There are two type of symbols: constant and nonconstant symbols. |
| - | Nonconstant symbols are the most common ones and are defined with the |
| - | 'config' statement. Nonconstant symbols consist entirely of alphanumeric |
| - | characters or underscores. |
| - | Constant symbols are only part of expressions. Constant symbols are |
| - | always surrounded by single or double quotes. Within the quote any |
| - | other character is allowed and the quotes can be escaped using '\'. |
| - | |
| - | Menu structure |
| - | -------------- |
| - | |
| - | The position of a menu entry in the tree is determined in two ways. First |
| - | it can be specified explicitely: |
| - | |
| - | menu "Network device support" |
| - | depends NET |
| - | |
| - | config NETDEVICES |
| - | ... |
| - | |
| - | endmenu |
| - | |
| - | All entries within the "menu" ... "endmenu" block become a submenu of |
| - | "Network device support". All subentries inherit the dependencies from |
| - | the menu entry, e.g. this means the dependency "NET" is added to the |
| - | dependency list of the config option NETDEVICES. |
| - | |
| - | The other way to generate the menu structure is done by analyzing the |
| - | dependencies. If a menu entry somehow depends on the previous entry, it |
| - | can be made a submenu of it. First the the previous (parent) symbol must |
| - | be part of the dependency list and then one of these two condititions |
| - | must be true: |
| - | - the child entry must become invisible, if the parent is set to 'n' |
| - | - the child entry must only be visible, if the parent is visible |
| - | |
| - | config MODULES |
| - | bool "Enable loadable module support" |
| - | |
| - | config MODVERSIONS |
| - | bool "Set version information on all module symbols" |
| - | depends MODULES |
| - | |
| - | comment "module support disabled" |
| - | depends !MODULES |
| - | |
| - | MODVERSIONS directly depends on MODULES, this means it's only visible if |
| - | MODULES is different from 'n'. The comment on the other hand is always |
| - | visible when MODULES it's visible (the (empty) dependency of MODULES is |
| - | also part of the comment dependencies). |
| - | |
| - | |
| - | Kconfig syntax |
| - | -------------- |
| - | |
| - | The configuration file describes a series of menu entries, where every |
| - | line starts with a keyword (except help texts). The following keywords |
| - | end a menu entry: |
| - | - config |
| - | - choice/endchoice |
| - | - comment |
| - | - menu/endmenu |
| - | - if/endif |
| - | - source |
| - | The first four also start the definition of a menu entry. |
| - | |
| - | config: |
| - | |
| - | "config" <symbol> |
| - | <config options> |
| - | |
| - | This defines a config symbol <symbol> and accepts any of above |
| - | attributes as options. |
| - | |
| - | choices: |
| - | |
| - | "choice" |
| - | <choice options> |
| - | <choice block> |
| - | "endchoice" |
| - | |
| - | This defines a choice group and accepts any of above attributes as |
| - | options. A choice can only be of type bool or tristate, while a boolean |
| - | choice only allows a single config entry to be selected, a tristate |
| - | choice also allows any number of config entries to be set to 'm'. This |
| - | can be used if multiple drivers for a single hardware exists and only a |
| - | single driver can be compiled/loaded into the kernel, but all drivers |
| - | can be compiled as modules. |
| - | A choice accepts another option "optional", which allows to set the |
| - | choice to 'n' and no entry needs to be selected. |
| - | |
| - | comment: |
| - | |
| - | "comment" <prompt> |
| - | <comment options> |
| - | |
| - | This defines a comment which is displayed to the user during the |
| - | configuration process and is also echoed to the output files. The only |
| - | possible options are dependencies. |
| - | |
| - | menu: |
| - | |
| - | "menu" <prompt> |
| - | <menu options> |
| - | <menu block> |
| - | "endmenu" |
| - | |
| - | This defines a menu block, see "Menu structure" above for more |
| - | information. The only possible options are dependencies. |
| - | |
| - | if: |
| - | |
| - | "if" <expr> |
| - | <if block> |
| - | "endif" |
| - | |
| - | This defines an if block. The dependency expression <expr> is appended |
| - | to all enclosed menu entries. |
| - | |
| - | source: |
| - | |
| - | "source" <prompt> |
| - | |
| - | This reads the specified configuration file. This file is always parsed. |
| @@ -1,122 +0,0 @@ | |
| - | # Makefile for BusyBox |
| - | # |
| - | # Copyright (C) 2002 Erik Andersen <[email protected]> |
| - | |
| - | top_srcdir=../.. |
| - | top_builddir=../.. |
| - | srcdir=$(top_srcdir)/scripts/config |
| - | include $(top_srcdir)/Rules.mak |
| - | |
| - | all: ncurses conf mconf |
| - | |
| - | ifeq ($(shell uname),SunOS) |
| - | LIBS = -lcurses |
| - | else |
| - | LIBS = -lncurses |
| - | endif |
| - | ifeq (/usr/include/ncurses/ncurses.h, $(wildcard /usr/include/ncurses/ncurses.h)) |
| - | HOSTNCURSES += -I/usr/include/ncurses -DCURSES_LOC="<ncurses.h>" |
| - | else |
| - | ifeq (/usr/include/ncurses/curses.h, $(wildcard /usr/include/ncurses/curses.h)) |
| - | HOSTNCURSES += -I/usr/include/ncurses -DCURSES_LOC="<ncurses/curses.h>" |
| - | else |
| - | ifeq (/usr/local/include/ncurses/ncurses.h, $(wildcard /usr/local/include/ncurses/ncurses.h)) |
| - | HOSTCFLAGS += -I/usr/local/include/ncurses -DCURSES_LOC="<ncurses.h>" |
| - | else |
| - | ifeq (/usr/local/include/ncurses/curses.h, $(wildcard /usr/local/include/ncurses/curses.h)) |
| - | HOSTCFLAGS += -I/usr/local/include/ncurses -DCURSES_LOC="<ncurses/curses.h>" |
| - | else |
| - | ifeq (/usr/include/ncurses.h, $(wildcard /usr/include/ncurses.h)) |
| - | HOSTNCURSES += -DCURSES_LOC="<ncurses.h>" |
| - | else |
| - | HOSTNCURSES += -DCURSES_LOC="<curses.h>" |
| - | endif |
| - | endif |
| - | endif |
| - | endif |
| - | endif |
| - | |
| - | CONF_SRC = conf.c |
| - | MCONF_SRC = mconf.c |
| - | LXD_SRC = lxdialog/checklist.c lxdialog/menubox.c lxdialog/textbox.c \ |
| - | lxdialog/yesno.c lxdialog/inputbox.c lxdialog/util.c \ |
| - | lxdialog/msgbox.c |
| - | |
| - | SHARED_SRC = zconf.tab.c |
| - | SHARED_DEPS := $(srcdir)/lkc.h $(srcdir)/lkc_proto.h \ |
| - | lkc_defs.h $(srcdir)/expr.h zconf.tab.h |
| - | CONF_OBJS = $(patsubst %.c,%.o, $(CONF_SRC)) |
| - | MCONF_OBJS = $(patsubst %.c,%.o, $(MCONF_SRC) $(LXD_SRC)) |
| - | SHARED_OBJS = $(patsubst %.c,%.o, $(SHARED_SRC)) |
| - | |
| - | conf: $(CONF_OBJS) $(SHARED_OBJS) |
| - | $(SECHO) " "HOSTCC $@ ; true |
| - | $(Q)$(HOSTCC) $(NATIVE_LDFLAGS) $^ -o $@ |
| - | |
| - | mconf: $(MCONF_OBJS) $(SHARED_OBJS) |
| - | $(SECHO) " "HOSTCC $@ ; true |
| - | $(Q)$(HOSTCC) $(NATIVE_LDFLAGS) $^ -o $@ $(LIBS) |
| - | |
| - | $(CONF_OBJS): %.o : $(srcdir)/%.c $(SHARED_DEPS) |
| - | $(compile.h) -I. |
| - | |
| - | $(MCONF_OBJS): %.o : $(srcdir)/%.c $(SHARED_DEPS) |
| - | @[ -d $(@D) ] || mkdir $(@D) |
| - | $(compile.h) $(HOSTNCURSES) -I. |
| - | |
| - | lkc_defs.h: $(srcdir)/lkc_proto.h |
| - | @$(SED) < $< > $@ 's/P(\([^,]*\),.*/#define \1 (\*\1_p)/' |
| - | |
| - | ### |
| - | # The following requires flex/bison |
| - | # By default we use the _shipped versions, uncomment the |
| - | # following line if you are modifying the flex/bison src. |
| - | #LKC_GENPARSER := 1 |
| - | |
| - | ifdef LKC_GENPARSER |
| - | |
| - | %.tab.c %.tab.h: $(srcdir)/%.y |
| - | bison -t -d -v -b $* -p $(notdir $*) $< |
| - | |
| - | lex.%.c: $(srcdir)/%.l |
| - | flex -P$(notdir $*) -o$@ $< |
| - | else |
| - | |
| - | lex.zconf.o: lex.zconf.c $(SHARED_DEPS) |
| - | $(compile.h) -I$(srcdir) |
| - | |
| - | lex.zconf.c: $(srcdir)/lex.zconf.c_shipped |
| - | $(Q)cp $< $@ |
| - | |
| - | zconf.tab.c: $(srcdir)/zconf.tab.c_shipped |
| - | $(Q)cp $< $@ |
| - | |
| - | zconf.tab.h: $(srcdir)/zconf.tab.h_shipped |
| - | $(Q)cp $< $@ |
| - | endif |
| - | |
| - | zconf.tab.o: zconf.tab.c lex.zconf.c $(srcdir)/confdata.c $(srcdir)/expr.c \ |
| - | $(srcdir)/symbol.c $(srcdir)/menu.c $(SHARED_DEPS) |
| - | $(compile.h) -I$(srcdir) -I. |
| - | |
| - | .PHONY: ncurses |
| - | |
| - | ncurses: |
| - | @echo "main() {}" > lxtemp.c |
| - | @if $(HOSTCC) lxtemp.c $(LIBS) ; then \ |
| - | rm -f lxtemp.c a.out; \ |
| - | else \ |
| - | rm -f lxtemp.c; \ |
| - | echo -e "\007" ;\ |
| - | echo ">> Unable to find the Ncurses libraries." ;\ |
| - | echo ">>" ;\ |
| - | echo ">> You must have Ncurses installed in order" ;\ |
| - | echo ">> to use 'make menuconfig'" ;\ |
| - | echo ;\ |
| - | exit 1 ;\ |
| - | fi |
| - | |
| - | clean: |
| - | rm -f *.o *~ core $(TARGETS) $(MCONF_OBJS) $(CONF_OBJS) \ |
| - | conf mconf zconf.tab.c zconf.tab.h lex.zconf.c lkc_defs.h |
| - | |
| @@ -1,584 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <ctype.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <unistd.h> |
| - | #include <time.h> |
| - | #include <sys/stat.h> |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | static void conf(struct menu *menu); |
| - | static void check_conf(struct menu *menu); |
| - | |
| - | enum { |
| - | ask_all, |
| - | ask_new, |
| - | ask_silent, |
| - | set_default, |
| - | set_yes, |
| - | set_mod, |
| - | set_no, |
| - | set_random |
| - | } input_mode = ask_all; |
| - | char *defconfig_file; |
| - | |
| - | static int indent = 1; |
| - | static int valid_stdin = 1; |
| - | static int conf_cnt; |
| - | static char line[128]; |
| - | static struct menu *rootEntry; |
| - | |
| - | static char nohelp_text[] = "Sorry, no help available for this option yet.\n"; |
| - | |
| - | static void strip(char *str) |
| - | { |
| - | char *p = str; |
| - | int l; |
| - | |
| - | while ((isspace(*p))) |
| - | p++; |
| - | l = strlen(p); |
| - | if (p != str) |
| - | memmove(str, p, l + 1); |
| - | if (!l) |
| - | return; |
| - | p = str + l - 1; |
| - | while ((isspace(*p))) |
| - | *p-- = 0; |
| - | } |
| - | |
| - | static void check_stdin(void) |
| - | { |
| - | if (!valid_stdin && input_mode == ask_silent) { |
| - | printf("aborted!\n\n"); |
| - | printf("Console input/output is redirected. "); |
| - | printf("Run 'make oldconfig' to update configuration.\n\n"); |
| - | exit(1); |
| - | } |
| - | } |
| - | |
| - | static void conf_askvalue(struct symbol *sym, const char *def) |
| - | { |
| - | enum symbol_type type = sym_get_type(sym); |
| - | tristate val; |
| - | |
| - | if (!sym_has_value(sym)) |
| - | printf("(NEW) "); |
| - | |
| - | line[0] = '\n'; |
| - | line[1] = 0; |
| - | |
| - | if (!sym_is_changable(sym)) { |
| - | printf("%s\n", def); |
| - | line[0] = '\n'; |
| - | line[1] = 0; |
| - | return; |
| - | } |
| - | |
| - | switch (input_mode) { |
| - | case ask_new: |
| - | case ask_silent: |
| - | if (sym_has_value(sym)) { |
| - | printf("%s\n", def); |
| - | return; |
| - | } |
| - | check_stdin(); |
| - | case ask_all: |
| - | fflush(stdout); |
| - | fgets(line, 128, stdin); |
| - | return; |
| - | case set_default: |
| - | printf("%s\n", def); |
| - | return; |
| - | default: |
| - | break; |
| - | } |
| - | |
| - | switch (type) { |
| - | case S_INT: |
| - | case S_HEX: |
| - | case S_STRING: |
| - | printf("%s\n", def); |
| - | return; |
| - | default: |
| - | ; |
| - | } |
| - | switch (input_mode) { |
| - | case set_yes: |
| - | if (sym_tristate_within_range(sym, yes)) { |
| - | line[0] = 'y'; |
| - | line[1] = '\n'; |
| - | line[2] = 0; |
| - | break; |
| - | } |
| - | case set_mod: |
| - | if (type == S_TRISTATE) { |
| - | if (sym_tristate_within_range(sym, mod)) { |
| - | line[0] = 'm'; |
| - | line[1] = '\n'; |
| - | line[2] = 0; |
| - | break; |
| - | } |
| - | } else { |
| - | if (sym_tristate_within_range(sym, yes)) { |
| - | line[0] = 'y'; |
| - | line[1] = '\n'; |
| - | line[2] = 0; |
| - | break; |
| - | } |
| - | } |
| - | case set_no: |
| - | if (sym_tristate_within_range(sym, no)) { |
| - | line[0] = 'n'; |
| - | line[1] = '\n'; |
| - | line[2] = 0; |
| - | break; |
| - | } |
| - | case set_random: |
| - | do { |
| - | val = (tristate)(random() % 3); |
| - | } while (!sym_tristate_within_range(sym, val)); |
| - | switch (val) { |
| - | case no: line[0] = 'n'; break; |
| - | case mod: line[0] = 'm'; break; |
| - | case yes: line[0] = 'y'; break; |
| - | } |
| - | line[1] = '\n'; |
| - | line[2] = 0; |
| - | break; |
| - | default: |
| - | break; |
| - | } |
| - | printf("%s", line); |
| - | } |
| - | |
| - | int conf_string(struct menu *menu) |
| - | { |
| - | struct symbol *sym = menu->sym; |
| - | const char *def, *help; |
| - | |
| - | while (1) { |
| - | printf("%*s%s ", indent - 1, "", menu->prompt->text); |
| - | printf("(%s) ", sym->name); |
| - | def = sym_get_string_value(sym); |
| - | if (sym_get_string_value(sym)) |
| - | printf("[%s] ", def); |
| - | conf_askvalue(sym, def); |
| - | switch (line[0]) { |
| - | case '\n': |
| - | break; |
| - | case '?': |
| - | /* print help */ |
| - | if (line[1] == '\n') { |
| - | help = nohelp_text; |
| - | if (menu->sym->help) |
| - | help = menu->sym->help; |
| - | printf("\n%s\n", menu->sym->help); |
| - | def = NULL; |
| - | break; |
| - | } |
| - | default: |
| - | line[strlen(line)-1] = 0; |
| - | def = line; |
| - | } |
| - | if (def && sym_set_string_value(sym, def)) |
| - | return 0; |
| - | } |
| - | } |
| - | |
| - | static int conf_sym(struct menu *menu) |
| - | { |
| - | struct symbol *sym = menu->sym; |
| - | int type; |
| - | tristate oldval, newval; |
| - | const char *help; |
| - | |
| - | while (1) { |
| - | printf("%*s%s ", indent - 1, "", menu->prompt->text); |
| - | if (sym->name) |
| - | printf("(%s) ", sym->name); |
| - | type = sym_get_type(sym); |
| - | putchar('['); |
| - | oldval = sym_get_tristate_value(sym); |
| - | switch (oldval) { |
| - | case no: |
| - | putchar('N'); |
| - | break; |
| - | case mod: |
| - | putchar('M'); |
| - | break; |
| - | case yes: |
| - | putchar('Y'); |
| - | break; |
| - | } |
| - | if (oldval != no && sym_tristate_within_range(sym, no)) |
| - | printf("/n"); |
| - | if (oldval != mod && sym_tristate_within_range(sym, mod)) |
| - | printf("/m"); |
| - | if (oldval != yes && sym_tristate_within_range(sym, yes)) |
| - | printf("/y"); |
| - | if (sym->help) |
| - | printf("/?"); |
| - | printf("] "); |
| - | conf_askvalue(sym, sym_get_string_value(sym)); |
| - | strip(line); |
| - | |
| - | switch (line[0]) { |
| - | case 'n': |
| - | case 'N': |
| - | newval = no; |
| - | if (!line[1] || !strcmp(&line[1], "o")) |
| - | break; |
| - | continue; |
| - | case 'm': |
| - | case 'M': |
| - | newval = mod; |
| - | if (!line[1]) |
| - | break; |
| - | continue; |
| - | case 'y': |
| - | case 'Y': |
| - | newval = yes; |
| - | if (!line[1] || !strcmp(&line[1], "es")) |
| - | break; |
| - | continue; |
| - | case 0: |
| - | newval = oldval; |
| - | break; |
| - | case '?': |
| - | goto help; |
| - | default: |
| - | continue; |
| - | } |
| - | if (sym_set_tristate_value(sym, newval)) |
| - | return 0; |
| - | help: |
| - | help = nohelp_text; |
| - | if (sym->help) |
| - | help = sym->help; |
| - | printf("\n%s\n", help); |
| - | } |
| - | } |
| - | |
| - | static int conf_choice(struct menu *menu) |
| - | { |
| - | struct symbol *sym, *def_sym; |
| - | struct menu *child; |
| - | int type; |
| - | bool is_new; |
| - | |
| - | sym = menu->sym; |
| - | type = sym_get_type(sym); |
| - | is_new = !sym_has_value(sym); |
| - | if (sym_is_changable(sym)) { |
| - | conf_sym(menu); |
| - | sym_calc_value(sym); |
| - | switch (sym_get_tristate_value(sym)) { |
| - | case no: |
| - | return 1; |
| - | case mod: |
| - | return 0; |
| - | case yes: |
| - | break; |
| - | } |
| - | } else { |
| - | switch (sym_get_tristate_value(sym)) { |
| - | case no: |
| - | return 1; |
| - | case mod: |
| - | printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu)); |
| - | return 0; |
| - | case yes: |
| - | break; |
| - | } |
| - | } |
| - | |
| - | while (1) { |
| - | int cnt, def; |
| - | |
| - | printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu)); |
| - | def_sym = sym_get_choice_value(sym); |
| - | cnt = def = 0; |
| - | line[0] = '0'; |
| - | line[1] = 0; |
| - | for (child = menu->list; child; child = child->next) { |
| - | if (!menu_is_visible(child)) |
| - | continue; |
| - | if (!child->sym) { |
| - | printf("%*c %s\n", indent, '*', menu_get_prompt(child)); |
| - | continue; |
| - | } |
| - | cnt++; |
| - | if (child->sym == def_sym) { |
| - | def = cnt; |
| - | printf("%*c", indent, '>'); |
| - | } else |
| - | printf("%*c", indent, ' '); |
| - | printf(" %d. %s", cnt, menu_get_prompt(child)); |
| - | if (child->sym->name) |
| - | printf(" (%s)", child->sym->name); |
| - | if (!sym_has_value(child->sym)) |
| - | printf(" (NEW)"); |
| - | printf("\n"); |
| - | } |
| - | printf("%*schoice", indent - 1, ""); |
| - | if (cnt == 1) { |
| - | printf("[1]: 1\n"); |
| - | goto conf_childs; |
| - | } |
| - | printf("[1-%d", cnt); |
| - | if (sym->help) |
| - | printf("?"); |
| - | printf("]: "); |
| - | switch (input_mode) { |
| - | case ask_new: |
| - | case ask_silent: |
| - | if (!is_new) { |
| - | cnt = def; |
| - | printf("%d\n", cnt); |
| - | break; |
| - | } |
| - | check_stdin(); |
| - | case ask_all: |
| - | fflush(stdout); |
| - | fgets(line, 128, stdin); |
| - | strip(line); |
| - | if (line[0] == '?') { |
| - | printf("\n%s\n", menu->sym->help ? |
| - | menu->sym->help : nohelp_text); |
| - | continue; |
| - | } |
| - | if (!line[0]) |
| - | cnt = def; |
| - | else if (isdigit(line[0])) |
| - | cnt = atoi(line); |
| - | else |
| - | continue; |
| - | break; |
| - | case set_random: |
| - | def = (random() % cnt) + 1; |
| - | case set_default: |
| - | case set_yes: |
| - | case set_mod: |
| - | case set_no: |
| - | cnt = def; |
| - | printf("%d\n", cnt); |
| - | break; |
| - | } |
| - | |
| - | conf_childs: |
| - | for (child = menu->list; child; child = child->next) { |
| - | if (!child->sym || !menu_is_visible(child)) |
| - | continue; |
| - | if (!--cnt) |
| - | break; |
| - | } |
| - | if (!child) |
| - | continue; |
| - | if (line[strlen(line) - 1] == '?') { |
| - | printf("\n%s\n", child->sym->help ? |
| - | child->sym->help : nohelp_text); |
| - | continue; |
| - | } |
| - | sym_set_choice_value(sym, child->sym); |
| - | if (child->list) { |
| - | indent += 2; |
| - | conf(child->list); |
| - | indent -= 2; |
| - | } |
| - | return 1; |
| - | } |
| - | } |
| - | |
| - | static void conf(struct menu *menu) |
| - | { |
| - | struct symbol *sym; |
| - | struct property *prop; |
| - | struct menu *child; |
| - | |
| - | if (!menu_is_visible(menu)) |
| - | return; |
| - | |
| - | sym = menu->sym; |
| - | prop = menu->prompt; |
| - | if (prop) { |
| - | const char *prompt; |
| - | |
| - | switch (prop->type) { |
| - | case P_MENU: |
| - | if (input_mode == ask_silent && rootEntry != menu) { |
| - | check_conf(menu); |
| - | return; |
| - | } |
| - | case P_COMMENT: |
| - | prompt = menu_get_prompt(menu); |
| - | if (prompt) |
| - | printf("%*c\n%*c %s\n%*c\n", |
| - | indent, '*', |
| - | indent, '*', prompt, |
| - | indent, '*'); |
| - | default: |
| - | ; |
| - | } |
| - | } |
| - | |
| - | if (!sym) |
| - | goto conf_childs; |
| - | |
| - | if (sym_is_choice(sym)) { |
| - | conf_choice(menu); |
| - | if (sym->curr.tri != mod) |
| - | return; |
| - | goto conf_childs; |
| - | } |
| - | |
| - | switch (sym->type) { |
| - | case S_INT: |
| - | case S_HEX: |
| - | case S_STRING: |
| - | conf_string(menu); |
| - | break; |
| - | default: |
| - | conf_sym(menu); |
| - | break; |
| - | } |
| - | |
| - | conf_childs: |
| - | if (sym) |
| - | indent += 2; |
| - | for (child = menu->list; child; child = child->next) |
| - | conf(child); |
| - | if (sym) |
| - | indent -= 2; |
| - | } |
| - | |
| - | static void check_conf(struct menu *menu) |
| - | { |
| - | struct symbol *sym; |
| - | struct menu *child; |
| - | |
| - | if (!menu_is_visible(menu)) |
| - | return; |
| - | |
| - | sym = menu->sym; |
| - | if (sym) { |
| - | if (sym_is_changable(sym) && !sym_has_value(sym)) { |
| - | if (!conf_cnt++) |
| - | printf("*\n* Restart config...\n*\n"); |
| - | rootEntry = menu_get_parent_menu(menu); |
| - | conf(rootEntry); |
| - | } |
| - | if (sym_is_choice(sym) && sym_get_tristate_value(sym) != mod) |
| - | return; |
| - | } |
| - | |
| - | for (child = menu->list; child; child = child->next) |
| - | check_conf(child); |
| - | } |
| - | |
| - | int main(int ac, char **av) |
| - | { |
| - | int i = 1; |
| - | const char *name; |
| - | struct stat tmpstat; |
| - | |
| - | if (ac > i && av[i][0] == '-') { |
| - | switch (av[i++][1]) { |
| - | case 'o': |
| - | input_mode = ask_new; |
| - | break; |
| - | case 's': |
| - | input_mode = ask_silent; |
| - | valid_stdin = isatty(0) && isatty(1) && isatty(2); |
| - | break; |
| - | case 'd': |
| - | input_mode = set_default; |
| - | break; |
| - | case 'D': |
| - | input_mode = set_default; |
| - | defconfig_file = av[i++]; |
| - | if (!defconfig_file) { |
| - | printf("%s: No default config file specified\n", |
| - | av[0]); |
| - | exit(1); |
| - | } |
| - | break; |
| - | case 'n': |
| - | input_mode = set_no; |
| - | break; |
| - | case 'm': |
| - | input_mode = set_mod; |
| - | break; |
| - | case 'y': |
| - | input_mode = set_yes; |
| - | break; |
| - | case 'r': |
| - | input_mode = set_random; |
| - | srandom(time(NULL)); |
| - | break; |
| - | case 'h': |
| - | case '?': |
| - | printf("%s [-o|-s] config\n", av[0]); |
| - | exit(0); |
| - | } |
| - | } |
| - | name = av[i]; |
| - | if (!name) { |
| - | printf("%s: configuration file missing\n", av[0]); |
| - | } |
| - | conf_parse(name); |
| - | //zconfdump(stdout); |
| - | switch (input_mode) { |
| - | case set_default: |
| - | if (!defconfig_file) |
| - | defconfig_file = conf_get_default_confname(); |
| - | if (conf_read(defconfig_file)) { |
| - | printf("***\n" |
| - | "*** Can't find default configuration \"%s\"!\n" |
| - | "***\n", defconfig_file); |
| - | exit(1); |
| - | } |
| - | break; |
| - | case ask_silent: |
| - | if (stat(".config", &tmpstat)) { |
| - | printf("***\n" |
| - | "*** You have not yet configured BusyBox!\n" |
| - | "***\n" |
| - | "*** Please run some configurator (e.g. \"make oldconfig\" or\n" |
| - | "*** \"make menuconfig\" or \"make config\").\n" |
| - | "***\n"); |
| - | exit(1); |
| - | } |
| - | case ask_all: |
| - | case ask_new: |
| - | conf_read(NULL); |
| - | break; |
| - | default: |
| - | break; |
| - | } |
| - | |
| - | if (input_mode != ask_silent) { |
| - | rootEntry = &rootmenu; |
| - | conf(&rootmenu); |
| - | if (input_mode == ask_all) { |
| - | input_mode = ask_silent; |
| - | valid_stdin = 1; |
| - | } |
| - | } |
| - | do { |
| - | conf_cnt = 0; |
| - | check_conf(&rootmenu); |
| - | } while (conf_cnt); |
| - | if (conf_write(NULL)) { |
| - | fprintf(stderr, "\n*** Error during writing of the BusyBox configuration.\n\n"); |
| - | return 1; |
| - | } |
| - | return 0; |
| - | } |
| @@ -1,485 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <sys/stat.h> |
| - | #include <ctype.h> |
| - | #include <stdio.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <unistd.h> |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | const char conf_def_filename[] = ".config"; |
| - | |
| - | const char conf_defname[] = "defconfig"; |
| - | |
| - | const char *conf_confnames[] = { |
| - | ".config", |
| - | conf_defname, |
| - | NULL, |
| - | }; |
| - | |
| - | static char *conf_expand_value(const char *in) |
| - | { |
| - | struct symbol *sym; |
| - | const char *src; |
| - | static char res_value[SYMBOL_MAXLENGTH]; |
| - | char *dst, name[SYMBOL_MAXLENGTH]; |
| - | |
| - | res_value[0] = 0; |
| - | dst = name; |
| - | while ((src = strchr(in, '$'))) { |
| - | strncat(res_value, in, src - in); |
| - | src++; |
| - | dst = name; |
| - | while (isalnum(*src) || *src == '_') |
| - | *dst++ = *src++; |
| - | *dst = 0; |
| - | sym = sym_lookup(name, 0); |
| - | sym_calc_value(sym); |
| - | strcat(res_value, sym_get_string_value(sym)); |
| - | in = src; |
| - | } |
| - | strcat(res_value, in); |
| - | |
| - | return res_value; |
| - | } |
| - | |
| - | char *conf_get_default_confname(void) |
| - | { |
| - | struct stat buf; |
| - | static char fullname[PATH_MAX+1]; |
| - | char *env, *name; |
| - | |
| - | name = conf_expand_value(conf_defname); |
| - | env = getenv(SRCTREE); |
| - | if (env) { |
| - | sprintf(fullname, "%s/%s", env, name); |
| - | if (!stat(fullname, &buf)) |
| - | return fullname; |
| - | } |
| - | return name; |
| - | } |
| - | |
| - | int conf_read(const char *name) |
| - | { |
| - | FILE *in = NULL; |
| - | char line[1024]; |
| - | char *p, *p2; |
| - | int lineno = 0; |
| - | struct symbol *sym; |
| - | struct property *prop; |
| - | struct expr *e; |
| - | int i; |
| - | |
| - | if (name) { |
| - | in = zconf_fopen(name); |
| - | } else { |
| - | const char **names = conf_confnames; |
| - | while ((name = *names++)) { |
| - | name = conf_expand_value(name); |
| - | in = zconf_fopen(name); |
| - | if (in) { |
| - | printf("#\n" |
| - | "# using defaults found in %s\n" |
| - | "#\n", name); |
| - | break; |
| - | } |
| - | } |
| - | } |
| - | |
| - | if (!in) |
| - | return 1; |
| - | |
| - | for_all_symbols(i, sym) { |
| - | sym->flags |= SYMBOL_NEW | SYMBOL_CHANGED; |
| - | sym->flags &= ~SYMBOL_VALID; |
| - | switch (sym->type) { |
| - | case S_INT: |
| - | case S_HEX: |
| - | case S_STRING: |
| - | free(sym->user.val); |
| - | default: |
| - | sym->user.val = NULL; |
| - | sym->user.tri = no; |
| - | } |
| - | } |
| - | |
| - | while (fgets(line, sizeof(line), in)) { |
| - | lineno++; |
| - | sym = NULL; |
| - | switch (line[0]) { |
| - | case '#': |
| - | if (line[1]!=' ') |
| - | continue; |
| - | p = strchr(line + 2, ' '); |
| - | if (!p) |
| - | continue; |
| - | *p++ = 0; |
| - | if (strncmp(p, "is not set", 10)) |
| - | continue; |
| - | sym = sym_find(line + 2); |
| - | if (!sym) { |
| - | fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line + 2); |
| - | break; |
| - | } |
| - | switch (sym->type) { |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | sym->user.tri = no; |
| - | sym->flags &= ~SYMBOL_NEW; |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | break; |
| - | |
| - | case 'A' ... 'Z': |
| - | p = strchr(line, '='); |
| - | if (!p) |
| - | continue; |
| - | *p++ = 0; |
| - | p2 = strchr(p, '\n'); |
| - | if (p2) |
| - | *p2 = 0; |
| - | sym = sym_find(line); |
| - | if (!sym) { |
| - | fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line); |
| - | break; |
| - | } |
| - | switch (sym->type) { |
| - | case S_TRISTATE: |
| - | if (p[0] == 'm') { |
| - | sym->user.tri = mod; |
| - | sym->flags &= ~SYMBOL_NEW; |
| - | break; |
| - | } |
| - | case S_BOOLEAN: |
| - | if (p[0] == 'y') { |
| - | sym->user.tri = yes; |
| - | sym->flags &= ~SYMBOL_NEW; |
| - | break; |
| - | } |
| - | if (p[0] == 'n') { |
| - | sym->user.tri = no; |
| - | sym->flags &= ~SYMBOL_NEW; |
| - | break; |
| - | } |
| - | break; |
| - | case S_STRING: |
| - | if (*p++ != '"') |
| - | break; |
| - | for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) { |
| - | if (*p2 == '"') { |
| - | *p2 = 0; |
| - | break; |
| - | } |
| - | memmove(p2, p2 + 1, strlen(p2)); |
| - | } |
| - | if (!p2) { |
| - | fprintf(stderr, "%s:%d: invalid string found\n", name, lineno); |
| - | exit(1); |
| - | } |
| - | case S_INT: |
| - | case S_HEX: |
| - | if (sym_string_valid(sym, p)) { |
| - | sym->user.val = strdup(p); |
| - | sym->flags &= ~SYMBOL_NEW; |
| - | } else { |
| - | fprintf(stderr, "%s:%d: symbol value '%s' invalid for %s\n", name, lineno, p, sym->name); |
| - | exit(1); |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | break; |
| - | case '\n': |
| - | break; |
| - | default: |
| - | continue; |
| - | } |
| - | if (sym && sym_is_choice_value(sym)) { |
| - | struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); |
| - | switch (sym->user.tri) { |
| - | case no: |
| - | break; |
| - | case mod: |
| - | if (cs->user.tri == yes) |
| - | /* warn? */; |
| - | break; |
| - | case yes: |
| - | if (cs->user.tri != no) |
| - | /* warn? */; |
| - | cs->user.val = sym; |
| - | break; |
| - | } |
| - | cs->user.tri = E_OR(cs->user.tri, sym->user.tri); |
| - | cs->flags &= ~SYMBOL_NEW; |
| - | } |
| - | } |
| - | fclose(in); |
| - | |
| - | if (modules_sym) |
| - | sym_calc_value(modules_sym); |
| - | for_all_symbols(i, sym) { |
| - | sym_calc_value(sym); |
| - | if (sym_has_value(sym) && !sym_is_choice_value(sym)) { |
| - | if (sym->visible == no) |
| - | sym->flags |= SYMBOL_NEW; |
| - | switch (sym->type) { |
| - | case S_STRING: |
| - | case S_INT: |
| - | case S_HEX: |
| - | if (!sym_string_within_range(sym, sym->user.val)) |
| - | sym->flags |= SYMBOL_NEW; |
| - | default: |
| - | break; |
| - | } |
| - | } |
| - | if (!sym_is_choice(sym)) |
| - | continue; |
| - | prop = sym_get_choice_prop(sym); |
| - | for (e = prop->expr; e; e = e->left.expr) |
| - | if (e->right.sym->visible != no) |
| - | sym->flags |= e->right.sym->flags & SYMBOL_NEW; |
| - | } |
| - | |
| - | sym_change_count = 1; |
| - | |
| - | return 0; |
| - | } |
| - | |
| - | struct menu *next_menu(struct menu *menu) |
| - | { |
| - | if (menu->list) return menu->list; |
| - | do { |
| - | if (menu->next) { |
| - | menu = menu->next; |
| - | break; |
| - | } |
| - | } while ((menu = menu->parent)); |
| - | |
| - | return menu; |
| - | } |
| - | |
| - | #define SYMBOL_FORCEWRITE (1<<31) |
| - | |
| - | int conf_write(const char *name) |
| - | { |
| - | FILE *out, *out_h; |
| - | struct symbol *sym; |
| - | struct menu *menu; |
| - | const char *basename; |
| - | char dirname[128], tmpname[128], newname[128]; |
| - | int type, l; |
| - | const char *str; |
| - | |
| - | /* busybox`s code */ |
| - | const char *opt_name; |
| - | int use_flg; |
| - | |
| - | dirname[0] = 0; |
| - | if (name && name[0]) { |
| - | struct stat st; |
| - | char *slash; |
| - | |
| - | if (!stat(name, &st) && S_ISDIR(st.st_mode)) { |
| - | strcpy(dirname, name); |
| - | strcat(dirname, "/"); |
| - | basename = conf_def_filename; |
| - | } else if ((slash = strrchr(name, '/'))) { |
| - | int size = slash - name + 1; |
| - | memcpy(dirname, name, size); |
| - | dirname[size] = 0; |
| - | if (slash[1]) |
| - | basename = slash + 1; |
| - | else |
| - | basename = conf_def_filename; |
| - | } else |
| - | basename = name; |
| - | } else |
| - | basename = conf_def_filename; |
| - | |
| - | sprintf(newname, "%s.tmpconfig.%d", dirname, (int)getpid()); |
| - | out = fopen(newname, "w"); |
| - | if (!out) |
| - | return 1; |
| - | out_h = NULL; |
| - | if (!name) { |
| - | out_h = fopen(".tmpconfig.h", "w"); |
| - | if (!out_h) |
| - | return 1; |
| - | } |
| - | fprintf(out, "#\n" |
| - | "# Automatically generated make config: don't edit\n" |
| - | "#\n"); |
| - | |
| - | /* busybox`s code */ |
| - | if (out_h) { |
| - | fprintf(out_h, "#ifndef BB_CONFIG_H\n#define BB_CONFIG_H\n"); |
| - | fprintf(out_h, "/*\n" |
| - | " * Automatically generated header file: don't edit\n" |
| - | " */\n\n" |
| - | "/* Version Number */\n" |
| - | "#define BB_VER \"%s\"\n" |
| - | "#define BB_BT \"%s\"\n", |
| - | getenv("VERSION"), |
| - | getenv("BUILDTIME")); |
| - | if (getenv("EXTRA_VERSION")) |
| - | fprintf(out_h, "#define BB_EXTRA_VERSION \"%s\"\n", |
| - | getenv("EXTRA_VERSION")); |
| - | fprintf(out_h, "\n"); |
| - | } |
| - | /* end busybox`s code */ |
| - | |
| - | if (!sym_change_count) |
| - | sym_clear_all_valid(); |
| - | |
| - | /* Force write of all non-duplicate symbols. */ |
| - | |
| - | /* Write out everything by default. */ |
| - | for(menu = rootmenu.list; menu; menu = next_menu(menu)) |
| - | if (menu->sym) menu->sym->flags |= SYMBOL_FORCEWRITE; |
| - | |
| - | menu = rootmenu.list; |
| - | while (menu) { |
| - | sym = menu->sym; |
| - | if (!sym) { |
| - | if (!menu_is_visible(menu)) |
| - | goto next; |
| - | str = menu_get_prompt(menu); |
| - | fprintf(out, "\n" |
| - | "#\n" |
| - | "# %s\n" |
| - | "#\n", str); |
| - | if (out_h) |
| - | fprintf(out_h, "\n" |
| - | "/*\n" |
| - | " * %s\n" |
| - | " */\n", str); |
| - | } else if (!(sym->flags & SYMBOL_CHOICE)) { |
| - | sym_calc_value(sym); |
| - | if (!(sym->flags & SYMBOL_FORCEWRITE)) |
| - | goto next; |
| - | |
| - | sym->flags &= ~SYMBOL_FORCEWRITE; |
| - | type = sym->type; |
| - | if (type == S_TRISTATE) { |
| - | sym_calc_value(modules_sym); |
| - | if (modules_sym->curr.tri == no) |
| - | type = S_BOOLEAN; |
| - | } |
| - | |
| - | /* busybox`s code */ |
| - | opt_name = strchr(sym->name, '_'); |
| - | if(opt_name == NULL) |
| - | opt_name = sym->name; |
| - | else |
| - | opt_name++; |
| - | use_flg = 1; |
| - | /* end busybox`s code */ |
| - | |
| - | switch (type) { |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | switch (sym_get_tristate_value(sym)) { |
| - | case no: |
| - | fprintf(out, "# %s is not set\n", sym->name); |
| - | if (out_h) |
| - | fprintf(out_h, "#undef %s\n", sym->name); |
| - | use_flg = 0; /* busybox`s code */ |
| - | break; |
| - | case mod: |
| - | #if 0 /* busybox`s code */ |
| - | fprintf(out, "%s=m\n", sym->name); |
| - | if (out_h) |
| - | fprintf(out_h, "#define %s_MODULE 1\n", sym->name); |
| - | #endif /* busybox`s code */ |
| - | break; |
| - | case yes: |
| - | fprintf(out, "%s=y\n", sym->name); |
| - | if (out_h) |
| - | fprintf(out_h, "#define %s 1\n", sym->name); |
| - | break; |
| - | } |
| - | break; |
| - | case S_STRING: |
| - | // fix me |
| - | str = sym_get_string_value(sym); |
| - | fprintf(out, "%s=\"", sym->name); |
| - | if (out_h) |
| - | fprintf(out_h, "#define %s \"", sym->name); |
| - | do { |
| - | l = strcspn(str, "\"\\"); |
| - | if (l) { |
| - | fwrite(str, l, 1, out); |
| - | if (out_h) |
| - | fwrite(str, l, 1, out_h); |
| - | } |
| - | str += l; |
| - | while (*str == '\\' || *str == '"') { |
| - | fprintf(out, "\\%c", *str); |
| - | if (out_h) |
| - | fprintf(out_h, "\\%c", *str); |
| - | str++; |
| - | } |
| - | } while (*str); |
| - | fputs("\"\n", out); |
| - | if (out_h) |
| - | fputs("\"\n", out_h); |
| - | break; |
| - | case S_HEX: |
| - | str = sym_get_string_value(sym); |
| - | if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) { |
| - | fprintf(out, "%s=%s\n", sym->name, *str ? str : "0"); |
| - | if (out_h) |
| - | fprintf(out_h, "#define %s 0x%s\n", sym->name, str); |
| - | break; |
| - | } |
| - | case S_INT: |
| - | str = sym_get_string_value(sym); |
| - | fprintf(out, "%s=%s\n", sym->name, *str ? str : "0"); |
| - | if (out_h) |
| - | fprintf(out_h, "#define %s %s\n", sym->name, str); |
| - | break; |
| - | } |
| - | /* busybox`s code */ |
| - | if (out_h) { |
| - | fprintf(out_h, "#define ENABLE_%s %d\n", opt_name, use_flg); |
| - | fprintf(out_h, "#define USE_%s(...)%s\n", opt_name, |
| - | (use_flg ? " __VA_ARGS__" : "")); |
| - | fprintf(out_h, "#define SKIP_%s(...)%s\n\n", opt_name, |
| - | (use_flg ? "" : " __VA_ARGS__")); |
| - | } |
| - | /* end busybox`s code */ |
| - | } |
| - | next: |
| - | menu = next_menu(menu); |
| - | } |
| - | fclose(out); |
| - | if (out_h) { |
| - | fprintf(out_h, "#endif /* BB_CONFIG_H */\n"); /* busybox`s code */ |
| - | fclose(out_h); |
| - | rename(".tmpconfig.h", "include/bb_config.h"); /* busybox`s config name */ |
| - | file_write_dep(NULL); |
| - | } |
| - | if (!name || basename != conf_def_filename) { |
| - | if (!name) |
| - | name = conf_def_filename; |
| - | sprintf(tmpname, "%s.old", name); |
| - | rename(name, tmpname); |
| - | } |
| - | sprintf(tmpname, "%s%s", dirname, basename); |
| - | if (rename(newname, tmpname)) |
| - | return 1; |
| - | |
| - | sym_change_count = 0; |
| - | |
| - | return 0; |
| - | } |
| @@ -1,1100 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <stdio.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | #define DEBUG_EXPR 0 |
| - | |
| - | struct expr *expr_alloc_symbol(struct symbol *sym) |
| - | { |
| - | struct expr *e = malloc(sizeof(*e)); |
| - | memset(e, 0, sizeof(*e)); |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = sym; |
| - | return e; |
| - | } |
| - | |
| - | struct expr *expr_alloc_one(enum expr_type type, struct expr *ce) |
| - | { |
| - | struct expr *e = malloc(sizeof(*e)); |
| - | memset(e, 0, sizeof(*e)); |
| - | e->type = type; |
| - | e->left.expr = ce; |
| - | return e; |
| - | } |
| - | |
| - | struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2) |
| - | { |
| - | struct expr *e = malloc(sizeof(*e)); |
| - | memset(e, 0, sizeof(*e)); |
| - | e->type = type; |
| - | e->left.expr = e1; |
| - | e->right.expr = e2; |
| - | return e; |
| - | } |
| - | |
| - | struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2) |
| - | { |
| - | struct expr *e = malloc(sizeof(*e)); |
| - | memset(e, 0, sizeof(*e)); |
| - | e->type = type; |
| - | e->left.sym = s1; |
| - | e->right.sym = s2; |
| - | return e; |
| - | } |
| - | |
| - | struct expr *expr_alloc_and(struct expr *e1, struct expr *e2) |
| - | { |
| - | if (!e1) |
| - | return e2; |
| - | return e2 ? expr_alloc_two(E_AND, e1, e2) : e1; |
| - | } |
| - | |
| - | struct expr *expr_alloc_or(struct expr *e1, struct expr *e2) |
| - | { |
| - | if (!e1) |
| - | return e2; |
| - | return e2 ? expr_alloc_two(E_OR, e1, e2) : e1; |
| - | } |
| - | |
| - | struct expr *expr_copy(struct expr *org) |
| - | { |
| - | struct expr *e; |
| - | |
| - | if (!org) |
| - | return NULL; |
| - | |
| - | e = malloc(sizeof(*org)); |
| - | memcpy(e, org, sizeof(*org)); |
| - | switch (org->type) { |
| - | case E_SYMBOL: |
| - | e->left = org->left; |
| - | break; |
| - | case E_NOT: |
| - | e->left.expr = expr_copy(org->left.expr); |
| - | break; |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | e->left.sym = org->left.sym; |
| - | e->right.sym = org->right.sym; |
| - | break; |
| - | case E_AND: |
| - | case E_OR: |
| - | case E_CHOICE: |
| - | e->left.expr = expr_copy(org->left.expr); |
| - | e->right.expr = expr_copy(org->right.expr); |
| - | break; |
| - | default: |
| - | printf("can't copy type %d\n", e->type); |
| - | free(e); |
| - | e = NULL; |
| - | break; |
| - | } |
| - | |
| - | return e; |
| - | } |
| - | |
| - | void expr_free(struct expr *e) |
| - | { |
| - | if (!e) |
| - | return; |
| - | |
| - | switch (e->type) { |
| - | case E_SYMBOL: |
| - | break; |
| - | case E_NOT: |
| - | expr_free(e->left.expr); |
| - | return; |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | break; |
| - | case E_OR: |
| - | case E_AND: |
| - | expr_free(e->left.expr); |
| - | expr_free(e->right.expr); |
| - | break; |
| - | default: |
| - | printf("how to free type %d?\n", e->type); |
| - | break; |
| - | } |
| - | free(e); |
| - | } |
| - | |
| - | static int trans_count; |
| - | |
| - | #define e1 (*ep1) |
| - | #define e2 (*ep2) |
| - | |
| - | static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2) |
| - | { |
| - | if (e1->type == type) { |
| - | __expr_eliminate_eq(type, &e1->left.expr, &e2); |
| - | __expr_eliminate_eq(type, &e1->right.expr, &e2); |
| - | return; |
| - | } |
| - | if (e2->type == type) { |
| - | __expr_eliminate_eq(type, &e1, &e2->left.expr); |
| - | __expr_eliminate_eq(type, &e1, &e2->right.expr); |
| - | return; |
| - | } |
| - | if (e1->type == E_SYMBOL && e2->type == E_SYMBOL && |
| - | e1->left.sym == e2->left.sym && (e1->left.sym->flags & (SYMBOL_YES|SYMBOL_NO))) |
| - | return; |
| - | if (!expr_eq(e1, e2)) |
| - | return; |
| - | trans_count++; |
| - | expr_free(e1); expr_free(e2); |
| - | switch (type) { |
| - | case E_OR: |
| - | e1 = expr_alloc_symbol(&symbol_no); |
| - | e2 = expr_alloc_symbol(&symbol_no); |
| - | break; |
| - | case E_AND: |
| - | e1 = expr_alloc_symbol(&symbol_yes); |
| - | e2 = expr_alloc_symbol(&symbol_yes); |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | } |
| - | |
| - | void expr_eliminate_eq(struct expr **ep1, struct expr **ep2) |
| - | { |
| - | if (!e1 || !e2) |
| - | return; |
| - | switch (e1->type) { |
| - | case E_OR: |
| - | case E_AND: |
| - | __expr_eliminate_eq(e1->type, ep1, ep2); |
| - | default: |
| - | ; |
| - | } |
| - | if (e1->type != e2->type) switch (e2->type) { |
| - | case E_OR: |
| - | case E_AND: |
| - | __expr_eliminate_eq(e2->type, ep1, ep2); |
| - | default: |
| - | ; |
| - | } |
| - | e1 = expr_eliminate_yn(e1); |
| - | e2 = expr_eliminate_yn(e2); |
| - | } |
| - | |
| - | #undef e1 |
| - | #undef e2 |
| - | |
| - | int expr_eq(struct expr *e1, struct expr *e2) |
| - | { |
| - | int res, old_count; |
| - | |
| - | if (e1->type != e2->type) |
| - | return 0; |
| - | switch (e1->type) { |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym; |
| - | case E_SYMBOL: |
| - | return e1->left.sym == e2->left.sym; |
| - | case E_NOT: |
| - | return expr_eq(e1->left.expr, e2->left.expr); |
| - | case E_AND: |
| - | case E_OR: |
| - | e1 = expr_copy(e1); |
| - | e2 = expr_copy(e2); |
| - | old_count = trans_count; |
| - | expr_eliminate_eq(&e1, &e2); |
| - | res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL && |
| - | e1->left.sym == e2->left.sym); |
| - | expr_free(e1); |
| - | expr_free(e2); |
| - | trans_count = old_count; |
| - | return res; |
| - | case E_CHOICE: |
| - | case E_RANGE: |
| - | case E_NONE: |
| - | /* panic */; |
| - | } |
| - | |
| - | if (DEBUG_EXPR) { |
| - | expr_fprint(e1, stdout); |
| - | printf(" = "); |
| - | expr_fprint(e2, stdout); |
| - | printf(" ?\n"); |
| - | } |
| - | |
| - | return 0; |
| - | } |
| - | |
| - | struct expr *expr_eliminate_yn(struct expr *e) |
| - | { |
| - | struct expr *tmp; |
| - | |
| - | if (e) switch (e->type) { |
| - | case E_AND: |
| - | e->left.expr = expr_eliminate_yn(e->left.expr); |
| - | e->right.expr = expr_eliminate_yn(e->right.expr); |
| - | if (e->left.expr->type == E_SYMBOL) { |
| - | if (e->left.expr->left.sym == &symbol_no) { |
| - | expr_free(e->left.expr); |
| - | expr_free(e->right.expr); |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_no; |
| - | e->right.expr = NULL; |
| - | return e; |
| - | } else if (e->left.expr->left.sym == &symbol_yes) { |
| - | free(e->left.expr); |
| - | tmp = e->right.expr; |
| - | *e = *(e->right.expr); |
| - | free(tmp); |
| - | return e; |
| - | } |
| - | } |
| - | if (e->right.expr->type == E_SYMBOL) { |
| - | if (e->right.expr->left.sym == &symbol_no) { |
| - | expr_free(e->left.expr); |
| - | expr_free(e->right.expr); |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_no; |
| - | e->right.expr = NULL; |
| - | return e; |
| - | } else if (e->right.expr->left.sym == &symbol_yes) { |
| - | free(e->right.expr); |
| - | tmp = e->left.expr; |
| - | *e = *(e->left.expr); |
| - | free(tmp); |
| - | return e; |
| - | } |
| - | } |
| - | break; |
| - | case E_OR: |
| - | e->left.expr = expr_eliminate_yn(e->left.expr); |
| - | e->right.expr = expr_eliminate_yn(e->right.expr); |
| - | if (e->left.expr->type == E_SYMBOL) { |
| - | if (e->left.expr->left.sym == &symbol_no) { |
| - | free(e->left.expr); |
| - | tmp = e->right.expr; |
| - | *e = *(e->right.expr); |
| - | free(tmp); |
| - | return e; |
| - | } else if (e->left.expr->left.sym == &symbol_yes) { |
| - | expr_free(e->left.expr); |
| - | expr_free(e->right.expr); |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_yes; |
| - | e->right.expr = NULL; |
| - | return e; |
| - | } |
| - | } |
| - | if (e->right.expr->type == E_SYMBOL) { |
| - | if (e->right.expr->left.sym == &symbol_no) { |
| - | free(e->right.expr); |
| - | tmp = e->left.expr; |
| - | *e = *(e->left.expr); |
| - | free(tmp); |
| - | return e; |
| - | } else if (e->right.expr->left.sym == &symbol_yes) { |
| - | expr_free(e->left.expr); |
| - | expr_free(e->right.expr); |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_yes; |
| - | e->right.expr = NULL; |
| - | return e; |
| - | } |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | return e; |
| - | } |
| - | |
| - | /* |
| - | * bool FOO!=n => FOO |
| - | */ |
| - | struct expr *expr_trans_bool(struct expr *e) |
| - | { |
| - | if (!e) |
| - | return NULL; |
| - | switch (e->type) { |
| - | case E_AND: |
| - | case E_OR: |
| - | case E_NOT: |
| - | e->left.expr = expr_trans_bool(e->left.expr); |
| - | e->right.expr = expr_trans_bool(e->right.expr); |
| - | break; |
| - | case E_UNEQUAL: |
| - | // FOO!=n -> FOO |
| - | if (e->left.sym->type == S_TRISTATE) { |
| - | if (e->right.sym == &symbol_no) { |
| - | e->type = E_SYMBOL; |
| - | e->right.sym = NULL; |
| - | } |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | return e; |
| - | } |
| - | |
| - | /* |
| - | * e1 || e2 -> ? |
| - | */ |
| - | struct expr *expr_join_or(struct expr *e1, struct expr *e2) |
| - | { |
| - | struct expr *tmp; |
| - | struct symbol *sym1, *sym2; |
| - | |
| - | if (expr_eq(e1, e2)) |
| - | return expr_copy(e1); |
| - | if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT) |
| - | return NULL; |
| - | if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT) |
| - | return NULL; |
| - | if (e1->type == E_NOT) { |
| - | tmp = e1->left.expr; |
| - | if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL) |
| - | return NULL; |
| - | sym1 = tmp->left.sym; |
| - | } else |
| - | sym1 = e1->left.sym; |
| - | if (e2->type == E_NOT) { |
| - | if (e2->left.expr->type != E_SYMBOL) |
| - | return NULL; |
| - | sym2 = e2->left.expr->left.sym; |
| - | } else |
| - | sym2 = e2->left.sym; |
| - | if (sym1 != sym2) |
| - | return NULL; |
| - | if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE) |
| - | return NULL; |
| - | if (sym1->type == S_TRISTATE) { |
| - | if (e1->type == E_EQUAL && e2->type == E_EQUAL && |
| - | ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) || |
| - | (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) { |
| - | // (a='y') || (a='m') -> (a!='n') |
| - | return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_no); |
| - | } |
| - | if (e1->type == E_EQUAL && e2->type == E_EQUAL && |
| - | ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) || |
| - | (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) { |
| - | // (a='y') || (a='n') -> (a!='m') |
| - | return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_mod); |
| - | } |
| - | if (e1->type == E_EQUAL && e2->type == E_EQUAL && |
| - | ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) || |
| - | (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) { |
| - | // (a='m') || (a='n') -> (a!='y') |
| - | return expr_alloc_comp(E_UNEQUAL, sym1, &symbol_yes); |
| - | } |
| - | } |
| - | if (sym1->type == S_BOOLEAN && sym1 == sym2) { |
| - | if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) || |
| - | (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL)) |
| - | return expr_alloc_symbol(&symbol_yes); |
| - | } |
| - | |
| - | if (DEBUG_EXPR) { |
| - | printf("optimize ("); |
| - | expr_fprint(e1, stdout); |
| - | printf(") || ("); |
| - | expr_fprint(e2, stdout); |
| - | printf(")?\n"); |
| - | } |
| - | return NULL; |
| - | } |
| - | |
| - | struct expr *expr_join_and(struct expr *e1, struct expr *e2) |
| - | { |
| - | struct expr *tmp; |
| - | struct symbol *sym1, *sym2; |
| - | |
| - | if (expr_eq(e1, e2)) |
| - | return expr_copy(e1); |
| - | if (e1->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT) |
| - | return NULL; |
| - | if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT) |
| - | return NULL; |
| - | if (e1->type == E_NOT) { |
| - | tmp = e1->left.expr; |
| - | if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL) |
| - | return NULL; |
| - | sym1 = tmp->left.sym; |
| - | } else |
| - | sym1 = e1->left.sym; |
| - | if (e2->type == E_NOT) { |
| - | if (e2->left.expr->type != E_SYMBOL) |
| - | return NULL; |
| - | sym2 = e2->left.expr->left.sym; |
| - | } else |
| - | sym2 = e2->left.sym; |
| - | if (sym1 != sym2) |
| - | return NULL; |
| - | if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE) |
| - | return NULL; |
| - | |
| - | if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) || |
| - | (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes)) |
| - | // (a) && (a='y') -> (a='y') |
| - | return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes); |
| - | |
| - | if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) || |
| - | (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no)) |
| - | // (a) && (a!='n') -> (a) |
| - | return expr_alloc_symbol(sym1); |
| - | |
| - | if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_mod) || |
| - | (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_mod)) |
| - | // (a) && (a!='m') -> (a='y') |
| - | return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes); |
| - | |
| - | if (sym1->type == S_TRISTATE) { |
| - | if (e1->type == E_EQUAL && e2->type == E_UNEQUAL) { |
| - | // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b' |
| - | sym2 = e1->right.sym; |
| - | if ((e2->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST)) |
| - | return sym2 != e2->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2) |
| - | : expr_alloc_symbol(&symbol_no); |
| - | } |
| - | if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) { |
| - | // (a='b') && (a!='c') -> 'b'='c' ? 'n' : a='b' |
| - | sym2 = e2->right.sym; |
| - | if ((e1->right.sym->flags & SYMBOL_CONST) && (sym2->flags & SYMBOL_CONST)) |
| - | return sym2 != e1->right.sym ? expr_alloc_comp(E_EQUAL, sym1, sym2) |
| - | : expr_alloc_symbol(&symbol_no); |
| - | } |
| - | if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL && |
| - | ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_no) || |
| - | (e1->right.sym == &symbol_no && e2->right.sym == &symbol_yes))) |
| - | // (a!='y') && (a!='n') -> (a='m') |
| - | return expr_alloc_comp(E_EQUAL, sym1, &symbol_mod); |
| - | |
| - | if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL && |
| - | ((e1->right.sym == &symbol_yes && e2->right.sym == &symbol_mod) || |
| - | (e1->right.sym == &symbol_mod && e2->right.sym == &symbol_yes))) |
| - | // (a!='y') && (a!='m') -> (a='n') |
| - | return expr_alloc_comp(E_EQUAL, sym1, &symbol_no); |
| - | |
| - | if (e1->type == E_UNEQUAL && e2->type == E_UNEQUAL && |
| - | ((e1->right.sym == &symbol_mod && e2->right.sym == &symbol_no) || |
| - | (e1->right.sym == &symbol_no && e2->right.sym == &symbol_mod))) |
| - | // (a!='m') && (a!='n') -> (a='m') |
| - | return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes); |
| - | |
| - | if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) || |
| - | (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) || |
| - | (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) || |
| - | (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes)) |
| - | return NULL; |
| - | } |
| - | |
| - | if (DEBUG_EXPR) { |
| - | printf("optimize ("); |
| - | expr_fprint(e1, stdout); |
| - | printf(") && ("); |
| - | expr_fprint(e2, stdout); |
| - | printf(")?\n"); |
| - | } |
| - | return NULL; |
| - | } |
| - | |
| - | static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct expr **ep2) |
| - | { |
| - | #define e1 (*ep1) |
| - | #define e2 (*ep2) |
| - | struct expr *tmp; |
| - | |
| - | if (e1->type == type) { |
| - | expr_eliminate_dups1(type, &e1->left.expr, &e2); |
| - | expr_eliminate_dups1(type, &e1->right.expr, &e2); |
| - | return; |
| - | } |
| - | if (e2->type == type) { |
| - | expr_eliminate_dups1(type, &e1, &e2->left.expr); |
| - | expr_eliminate_dups1(type, &e1, &e2->right.expr); |
| - | return; |
| - | } |
| - | if (e1 == e2) |
| - | return; |
| - | |
| - | switch (e1->type) { |
| - | case E_OR: case E_AND: |
| - | expr_eliminate_dups1(e1->type, &e1, &e1); |
| - | default: |
| - | ; |
| - | } |
| - | |
| - | switch (type) { |
| - | case E_OR: |
| - | tmp = expr_join_or(e1, e2); |
| - | if (tmp) { |
| - | expr_free(e1); expr_free(e2); |
| - | e1 = expr_alloc_symbol(&symbol_no); |
| - | e2 = tmp; |
| - | trans_count++; |
| - | } |
| - | break; |
| - | case E_AND: |
| - | tmp = expr_join_and(e1, e2); |
| - | if (tmp) { |
| - | expr_free(e1); expr_free(e2); |
| - | e1 = expr_alloc_symbol(&symbol_yes); |
| - | e2 = tmp; |
| - | trans_count++; |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | #undef e1 |
| - | #undef e2 |
| - | } |
| - | |
| - | static void expr_eliminate_dups2(enum expr_type type, struct expr **ep1, struct expr **ep2) |
| - | { |
| - | #define e1 (*ep1) |
| - | #define e2 (*ep2) |
| - | struct expr *tmp, *tmp1, *tmp2; |
| - | |
| - | if (e1->type == type) { |
| - | expr_eliminate_dups2(type, &e1->left.expr, &e2); |
| - | expr_eliminate_dups2(type, &e1->right.expr, &e2); |
| - | return; |
| - | } |
| - | if (e2->type == type) { |
| - | expr_eliminate_dups2(type, &e1, &e2->left.expr); |
| - | expr_eliminate_dups2(type, &e1, &e2->right.expr); |
| - | } |
| - | if (e1 == e2) |
| - | return; |
| - | |
| - | switch (e1->type) { |
| - | case E_OR: |
| - | expr_eliminate_dups2(e1->type, &e1, &e1); |
| - | // (FOO || BAR) && (!FOO && !BAR) -> n |
| - | tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1))); |
| - | tmp2 = expr_copy(e2); |
| - | tmp = expr_extract_eq_and(&tmp1, &tmp2); |
| - | if (expr_is_yes(tmp1)) { |
| - | expr_free(e1); |
| - | e1 = expr_alloc_symbol(&symbol_no); |
| - | trans_count++; |
| - | } |
| - | expr_free(tmp2); |
| - | expr_free(tmp1); |
| - | expr_free(tmp); |
| - | break; |
| - | case E_AND: |
| - | expr_eliminate_dups2(e1->type, &e1, &e1); |
| - | // (FOO && BAR) || (!FOO || !BAR) -> y |
| - | tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1))); |
| - | tmp2 = expr_copy(e2); |
| - | tmp = expr_extract_eq_or(&tmp1, &tmp2); |
| - | if (expr_is_no(tmp1)) { |
| - | expr_free(e1); |
| - | e1 = expr_alloc_symbol(&symbol_yes); |
| - | trans_count++; |
| - | } |
| - | expr_free(tmp2); |
| - | expr_free(tmp1); |
| - | expr_free(tmp); |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | #undef e1 |
| - | #undef e2 |
| - | } |
| - | |
| - | struct expr *expr_eliminate_dups(struct expr *e) |
| - | { |
| - | int oldcount; |
| - | if (!e) |
| - | return e; |
| - | |
| - | oldcount = trans_count; |
| - | while (1) { |
| - | trans_count = 0; |
| - | switch (e->type) { |
| - | case E_OR: case E_AND: |
| - | expr_eliminate_dups1(e->type, &e, &e); |
| - | expr_eliminate_dups2(e->type, &e, &e); |
| - | default: |
| - | ; |
| - | } |
| - | if (!trans_count) |
| - | break; |
| - | e = expr_eliminate_yn(e); |
| - | } |
| - | trans_count = oldcount; |
| - | return e; |
| - | } |
| - | |
| - | struct expr *expr_transform(struct expr *e) |
| - | { |
| - | struct expr *tmp; |
| - | |
| - | if (!e) |
| - | return NULL; |
| - | switch (e->type) { |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | case E_SYMBOL: |
| - | case E_CHOICE: |
| - | break; |
| - | default: |
| - | e->left.expr = expr_transform(e->left.expr); |
| - | e->right.expr = expr_transform(e->right.expr); |
| - | } |
| - | |
| - | switch (e->type) { |
| - | case E_EQUAL: |
| - | if (e->left.sym->type != S_BOOLEAN) |
| - | break; |
| - | if (e->right.sym == &symbol_no) { |
| - | e->type = E_NOT; |
| - | e->left.expr = expr_alloc_symbol(e->left.sym); |
| - | e->right.sym = NULL; |
| - | break; |
| - | } |
| - | if (e->right.sym == &symbol_mod) { |
| - | printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name); |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_no; |
| - | e->right.sym = NULL; |
| - | break; |
| - | } |
| - | if (e->right.sym == &symbol_yes) { |
| - | e->type = E_SYMBOL; |
| - | e->right.sym = NULL; |
| - | break; |
| - | } |
| - | break; |
| - | case E_UNEQUAL: |
| - | if (e->left.sym->type != S_BOOLEAN) |
| - | break; |
| - | if (e->right.sym == &symbol_no) { |
| - | e->type = E_SYMBOL; |
| - | e->right.sym = NULL; |
| - | break; |
| - | } |
| - | if (e->right.sym == &symbol_mod) { |
| - | printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name); |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_yes; |
| - | e->right.sym = NULL; |
| - | break; |
| - | } |
| - | if (e->right.sym == &symbol_yes) { |
| - | e->type = E_NOT; |
| - | e->left.expr = expr_alloc_symbol(e->left.sym); |
| - | e->right.sym = NULL; |
| - | break; |
| - | } |
| - | break; |
| - | case E_NOT: |
| - | switch (e->left.expr->type) { |
| - | case E_NOT: |
| - | // !!a -> a |
| - | tmp = e->left.expr->left.expr; |
| - | free(e->left.expr); |
| - | free(e); |
| - | e = tmp; |
| - | e = expr_transform(e); |
| - | break; |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | // !a='x' -> a!='x' |
| - | tmp = e->left.expr; |
| - | free(e); |
| - | e = tmp; |
| - | e->type = e->type == E_EQUAL ? E_UNEQUAL : E_EQUAL; |
| - | break; |
| - | case E_OR: |
| - | // !(a || b) -> !a && !b |
| - | tmp = e->left.expr; |
| - | e->type = E_AND; |
| - | e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr); |
| - | tmp->type = E_NOT; |
| - | tmp->right.expr = NULL; |
| - | e = expr_transform(e); |
| - | break; |
| - | case E_AND: |
| - | // !(a && b) -> !a || !b |
| - | tmp = e->left.expr; |
| - | e->type = E_OR; |
| - | e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr); |
| - | tmp->type = E_NOT; |
| - | tmp->right.expr = NULL; |
| - | e = expr_transform(e); |
| - | break; |
| - | case E_SYMBOL: |
| - | if (e->left.expr->left.sym == &symbol_yes) { |
| - | // !'y' -> 'n' |
| - | tmp = e->left.expr; |
| - | free(e); |
| - | e = tmp; |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_no; |
| - | break; |
| - | } |
| - | if (e->left.expr->left.sym == &symbol_mod) { |
| - | // !'m' -> 'm' |
| - | tmp = e->left.expr; |
| - | free(e); |
| - | e = tmp; |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_mod; |
| - | break; |
| - | } |
| - | if (e->left.expr->left.sym == &symbol_no) { |
| - | // !'n' -> 'y' |
| - | tmp = e->left.expr; |
| - | free(e); |
| - | e = tmp; |
| - | e->type = E_SYMBOL; |
| - | e->left.sym = &symbol_yes; |
| - | break; |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | return e; |
| - | } |
| - | |
| - | int expr_contains_symbol(struct expr *dep, struct symbol *sym) |
| - | { |
| - | if (!dep) |
| - | return 0; |
| - | |
| - | switch (dep->type) { |
| - | case E_AND: |
| - | case E_OR: |
| - | return expr_contains_symbol(dep->left.expr, sym) || |
| - | expr_contains_symbol(dep->right.expr, sym); |
| - | case E_SYMBOL: |
| - | return dep->left.sym == sym; |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | return dep->left.sym == sym || |
| - | dep->right.sym == sym; |
| - | case E_NOT: |
| - | return expr_contains_symbol(dep->left.expr, sym); |
| - | default: |
| - | ; |
| - | } |
| - | return 0; |
| - | } |
| - | |
| - | bool expr_depends_symbol(struct expr *dep, struct symbol *sym) |
| - | { |
| - | if (!dep) |
| - | return false; |
| - | |
| - | switch (dep->type) { |
| - | case E_AND: |
| - | return expr_depends_symbol(dep->left.expr, sym) || |
| - | expr_depends_symbol(dep->right.expr, sym); |
| - | case E_SYMBOL: |
| - | return dep->left.sym == sym; |
| - | case E_EQUAL: |
| - | if (dep->left.sym == sym) { |
| - | if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod) |
| - | return true; |
| - | } |
| - | break; |
| - | case E_UNEQUAL: |
| - | if (dep->left.sym == sym) { |
| - | if (dep->right.sym == &symbol_no) |
| - | return true; |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | return false; |
| - | } |
| - | |
| - | struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2) |
| - | { |
| - | struct expr *tmp = NULL; |
| - | expr_extract_eq(E_AND, &tmp, ep1, ep2); |
| - | if (tmp) { |
| - | *ep1 = expr_eliminate_yn(*ep1); |
| - | *ep2 = expr_eliminate_yn(*ep2); |
| - | } |
| - | return tmp; |
| - | } |
| - | |
| - | struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2) |
| - | { |
| - | struct expr *tmp = NULL; |
| - | expr_extract_eq(E_OR, &tmp, ep1, ep2); |
| - | if (tmp) { |
| - | *ep1 = expr_eliminate_yn(*ep1); |
| - | *ep2 = expr_eliminate_yn(*ep2); |
| - | } |
| - | return tmp; |
| - | } |
| - | |
| - | void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2) |
| - | { |
| - | #define e1 (*ep1) |
| - | #define e2 (*ep2) |
| - | if (e1->type == type) { |
| - | expr_extract_eq(type, ep, &e1->left.expr, &e2); |
| - | expr_extract_eq(type, ep, &e1->right.expr, &e2); |
| - | return; |
| - | } |
| - | if (e2->type == type) { |
| - | expr_extract_eq(type, ep, ep1, &e2->left.expr); |
| - | expr_extract_eq(type, ep, ep1, &e2->right.expr); |
| - | return; |
| - | } |
| - | if (expr_eq(e1, e2)) { |
| - | *ep = *ep ? expr_alloc_two(type, *ep, e1) : e1; |
| - | expr_free(e2); |
| - | if (type == E_AND) { |
| - | e1 = expr_alloc_symbol(&symbol_yes); |
| - | e2 = expr_alloc_symbol(&symbol_yes); |
| - | } else if (type == E_OR) { |
| - | e1 = expr_alloc_symbol(&symbol_no); |
| - | e2 = expr_alloc_symbol(&symbol_no); |
| - | } |
| - | } |
| - | #undef e1 |
| - | #undef e2 |
| - | } |
| - | |
| - | struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym) |
| - | { |
| - | struct expr *e1, *e2; |
| - | |
| - | if (!e) { |
| - | e = expr_alloc_symbol(sym); |
| - | if (type == E_UNEQUAL) |
| - | e = expr_alloc_one(E_NOT, e); |
| - | return e; |
| - | } |
| - | switch (e->type) { |
| - | case E_AND: |
| - | e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); |
| - | e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym); |
| - | if (sym == &symbol_yes) |
| - | e = expr_alloc_two(E_AND, e1, e2); |
| - | if (sym == &symbol_no) |
| - | e = expr_alloc_two(E_OR, e1, e2); |
| - | if (type == E_UNEQUAL) |
| - | e = expr_alloc_one(E_NOT, e); |
| - | return e; |
| - | case E_OR: |
| - | e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym); |
| - | e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym); |
| - | if (sym == &symbol_yes) |
| - | e = expr_alloc_two(E_OR, e1, e2); |
| - | if (sym == &symbol_no) |
| - | e = expr_alloc_two(E_AND, e1, e2); |
| - | if (type == E_UNEQUAL) |
| - | e = expr_alloc_one(E_NOT, e); |
| - | return e; |
| - | case E_NOT: |
| - | return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym); |
| - | case E_UNEQUAL: |
| - | case E_EQUAL: |
| - | if (type == E_EQUAL) { |
| - | if (sym == &symbol_yes) |
| - | return expr_copy(e); |
| - | if (sym == &symbol_mod) |
| - | return expr_alloc_symbol(&symbol_no); |
| - | if (sym == &symbol_no) |
| - | return expr_alloc_one(E_NOT, expr_copy(e)); |
| - | } else { |
| - | if (sym == &symbol_yes) |
| - | return expr_alloc_one(E_NOT, expr_copy(e)); |
| - | if (sym == &symbol_mod) |
| - | return expr_alloc_symbol(&symbol_yes); |
| - | if (sym == &symbol_no) |
| - | return expr_copy(e); |
| - | } |
| - | break; |
| - | case E_SYMBOL: |
| - | return expr_alloc_comp(type, e->left.sym, sym); |
| - | case E_CHOICE: |
| - | case E_RANGE: |
| - | case E_NONE: |
| - | /* panic */; |
| - | } |
| - | return NULL; |
| - | } |
| - | |
| - | tristate expr_calc_value(struct expr *e) |
| - | { |
| - | tristate val1, val2; |
| - | const char *str1, *str2; |
| - | |
| - | if (!e) |
| - | return yes; |
| - | |
| - | switch (e->type) { |
| - | case E_SYMBOL: |
| - | sym_calc_value(e->left.sym); |
| - | return e->left.sym->curr.tri; |
| - | case E_AND: |
| - | val1 = expr_calc_value(e->left.expr); |
| - | val2 = expr_calc_value(e->right.expr); |
| - | return E_AND(val1, val2); |
| - | case E_OR: |
| - | val1 = expr_calc_value(e->left.expr); |
| - | val2 = expr_calc_value(e->right.expr); |
| - | return E_OR(val1, val2); |
| - | case E_NOT: |
| - | val1 = expr_calc_value(e->left.expr); |
| - | return E_NOT(val1); |
| - | case E_EQUAL: |
| - | sym_calc_value(e->left.sym); |
| - | sym_calc_value(e->right.sym); |
| - | str1 = sym_get_string_value(e->left.sym); |
| - | str2 = sym_get_string_value(e->right.sym); |
| - | return !strcmp(str1, str2) ? yes : no; |
| - | case E_UNEQUAL: |
| - | sym_calc_value(e->left.sym); |
| - | sym_calc_value(e->right.sym); |
| - | str1 = sym_get_string_value(e->left.sym); |
| - | str2 = sym_get_string_value(e->right.sym); |
| - | return !strcmp(str1, str2) ? no : yes; |
| - | default: |
| - | printf("expr_calc_value: %d?\n", e->type); |
| - | return no; |
| - | } |
| - | } |
| - | |
| - | int expr_compare_type(enum expr_type t1, enum expr_type t2) |
| - | { |
| - | #if 0 |
| - | return 1; |
| - | #else |
| - | if (t1 == t2) |
| - | return 0; |
| - | switch (t1) { |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | if (t2 == E_NOT) |
| - | return 1; |
| - | case E_NOT: |
| - | if (t2 == E_AND) |
| - | return 1; |
| - | case E_AND: |
| - | if (t2 == E_OR) |
| - | return 1; |
| - | case E_OR: |
| - | if (t2 == E_CHOICE) |
| - | return 1; |
| - | case E_CHOICE: |
| - | if (t2 == 0) |
| - | return 1; |
| - | default: |
| - | return -1; |
| - | } |
| - | printf("[%dgt%d?]", t1, t2); |
| - | return 0; |
| - | #endif |
| - | } |
| - | |
| - | void expr_print(struct expr *e, void (*fn)(void *, const char *), void *data, int prevtoken) |
| - | { |
| - | if (!e) { |
| - | fn(data, "y"); |
| - | return; |
| - | } |
| - | |
| - | if (expr_compare_type(prevtoken, e->type) > 0) |
| - | fn(data, "("); |
| - | switch (e->type) { |
| - | case E_SYMBOL: |
| - | if (e->left.sym->name) |
| - | fn(data, e->left.sym->name); |
| - | else |
| - | fn(data, "<choice>"); |
| - | break; |
| - | case E_NOT: |
| - | fn(data, "!"); |
| - | expr_print(e->left.expr, fn, data, E_NOT); |
| - | break; |
| - | case E_EQUAL: |
| - | fn(data, e->left.sym->name); |
| - | fn(data, "="); |
| - | fn(data, e->right.sym->name); |
| - | break; |
| - | case E_UNEQUAL: |
| - | fn(data, e->left.sym->name); |
| - | fn(data, "!="); |
| - | fn(data, e->right.sym->name); |
| - | break; |
| - | case E_OR: |
| - | expr_print(e->left.expr, fn, data, E_OR); |
| - | fn(data, " || "); |
| - | expr_print(e->right.expr, fn, data, E_OR); |
| - | break; |
| - | case E_AND: |
| - | expr_print(e->left.expr, fn, data, E_AND); |
| - | fn(data, " && "); |
| - | expr_print(e->right.expr, fn, data, E_AND); |
| - | break; |
| - | case E_CHOICE: |
| - | fn(data, e->right.sym->name); |
| - | if (e->left.expr) { |
| - | fn(data, " ^ "); |
| - | expr_print(e->left.expr, fn, data, E_CHOICE); |
| - | } |
| - | break; |
| - | case E_RANGE: |
| - | fn(data, "["); |
| - | fn(data, e->left.sym->name); |
| - | fn(data, " "); |
| - | fn(data, e->right.sym->name); |
| - | fn(data, "]"); |
| - | break; |
| - | default: |
| - | { |
| - | char buf[32]; |
| - | sprintf(buf, "<unknown type %d>", e->type); |
| - | fn(data, buf); |
| - | break; |
| - | } |
| - | } |
| - | if (expr_compare_type(prevtoken, e->type) > 0) |
| - | fn(data, ")"); |
| - | } |
| - | |
| - | static void expr_print_file_helper(void *data, const char *str) |
| - | { |
| - | fwrite(str, strlen(str), 1, data); |
| - | } |
| - | |
| - | void expr_fprint(struct expr *e, FILE *out) |
| - | { |
| - | expr_print(e, expr_print_file_helper, out, E_NONE); |
| - | } |
| - | |
| - | static void expr_print_gstr_helper(void *data, const char *str) |
| - | { |
| - | str_append((struct gstr*)data, str); |
| - | } |
| - | |
| - | void expr_gstr_print(struct expr *e, struct gstr *gs) |
| - | { |
| - | expr_print(e, expr_print_gstr_helper, gs, E_NONE); |
| - | } |
| @@ -1,196 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #ifndef EXPR_H |
| - | #define EXPR_H |
| - | |
| - | #ifdef __cplusplus |
| - | extern "C" { |
| - | #endif |
| - | |
| - | #include <stdio.h> |
| - | #ifndef __cplusplus |
| - | #include <stdbool.h> |
| - | #endif |
| - | |
| - | struct file { |
| - | struct file *next; |
| - | struct file *parent; |
| - | char *name; |
| - | int lineno; |
| - | int flags; |
| - | }; |
| - | |
| - | #define FILE_BUSY 0x0001 |
| - | #define FILE_SCANNED 0x0002 |
| - | #define FILE_PRINTED 0x0004 |
| - | |
| - | typedef enum tristate { |
| - | no, mod, yes |
| - | } tristate; |
| - | |
| - | enum expr_type { |
| - | E_NONE, E_OR, E_AND, E_NOT, E_EQUAL, E_UNEQUAL, E_CHOICE, E_SYMBOL, E_RANGE |
| - | }; |
| - | |
| - | union expr_data { |
| - | struct expr *expr; |
| - | struct symbol *sym; |
| - | }; |
| - | |
| - | struct expr { |
| - | enum expr_type type; |
| - | union expr_data left, right; |
| - | }; |
| - | |
| - | #define E_OR(dep1, dep2) (((dep1)>(dep2))?(dep1):(dep2)) |
| - | #define E_AND(dep1, dep2) (((dep1)<(dep2))?(dep1):(dep2)) |
| - | #define E_NOT(dep) (2-(dep)) |
| - | |
| - | struct expr_value { |
| - | struct expr *expr; |
| - | tristate tri; |
| - | }; |
| - | |
| - | struct symbol_value { |
| - | void *val; |
| - | tristate tri; |
| - | }; |
| - | |
| - | enum symbol_type { |
| - | S_UNKNOWN, S_BOOLEAN, S_TRISTATE, S_INT, S_HEX, S_STRING, S_OTHER |
| - | }; |
| - | |
| - | struct symbol { |
| - | struct symbol *next; |
| - | char *name; |
| - | char *help; |
| - | enum symbol_type type; |
| - | struct symbol_value curr, user; |
| - | tristate visible; |
| - | int flags; |
| - | struct property *prop; |
| - | struct expr *dep, *dep2; |
| - | struct expr_value rev_dep; |
| - | }; |
| - | |
| - | #define for_all_symbols(i, sym) for (i = 0; i < 257; i++) for (sym = symbol_hash[i]; sym; sym = sym->next) if (sym->type != S_OTHER) |
| - | |
| - | #define SYMBOL_YES 0x0001 |
| - | #define SYMBOL_MOD 0x0002 |
| - | #define SYMBOL_NO 0x0004 |
| - | #define SYMBOL_CONST 0x0007 |
| - | #define SYMBOL_CHECK 0x0008 |
| - | #define SYMBOL_CHOICE 0x0010 |
| - | #define SYMBOL_CHOICEVAL 0x0020 |
| - | #define SYMBOL_PRINTED 0x0040 |
| - | #define SYMBOL_VALID 0x0080 |
| - | #define SYMBOL_OPTIONAL 0x0100 |
| - | #define SYMBOL_WRITE 0x0200 |
| - | #define SYMBOL_CHANGED 0x0400 |
| - | #define SYMBOL_NEW 0x0800 |
| - | #define SYMBOL_AUTO 0x1000 |
| - | #define SYMBOL_CHECKED 0x2000 |
| - | #define SYMBOL_CHECK_DONE 0x4000 |
| - | #define SYMBOL_WARNED 0x8000 |
| - | |
| - | #define SYMBOL_MAXLENGTH 256 |
| - | #define SYMBOL_HASHSIZE 257 |
| - | #define SYMBOL_HASHMASK 0xff |
| - | |
| - | enum prop_type { |
| - | P_UNKNOWN, P_PROMPT, P_COMMENT, P_MENU, P_DEFAULT, P_CHOICE, P_SELECT, P_RANGE |
| - | }; |
| - | |
| - | struct property { |
| - | struct property *next; |
| - | struct symbol *sym; |
| - | enum prop_type type; |
| - | const char *text; |
| - | struct expr_value visible; |
| - | struct expr *expr; |
| - | struct menu *menu; |
| - | struct file *file; |
| - | int lineno; |
| - | }; |
| - | |
| - | #define for_all_properties(sym, st, tok) \ |
| - | for (st = sym->prop; st; st = st->next) \ |
| - | if (st->type == (tok)) |
| - | #define for_all_defaults(sym, st) for_all_properties(sym, st, P_DEFAULT) |
| - | #define for_all_choices(sym, st) for_all_properties(sym, st, P_CHOICE) |
| - | #define for_all_prompts(sym, st) \ |
| - | for (st = sym->prop; st; st = st->next) \ |
| - | if (st->text) |
| - | |
| - | struct menu { |
| - | struct menu *next; |
| - | struct menu *parent; |
| - | struct menu *list; |
| - | struct symbol *sym; |
| - | struct property *prompt; |
| - | struct expr *dep; |
| - | unsigned int flags; |
| - | //char *help; |
| - | struct file *file; |
| - | int lineno; |
| - | void *data; |
| - | }; |
| - | |
| - | #define MENU_CHANGED 0x0001 |
| - | #define MENU_ROOT 0x0002 |
| - | |
| - | #ifndef SWIG |
| - | |
| - | extern struct file *file_list; |
| - | extern struct file *current_file; |
| - | struct file *lookup_file(const char *name); |
| - | |
| - | extern struct symbol symbol_yes, symbol_no, symbol_mod; |
| - | extern struct symbol *modules_sym; |
| - | extern int cdebug; |
| - | struct expr *expr_alloc_symbol(struct symbol *sym); |
| - | struct expr *expr_alloc_one(enum expr_type type, struct expr *ce); |
| - | struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2); |
| - | struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2); |
| - | struct expr *expr_alloc_and(struct expr *e1, struct expr *e2); |
| - | struct expr *expr_alloc_or(struct expr *e1, struct expr *e2); |
| - | struct expr *expr_copy(struct expr *org); |
| - | void expr_free(struct expr *e); |
| - | int expr_eq(struct expr *e1, struct expr *e2); |
| - | void expr_eliminate_eq(struct expr **ep1, struct expr **ep2); |
| - | tristate expr_calc_value(struct expr *e); |
| - | struct expr *expr_eliminate_yn(struct expr *e); |
| - | struct expr *expr_trans_bool(struct expr *e); |
| - | struct expr *expr_eliminate_dups(struct expr *e); |
| - | struct expr *expr_transform(struct expr *e); |
| - | int expr_contains_symbol(struct expr *dep, struct symbol *sym); |
| - | bool expr_depends_symbol(struct expr *dep, struct symbol *sym); |
| - | struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2); |
| - | struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2); |
| - | void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2); |
| - | struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym); |
| - | |
| - | void expr_fprint(struct expr *e, FILE *out); |
| - | struct gstr; /* forward */ |
| - | void expr_gstr_print(struct expr *e, struct gstr *gs); |
| - | |
| - | static inline int expr_is_yes(struct expr *e) |
| - | { |
| - | return !e || (e->type == E_SYMBOL && e->left.sym == &symbol_yes); |
| - | } |
| - | |
| - | static inline int expr_is_no(struct expr *e) |
| - | { |
| - | return e && (e->type == E_SYMBOL && e->left.sym == &symbol_no); |
| - | } |
| - | #endif |
| - | |
| - | #ifdef __cplusplus |
| - | } |
| - | #endif |
| - | |
| - | #endif /* EXPR_H */ |
| @@ -1,3688 +0,0 @@ | |
| - | |
| - | #line 3 "lex.zconf.c" |
| - | |
| - | #define YY_INT_ALIGNED short int |
| - | |
| - | /* A lexical scanner generated by flex */ |
| - | |
| - | #define FLEX_SCANNER |
| - | #define YY_FLEX_MAJOR_VERSION 2 |
| - | #define YY_FLEX_MINOR_VERSION 5 |
| - | #define YY_FLEX_SUBMINOR_VERSION 31 |
| - | #if YY_FLEX_SUBMINOR_VERSION > 0 |
| - | #define FLEX_BETA |
| - | #endif |
| - | |
| - | /* First, we deal with platform-specific or compiler-specific issues. */ |
| - | |
| - | /* begin standard C headers. */ |
| - | #include <stdio.h> |
| - | #include <string.h> |
| - | #include <errno.h> |
| - | #include <stdlib.h> |
| - | |
| - | /* end standard C headers. */ |
| - | |
| - | /* flex integer type definitions */ |
| - | |
| - | #ifndef FLEXINT_H |
| - | #define FLEXINT_H |
| - | |
| - | /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ |
| - | |
| - | #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L |
| - | #include <inttypes.h> |
| - | typedef int8_t flex_int8_t; |
| - | typedef uint8_t flex_uint8_t; |
| - | typedef int16_t flex_int16_t; |
| - | typedef uint16_t flex_uint16_t; |
| - | typedef int32_t flex_int32_t; |
| - | typedef uint32_t flex_uint32_t; |
| - | #else |
| - | typedef signed char flex_int8_t; |
| - | typedef short int flex_int16_t; |
| - | typedef int flex_int32_t; |
| - | typedef unsigned char flex_uint8_t; |
| - | typedef unsigned short int flex_uint16_t; |
| - | typedef unsigned int flex_uint32_t; |
| - | #endif /* ! C99 */ |
| - | |
| - | /* Limits of integral types. */ |
| - | #ifndef INT8_MIN |
| - | #define INT8_MIN (-128) |
| - | #endif |
| - | #ifndef INT16_MIN |
| - | #define INT16_MIN (-32767-1) |
| - | #endif |
| - | #ifndef INT32_MIN |
| - | #define INT32_MIN (-2147483647-1) |
| - | #endif |
| - | #ifndef INT8_MAX |
| - | #define INT8_MAX (127) |
| - | #endif |
| - | #ifndef INT16_MAX |
| - | #define INT16_MAX (32767) |
| - | #endif |
| - | #ifndef INT32_MAX |
| - | #define INT32_MAX (2147483647) |
| - | #endif |
| - | #ifndef UINT8_MAX |
| - | #define UINT8_MAX (255U) |
| - | #endif |
| - | #ifndef UINT16_MAX |
| - | #define UINT16_MAX (65535U) |
| - | #endif |
| - | #ifndef UINT32_MAX |
| - | #define UINT32_MAX (4294967295U) |
| - | #endif |
| - | |
| - | #endif /* ! FLEXINT_H */ |
| - | |
| - | #ifdef __cplusplus |
| - | |
| - | /* The "const" storage-class-modifier is valid. */ |
| - | #define YY_USE_CONST |
| - | |
| - | #else /* ! __cplusplus */ |
| - | |
| - | #if __STDC__ |
| - | |
| - | #define YY_USE_CONST |
| - | |
| - | #endif /* __STDC__ */ |
| - | #endif /* ! __cplusplus */ |
| - | |
| - | #ifdef YY_USE_CONST |
| - | #define yyconst const |
| - | #else |
| - | #define yyconst |
| - | #endif |
| - | |
| - | /* Returned upon end-of-file. */ |
| - | #define YY_NULL 0 |
| - | |
| - | /* Promotes a possibly negative, possibly signed char to an unsigned |
| - | * integer for use as an array index. If the signed char is negative, |
| - | * we want to instead treat it as an 8-bit unsigned char, hence the |
| - | * double cast. |
| - | */ |
| - | #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) |
| - | |
| - | /* Enter a start condition. This macro really ought to take a parameter, |
| - | * but we do it the disgusting crufty way forced on us by the ()-less |
| - | * definition of BEGIN. |
| - | */ |
| - | #define BEGIN (yy_start) = 1 + 2 * |
| - | |
| - | /* Translate the current start state into a value that can be later handed |
| - | * to BEGIN to return to the state. The YYSTATE alias is for lex |
| - | * compatibility. |
| - | */ |
| - | #define YY_START (((yy_start) - 1) / 2) |
| - | #define YYSTATE YY_START |
| - | |
| - | /* Action number for EOF rule of a given start state. */ |
| - | #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) |
| - | |
| - | /* Special action meaning "start processing a new file". */ |
| - | #define YY_NEW_FILE zconfrestart(zconfin ) |
| - | |
| - | #define YY_END_OF_BUFFER_CHAR 0 |
| - | |
| - | /* Size of default input buffer. */ |
| - | #ifndef YY_BUF_SIZE |
| - | #define YY_BUF_SIZE 16384 |
| - | #endif |
| - | |
| - | #ifndef YY_TYPEDEF_YY_BUFFER_STATE |
| - | #define YY_TYPEDEF_YY_BUFFER_STATE |
| - | typedef struct yy_buffer_state *YY_BUFFER_STATE; |
| - | #endif |
| - | |
| - | extern int zconfleng; |
| - | |
| - | extern FILE *zconfin, *zconfout; |
| - | |
| - | #define EOB_ACT_CONTINUE_SCAN 0 |
| - | #define EOB_ACT_END_OF_FILE 1 |
| - | #define EOB_ACT_LAST_MATCH 2 |
| - | |
| - | #define YY_LESS_LINENO(n) |
| - | |
| - | /* Return all but the first "n" matched characters back to the input stream. */ |
| - | #define yyless(n) \ |
| - | do \ |
| - | { \ |
| - | /* Undo effects of setting up zconftext. */ \ |
| - | int yyless_macro_arg = (n); \ |
| - | YY_LESS_LINENO(yyless_macro_arg);\ |
| - | *yy_cp = (yy_hold_char); \ |
| - | YY_RESTORE_YY_MORE_OFFSET \ |
| - | (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ |
| - | YY_DO_BEFORE_ACTION; /* set up zconftext again */ \ |
| - | } \ |
| - | while ( 0 ) |
| - | |
| - | #define unput(c) yyunput( c, (yytext_ptr) ) |
| - | |
| - | /* The following is because we cannot portably get our hands on size_t |
| - | * (without autoconf's help, which isn't available because we want |
| - | * flex-generated scanners to compile on their own). |
| - | */ |
| - | |
| - | #ifndef YY_TYPEDEF_YY_SIZE_T |
| - | #define YY_TYPEDEF_YY_SIZE_T |
| - | typedef unsigned int yy_size_t; |
| - | #endif |
| - | |
| - | #ifndef YY_STRUCT_YY_BUFFER_STATE |
| - | #define YY_STRUCT_YY_BUFFER_STATE |
| - | struct yy_buffer_state |
| - | { |
| - | FILE *yy_input_file; |
| - | |
| - | char *yy_ch_buf; /* input buffer */ |
| - | char *yy_buf_pos; /* current position in input buffer */ |
| - | |
| - | /* Size of input buffer in bytes, not including room for EOB |
| - | * characters. |
| - | */ |
| - | yy_size_t yy_buf_size; |
| - | |
| - | /* Number of characters read into yy_ch_buf, not including EOB |
| - | * characters. |
| - | */ |
| - | int yy_n_chars; |
| - | |
| - | /* Whether we "own" the buffer - i.e., we know we created it, |
| - | * and can realloc() it to grow it, and should free() it to |
| - | * delete it. |
| - | */ |
| - | int yy_is_our_buffer; |
| - | |
| - | /* Whether this is an "interactive" input source; if so, and |
| - | * if we're using stdio for input, then we want to use getc() |
| - | * instead of fread(), to make sure we stop fetching input after |
| - | * each newline. |
| - | */ |
| - | int yy_is_interactive; |
| - | |
| - | /* Whether we're considered to be at the beginning of a line. |
| - | * If so, '^' rules will be active on the next match, otherwise |
| - | * not. |
| - | */ |
| - | int yy_at_bol; |
| - | |
| - | int yy_bs_lineno; /**< The line count. */ |
| - | int yy_bs_column; /**< The column count. */ |
| - | |
| - | /* Whether to try to fill the input buffer when we reach the |
| - | * end of it. |
| - | */ |
| - | int yy_fill_buffer; |
| - | |
| - | int yy_buffer_status; |
| - | |
| - | #define YY_BUFFER_NEW 0 |
| - | #define YY_BUFFER_NORMAL 1 |
| - | /* When an EOF's been seen but there's still some text to process |
| - | * then we mark the buffer as YY_EOF_PENDING, to indicate that we |
| - | * shouldn't try reading from the input source any more. We might |
| - | * still have a bunch of tokens to match, though, because of |
| - | * possible backing-up. |
| - | * |
| - | * When we actually see the EOF, we change the status to "new" |
| - | * (via zconfrestart()), so that the user can continue scanning by |
| - | * just pointing zconfin at a new input file. |
| - | */ |
| - | #define YY_BUFFER_EOF_PENDING 2 |
| - | |
| - | }; |
| - | #endif /* !YY_STRUCT_YY_BUFFER_STATE */ |
| - | |
| - | /* Stack of input buffers. */ |
| - | static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ |
| - | static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ |
| - | static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ |
| - | |
| - | /* We provide macros for accessing buffer states in case in the |
| - | * future we want to put the buffer states in a more general |
| - | * "scanner state". |
| - | * |
| - | * Returns the top of the stack, or NULL. |
| - | */ |
| - | #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ |
| - | ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ |
| - | : NULL) |
| - | |
| - | /* Same as previous macro, but useful when we know that the buffer stack is not |
| - | * NULL or when we need an lvalue. For internal use only. |
| - | */ |
| - | #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] |
| - | |
| - | /* yy_hold_char holds the character lost when zconftext is formed. */ |
| - | static char yy_hold_char; |
| - | static int yy_n_chars; /* number of characters read into yy_ch_buf */ |
| - | int zconfleng; |
| - | |
| - | /* Points to current character in buffer. */ |
| - | static char *yy_c_buf_p = (char *) 0; |
| - | static int yy_init = 1; /* whether we need to initialize */ |
| - | static int yy_start = 0; /* start state number */ |
| - | |
| - | /* Flag which is used to allow zconfwrap()'s to do buffer switches |
| - | * instead of setting up a fresh zconfin. A bit of a hack ... |
| - | */ |
| - | static int yy_did_buffer_switch_on_eof; |
| - | |
| - | void zconfrestart (FILE *input_file ); |
| - | void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer ); |
| - | YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size ); |
| - | void zconf_delete_buffer (YY_BUFFER_STATE b ); |
| - | void zconf_flush_buffer (YY_BUFFER_STATE b ); |
| - | void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer ); |
| - | void zconfpop_buffer_state (void ); |
| - | |
| - | static void zconfensure_buffer_stack (void ); |
| - | static void zconf_load_buffer_state (void ); |
| - | static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file ); |
| - | |
| - | #define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER ) |
| - | |
| - | YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size ); |
| - | YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str ); |
| - | YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len ); |
| - | |
| - | void *zconfalloc (yy_size_t ); |
| - | void *zconfrealloc (void *,yy_size_t ); |
| - | void zconffree (void * ); |
| - | |
| - | #define yy_new_buffer zconf_create_buffer |
| - | |
| - | #define yy_set_interactive(is_interactive) \ |
| - | { \ |
| - | if ( ! YY_CURRENT_BUFFER ){ \ |
| - | zconfensure_buffer_stack (); \ |
| - | YY_CURRENT_BUFFER_LVALUE = \ |
| - | zconf_create_buffer(zconfin,YY_BUF_SIZE ); \ |
| - | } \ |
| - | YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ |
| - | } |
| - | |
| - | #define yy_set_bol(at_bol) \ |
| - | { \ |
| - | if ( ! YY_CURRENT_BUFFER ){\ |
| - | zconfensure_buffer_stack (); \ |
| - | YY_CURRENT_BUFFER_LVALUE = \ |
| - | zconf_create_buffer(zconfin,YY_BUF_SIZE ); \ |
| - | } \ |
| - | YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ |
| - | } |
| - | |
| - | #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) |
| - | |
| - | /* Begin user sect3 */ |
| - | |
| - | #define zconfwrap(n) 1 |
| - | #define YY_SKIP_YYWRAP |
| - | |
| - | typedef unsigned char YY_CHAR; |
| - | |
| - | FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0; |
| - | |
| - | typedef int yy_state_type; |
| - | |
| - | extern int zconflineno; |
| - | |
| - | int zconflineno = 1; |
| - | |
| - | extern char *zconftext; |
| - | #define yytext_ptr zconftext |
| - | static yyconst flex_int16_t yy_nxt[][38] = |
| - | { |
| - | { |
| - | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| - | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| - | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| - | 0, 0, 0, 0, 0, 0, 0, 0 |
| - | }, |
| - | |
| - | { |
| - | 11, 12, 13, 14, 12, 12, 15, 12, 12, 12, |
| - | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, |
| - | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, |
| - | 12, 12, 12, 12, 12, 12, 12, 12 |
| - | }, |
| - | |
| - | { |
| - | 11, 12, 13, 14, 12, 12, 15, 12, 12, 12, |
| - | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, |
| - | |
| - | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, |
| - | 12, 12, 12, 12, 12, 12, 12, 12 |
| - | }, |
| - | |
| - | { |
| - | 11, 16, 16, 17, 16, 16, 16, 16, 16, 16, |
| - | 16, 16, 16, 18, 16, 16, 18, 18, 19, 20, |
| - | 21, 22, 18, 18, 23, 24, 18, 25, 18, 26, |
| - | 27, 18, 28, 29, 30, 18, 18, 16 |
| - | }, |
| - | |
| - | { |
| - | 11, 16, 16, 17, 16, 16, 16, 16, 16, 16, |
| - | 16, 16, 16, 18, 16, 16, 18, 18, 19, 20, |
| - | 21, 22, 18, 18, 23, 24, 18, 25, 18, 26, |
| - | 27, 18, 28, 29, 30, 18, 18, 16 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, 31, 32, 33, 31, 31, 31, 31, 31, 31, |
| - | 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, |
| - | 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, |
| - | 31, 31, 31, 31, 31, 31, 31, 31 |
| - | }, |
| - | |
| - | { |
| - | 11, 31, 32, 33, 31, 31, 31, 31, 31, 31, |
| - | 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, |
| - | 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, |
| - | 31, 31, 31, 31, 31, 31, 31, 31 |
| - | }, |
| - | |
| - | { |
| - | 11, 34, 34, 35, 34, 36, 34, 34, 36, 34, |
| - | 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, |
| - | |
| - | 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, |
| - | 34, 34, 34, 34, 34, 34, 34, 34 |
| - | }, |
| - | |
| - | { |
| - | 11, 34, 34, 35, 34, 36, 34, 34, 36, 34, |
| - | 34, 34, 34, 34, 34, 37, 34, 34, 34, 34, |
| - | 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, |
| - | 34, 34, 34, 34, 34, 34, 34, 34 |
| - | }, |
| - | |
| - | { |
| - | 11, 38, 38, 39, 40, 41, 42, 43, 41, 44, |
| - | 45, 46, 47, 47, 48, 49, 47, 47, 47, 47, |
| - | 47, 47, 47, 47, 47, 50, 47, 47, 47, 51, |
| - | 47, 47, 47, 47, 47, 47, 47, 52 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, 38, 38, 39, 40, 41, 42, 43, 41, 44, |
| - | 45, 46, 47, 47, 48, 49, 47, 47, 47, 47, |
| - | 47, 47, 47, 47, 47, 50, 47, 47, 47, 51, |
| - | 47, 47, 47, 47, 47, 47, 47, 52 |
| - | }, |
| - | |
| - | { |
| - | -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, |
| - | -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, |
| - | -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, |
| - | -11, -11, -11, -11, -11, -11, -11, -11 |
| - | }, |
| - | |
| - | { |
| - | 11, -12, -12, -12, -12, -12, -12, -12, -12, -12, |
| - | -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, |
| - | |
| - | -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, |
| - | -12, -12, -12, -12, -12, -12, -12, -12 |
| - | }, |
| - | |
| - | { |
| - | 11, -13, 53, 54, -13, -13, 55, -13, -13, -13, |
| - | -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, |
| - | -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, |
| - | -13, -13, -13, -13, -13, -13, -13, -13 |
| - | }, |
| - | |
| - | { |
| - | 11, -14, -14, -14, -14, -14, -14, -14, -14, -14, |
| - | -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, |
| - | -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, |
| - | -14, -14, -14, -14, -14, -14, -14, -14 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, 56, 56, 57, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56 |
| - | }, |
| - | |
| - | { |
| - | 11, -16, -16, -16, -16, -16, -16, -16, -16, -16, |
| - | -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, |
| - | -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, |
| - | -16, -16, -16, -16, -16, -16, -16, -16 |
| - | }, |
| - | |
| - | { |
| - | 11, -17, -17, -17, -17, -17, -17, -17, -17, -17, |
| - | -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, |
| - | |
| - | -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, |
| - | -17, -17, -17, -17, -17, -17, -17, -17 |
| - | }, |
| - | |
| - | { |
| - | 11, -18, -18, -18, -18, -18, -18, -18, -18, -18, |
| - | -18, -18, -18, 58, -18, -18, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -18 |
| - | }, |
| - | |
| - | { |
| - | 11, -19, -19, -19, -19, -19, -19, -19, -19, -19, |
| - | -19, -19, -19, 58, -19, -19, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 59, |
| - | 58, 58, 58, 58, 58, 58, 58, -19 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -20, -20, -20, -20, -20, -20, -20, -20, -20, |
| - | -20, -20, -20, 58, -20, -20, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 60, 58, 58, 58, 58, 61, |
| - | 58, 58, 58, 58, 58, 58, 58, -20 |
| - | }, |
| - | |
| - | { |
| - | 11, -21, -21, -21, -21, -21, -21, -21, -21, -21, |
| - | -21, -21, -21, 58, -21, -21, 58, 58, 58, 58, |
| - | 58, 62, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -21 |
| - | }, |
| - | |
| - | { |
| - | 11, -22, -22, -22, -22, -22, -22, -22, -22, -22, |
| - | -22, -22, -22, 58, -22, -22, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 63, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -22 |
| - | }, |
| - | |
| - | { |
| - | 11, -23, -23, -23, -23, -23, -23, -23, -23, -23, |
| - | -23, -23, -23, 58, -23, -23, 58, 58, 58, 58, |
| - | 58, 64, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -23 |
| - | }, |
| - | |
| - | { |
| - | 11, -24, -24, -24, -24, -24, -24, -24, -24, -24, |
| - | -24, -24, -24, 58, -24, -24, 58, 58, 58, 58, |
| - | 58, 58, 65, 58, 58, 58, 58, 58, 66, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -24 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -25, -25, -25, -25, -25, -25, -25, -25, -25, |
| - | -25, -25, -25, 58, -25, -25, 58, 67, 58, 58, |
| - | 58, 68, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -25 |
| - | }, |
| - | |
| - | { |
| - | 11, -26, -26, -26, -26, -26, -26, -26, -26, -26, |
| - | -26, -26, -26, 58, -26, -26, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 69, 58, 58, 58, 58, 58, 58, -26 |
| - | }, |
| - | |
| - | { |
| - | 11, -27, -27, -27, -27, -27, -27, -27, -27, -27, |
| - | -27, -27, -27, 58, -27, -27, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 70, 58, 58, 58, 58, -27 |
| - | }, |
| - | |
| - | { |
| - | 11, -28, -28, -28, -28, -28, -28, -28, -28, -28, |
| - | -28, -28, -28, 58, -28, -28, 58, 71, 58, 58, |
| - | 58, 72, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -28 |
| - | }, |
| - | |
| - | { |
| - | 11, -29, -29, -29, -29, -29, -29, -29, -29, -29, |
| - | -29, -29, -29, 58, -29, -29, 58, 58, 58, 58, |
| - | 58, 73, 58, 58, 58, 58, 58, 58, 58, 74, |
| - | 58, 58, 58, 58, 75, 58, 58, -29 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -30, -30, -30, -30, -30, -30, -30, -30, -30, |
| - | -30, -30, -30, 58, -30, -30, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 76, 58, 58, 58, 58, -30 |
| - | }, |
| - | |
| - | { |
| - | 11, 77, 77, -31, 77, 77, 77, 77, 77, 77, |
| - | 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, |
| - | 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, |
| - | 77, 77, 77, 77, 77, 77, 77, 77 |
| - | }, |
| - | |
| - | { |
| - | 11, -32, 78, 79, -32, -32, -32, -32, -32, -32, |
| - | -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, |
| - | |
| - | -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, |
| - | -32, -32, -32, -32, -32, -32, -32, -32 |
| - | }, |
| - | |
| - | { |
| - | 11, 80, -33, -33, 80, 80, 80, 80, 80, 80, |
| - | 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, |
| - | 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, |
| - | 80, 80, 80, 80, 80, 80, 80, 80 |
| - | }, |
| - | |
| - | { |
| - | 11, 81, 81, 82, 81, -34, 81, 81, -34, 81, |
| - | 81, 81, 81, 81, 81, -34, 81, 81, 81, 81, |
| - | 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, |
| - | 81, 81, 81, 81, 81, 81, 81, 81 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -35, -35, -35, -35, -35, -35, -35, -35, -35, |
| - | -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, |
| - | -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, |
| - | -35, -35, -35, -35, -35, -35, -35, -35 |
| - | }, |
| - | |
| - | { |
| - | 11, -36, -36, -36, -36, -36, -36, -36, -36, -36, |
| - | -36, -36, -36, -36, -36, -36, -36, -36, -36, -36, |
| - | -36, -36, -36, -36, -36, -36, -36, -36, -36, -36, |
| - | -36, -36, -36, -36, -36, -36, -36, -36 |
| - | }, |
| - | |
| - | { |
| - | 11, 83, 83, 84, 83, 83, 83, 83, 83, 83, |
| - | 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, |
| - | |
| - | 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, |
| - | 83, 83, 83, 83, 83, 83, 83, 83 |
| - | }, |
| - | |
| - | { |
| - | 11, -38, -38, -38, -38, -38, -38, -38, -38, -38, |
| - | -38, -38, -38, -38, -38, -38, -38, -38, -38, -38, |
| - | -38, -38, -38, -38, -38, -38, -38, -38, -38, -38, |
| - | -38, -38, -38, -38, -38, -38, -38, -38 |
| - | }, |
| - | |
| - | { |
| - | 11, -39, -39, -39, -39, -39, -39, -39, -39, -39, |
| - | -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, |
| - | -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, |
| - | -39, -39, -39, -39, -39, -39, -39, -39 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -40, -40, -40, -40, -40, -40, -40, -40, -40, |
| - | -40, -40, -40, -40, 85, -40, -40, -40, -40, -40, |
| - | -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, |
| - | -40, -40, -40, -40, -40, -40, -40, -40 |
| - | }, |
| - | |
| - | { |
| - | 11, -41, -41, -41, -41, -41, -41, -41, -41, -41, |
| - | -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, |
| - | -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, |
| - | -41, -41, -41, -41, -41, -41, -41, -41 |
| - | }, |
| - | |
| - | { |
| - | 11, 86, 86, -42, 86, 86, 86, 86, 86, 86, |
| - | 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, |
| - | |
| - | 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, |
| - | 86, 86, 86, 86, 86, 86, 86, 86 |
| - | }, |
| - | |
| - | { |
| - | 11, -43, -43, -43, -43, -43, -43, 87, -43, -43, |
| - | -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, |
| - | -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, |
| - | -43, -43, -43, -43, -43, -43, -43, -43 |
| - | }, |
| - | |
| - | { |
| - | 11, -44, -44, -44, -44, -44, -44, -44, -44, -44, |
| - | -44, -44, -44, -44, -44, -44, -44, -44, -44, -44, |
| - | -44, -44, -44, -44, -44, -44, -44, -44, -44, -44, |
| - | -44, -44, -44, -44, -44, -44, -44, -44 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -45, -45, -45, -45, -45, -45, -45, -45, -45, |
| - | -45, -45, -45, -45, -45, -45, -45, -45, -45, -45, |
| - | -45, -45, -45, -45, -45, -45, -45, -45, -45, -45, |
| - | -45, -45, -45, -45, -45, -45, -45, -45 |
| - | }, |
| - | |
| - | { |
| - | 11, -46, -46, -46, -46, -46, -46, -46, -46, -46, |
| - | -46, 88, 89, 89, -46, -46, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -46 |
| - | }, |
| - | |
| - | { |
| - | 11, -47, -47, -47, -47, -47, -47, -47, -47, -47, |
| - | -47, 89, 89, 89, -47, -47, 89, 89, 89, 89, |
| - | |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -47 |
| - | }, |
| - | |
| - | { |
| - | 11, -48, -48, -48, -48, -48, -48, -48, -48, -48, |
| - | -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, |
| - | -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, |
| - | -48, -48, -48, -48, -48, -48, -48, -48 |
| - | }, |
| - | |
| - | { |
| - | 11, -49, -49, 90, -49, -49, -49, -49, -49, -49, |
| - | -49, -49, -49, -49, -49, -49, -49, -49, -49, -49, |
| - | -49, -49, -49, -49, -49, -49, -49, -49, -49, -49, |
| - | -49, -49, -49, -49, -49, -49, -49, -49 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -50, -50, -50, -50, -50, -50, -50, -50, -50, |
| - | -50, 89, 89, 89, -50, -50, 89, 89, 89, 89, |
| - | 89, 89, 91, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -50 |
| - | }, |
| - | |
| - | { |
| - | 11, -51, -51, -51, -51, -51, -51, -51, -51, -51, |
| - | -51, 89, 89, 89, -51, -51, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 92, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -51 |
| - | }, |
| - | |
| - | { |
| - | 11, -52, -52, -52, -52, -52, -52, -52, -52, -52, |
| - | -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, |
| - | |
| - | -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, |
| - | -52, -52, -52, -52, -52, -52, -52, 93 |
| - | }, |
| - | |
| - | { |
| - | 11, -53, 53, 54, -53, -53, 55, -53, -53, -53, |
| - | -53, -53, -53, -53, -53, -53, -53, -53, -53, -53, |
| - | -53, -53, -53, -53, -53, -53, -53, -53, -53, -53, |
| - | -53, -53, -53, -53, -53, -53, -53, -53 |
| - | }, |
| - | |
| - | { |
| - | 11, -54, -54, -54, -54, -54, -54, -54, -54, -54, |
| - | -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, |
| - | -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, |
| - | -54, -54, -54, -54, -54, -54, -54, -54 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, 56, 56, 57, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56 |
| - | }, |
| - | |
| - | { |
| - | 11, 56, 56, 57, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, |
| - | 56, 56, 56, 56, 56, 56, 56, 56 |
| - | }, |
| - | |
| - | { |
| - | 11, -57, -57, -57, -57, -57, -57, -57, -57, -57, |
| - | -57, -57, -57, -57, -57, -57, -57, -57, -57, -57, |
| - | |
| - | -57, -57, -57, -57, -57, -57, -57, -57, -57, -57, |
| - | -57, -57, -57, -57, -57, -57, -57, -57 |
| - | }, |
| - | |
| - | { |
| - | 11, -58, -58, -58, -58, -58, -58, -58, -58, -58, |
| - | -58, -58, -58, 58, -58, -58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -58 |
| - | }, |
| - | |
| - | { |
| - | 11, -59, -59, -59, -59, -59, -59, -59, -59, -59, |
| - | -59, -59, -59, 58, -59, -59, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 94, |
| - | 58, 58, 58, 58, 58, 58, 58, -59 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -60, -60, -60, -60, -60, -60, -60, -60, -60, |
| - | -60, -60, -60, 58, -60, -60, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 95, |
| - | 58, 58, 58, 58, 58, 58, 58, -60 |
| - | }, |
| - | |
| - | { |
| - | 11, -61, -61, -61, -61, -61, -61, -61, -61, -61, |
| - | -61, -61, -61, 58, -61, -61, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 96, 97, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -61 |
| - | }, |
| - | |
| - | { |
| - | 11, -62, -62, -62, -62, -62, -62, -62, -62, -62, |
| - | -62, -62, -62, 58, -62, -62, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 98, 58, 58, 58, 58, 58, 58, 58, |
| - | 99, 58, 58, 58, 58, 58, 58, -62 |
| - | }, |
| - | |
| - | { |
| - | 11, -63, -63, -63, -63, -63, -63, -63, -63, -63, |
| - | -63, -63, -63, 58, -63, -63, 58, 100, 58, 58, |
| - | 101, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -63 |
| - | }, |
| - | |
| - | { |
| - | 11, -64, -64, -64, -64, -64, -64, -64, -64, -64, |
| - | -64, -64, -64, 58, -64, -64, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 102, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 103, -64 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -65, -65, -65, -65, -65, -65, -65, -65, -65, |
| - | -65, -65, -65, 58, -65, -65, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -65 |
| - | }, |
| - | |
| - | { |
| - | 11, -66, -66, -66, -66, -66, -66, -66, -66, -66, |
| - | -66, -66, -66, 58, -66, -66, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 104, 58, 58, -66 |
| - | }, |
| - | |
| - | { |
| - | 11, -67, -67, -67, -67, -67, -67, -67, -67, -67, |
| - | -67, -67, -67, 58, -67, -67, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 105, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -67 |
| - | }, |
| - | |
| - | { |
| - | 11, -68, -68, -68, -68, -68, -68, -68, -68, -68, |
| - | -68, -68, -68, 58, -68, -68, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 106, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -68 |
| - | }, |
| - | |
| - | { |
| - | 11, -69, -69, -69, -69, -69, -69, -69, -69, -69, |
| - | -69, -69, -69, 58, -69, -69, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 107, 58, 58, -69 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -70, -70, -70, -70, -70, -70, -70, -70, -70, |
| - | -70, -70, -70, 58, -70, -70, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 108, |
| - | 58, 58, 58, 58, 58, 58, 58, -70 |
| - | }, |
| - | |
| - | { |
| - | 11, -71, -71, -71, -71, -71, -71, -71, -71, -71, |
| - | -71, -71, -71, 58, -71, -71, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 109, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -71 |
| - | }, |
| - | |
| - | { |
| - | 11, -72, -72, -72, -72, -72, -72, -72, -72, -72, |
| - | -72, -72, -72, 58, -72, -72, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 110, 58, 58, 58, 58, 58, -72 |
| - | }, |
| - | |
| - | { |
| - | 11, -73, -73, -73, -73, -73, -73, -73, -73, -73, |
| - | -73, -73, -73, 58, -73, -73, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 111, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -73 |
| - | }, |
| - | |
| - | { |
| - | 11, -74, -74, -74, -74, -74, -74, -74, -74, -74, |
| - | -74, -74, -74, 58, -74, -74, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 112, 58, -74 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -75, -75, -75, -75, -75, -75, -75, -75, -75, |
| - | -75, -75, -75, 58, -75, -75, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 113, 58, 58, 58, 58, -75 |
| - | }, |
| - | |
| - | { |
| - | 11, -76, -76, -76, -76, -76, -76, -76, -76, -76, |
| - | -76, -76, -76, 58, -76, -76, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 114, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -76 |
| - | }, |
| - | |
| - | { |
| - | 11, 77, 77, -77, 77, 77, 77, 77, 77, 77, |
| - | 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, |
| - | |
| - | 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, |
| - | 77, 77, 77, 77, 77, 77, 77, 77 |
| - | }, |
| - | |
| - | { |
| - | 11, -78, 78, 79, -78, -78, -78, -78, -78, -78, |
| - | -78, -78, -78, -78, -78, -78, -78, -78, -78, -78, |
| - | -78, -78, -78, -78, -78, -78, -78, -78, -78, -78, |
| - | -78, -78, -78, -78, -78, -78, -78, -78 |
| - | }, |
| - | |
| - | { |
| - | 11, 80, -79, -79, 80, 80, 80, 80, 80, 80, |
| - | 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, |
| - | 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, |
| - | 80, 80, 80, 80, 80, 80, 80, 80 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -80, -80, -80, -80, -80, -80, -80, -80, -80, |
| - | -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, |
| - | -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, |
| - | -80, -80, -80, -80, -80, -80, -80, -80 |
| - | }, |
| - | |
| - | { |
| - | 11, 81, 81, 82, 81, -81, 81, 81, -81, 81, |
| - | 81, 81, 81, 81, 81, -81, 81, 81, 81, 81, |
| - | 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, |
| - | 81, 81, 81, 81, 81, 81, 81, 81 |
| - | }, |
| - | |
| - | { |
| - | 11, -82, -82, -82, -82, -82, -82, -82, -82, -82, |
| - | -82, -82, -82, -82, -82, -82, -82, -82, -82, -82, |
| - | |
| - | -82, -82, -82, -82, -82, -82, -82, -82, -82, -82, |
| - | -82, -82, -82, -82, -82, -82, -82, -82 |
| - | }, |
| - | |
| - | { |
| - | 11, -83, -83, 84, -83, -83, -83, -83, -83, -83, |
| - | -83, -83, -83, -83, -83, -83, -83, -83, -83, -83, |
| - | -83, -83, -83, -83, -83, -83, -83, -83, -83, -83, |
| - | -83, -83, -83, -83, -83, -83, -83, -83 |
| - | }, |
| - | |
| - | { |
| - | 11, -84, -84, -84, -84, -84, -84, -84, -84, -84, |
| - | -84, -84, -84, -84, -84, -84, -84, -84, -84, -84, |
| - | -84, -84, -84, -84, -84, -84, -84, -84, -84, -84, |
| - | -84, -84, -84, -84, -84, -84, -84, -84 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -85, -85, -85, -85, -85, -85, -85, -85, -85, |
| - | -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, |
| - | -85, -85, -85, -85, -85, -85, -85, -85, -85, -85, |
| - | -85, -85, -85, -85, -85, -85, -85, -85 |
| - | }, |
| - | |
| - | { |
| - | 11, 86, 86, -86, 86, 86, 86, 86, 86, 86, |
| - | 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, |
| - | 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, |
| - | 86, 86, 86, 86, 86, 86, 86, 86 |
| - | }, |
| - | |
| - | { |
| - | 11, -87, -87, -87, -87, -87, -87, -87, -87, -87, |
| - | -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, |
| - | |
| - | -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, |
| - | -87, -87, -87, -87, -87, -87, -87, -87 |
| - | }, |
| - | |
| - | { |
| - | 11, -88, -88, -88, -88, -88, -88, -88, -88, -88, |
| - | -88, 115, 89, 89, -88, -88, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -88 |
| - | }, |
| - | |
| - | { |
| - | 11, -89, -89, -89, -89, -89, -89, -89, -89, -89, |
| - | -89, 89, 89, 89, -89, -89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -89 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -90, -90, -90, -90, -90, -90, -90, -90, -90, |
| - | -90, -90, -90, -90, -90, -90, -90, -90, -90, -90, |
| - | -90, -90, -90, -90, -90, -90, -90, -90, -90, -90, |
| - | -90, -90, -90, -90, -90, -90, -90, -90 |
| - | }, |
| - | |
| - | { |
| - | 11, -91, -91, -91, -91, -91, -91, -91, -91, -91, |
| - | -91, 89, 89, 89, -91, -91, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -91 |
| - | }, |
| - | |
| - | { |
| - | 11, -92, -92, -92, -92, -92, -92, -92, -92, -92, |
| - | -92, 89, 89, 89, -92, -92, 89, 89, 89, 89, |
| - | |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -92 |
| - | }, |
| - | |
| - | { |
| - | 11, -93, -93, -93, -93, -93, -93, -93, -93, -93, |
| - | -93, -93, -93, -93, -93, -93, -93, -93, -93, -93, |
| - | -93, -93, -93, -93, -93, -93, -93, -93, -93, -93, |
| - | -93, -93, -93, -93, -93, -93, -93, -93 |
| - | }, |
| - | |
| - | { |
| - | 11, -94, -94, -94, -94, -94, -94, -94, -94, -94, |
| - | -94, -94, -94, 58, -94, -94, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 116, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -94 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -95, -95, -95, -95, -95, -95, -95, -95, -95, |
| - | -95, -95, -95, 58, -95, -95, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 117, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -95 |
| - | }, |
| - | |
| - | { |
| - | 11, -96, -96, -96, -96, -96, -96, -96, -96, -96, |
| - | -96, -96, -96, 58, -96, -96, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 118, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -96 |
| - | }, |
| - | |
| - | { |
| - | 11, -97, -97, -97, -97, -97, -97, -97, -97, -97, |
| - | -97, -97, -97, 58, -97, -97, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 119, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -97 |
| - | }, |
| - | |
| - | { |
| - | 11, -98, -98, -98, -98, -98, -98, -98, -98, -98, |
| - | -98, -98, -98, 58, -98, -98, 120, 121, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -98 |
| - | }, |
| - | |
| - | { |
| - | 11, -99, -99, -99, -99, -99, -99, -99, -99, -99, |
| - | -99, -99, -99, 58, -99, -99, 58, 58, 58, 58, |
| - | 58, 122, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -99 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -100, -100, -100, -100, -100, -100, -100, -100, -100, |
| - | -100, -100, -100, 58, -100, -100, 58, 58, 123, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -100 |
| - | }, |
| - | |
| - | { |
| - | 11, -101, -101, -101, -101, -101, -101, -101, -101, -101, |
| - | -101, -101, -101, 58, -101, -101, 58, 58, 58, 124, |
| - | 58, 58, 58, 58, 58, 125, 58, 126, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -101 |
| - | }, |
| - | |
| - | { |
| - | 11, -102, -102, -102, -102, -102, -102, -102, -102, -102, |
| - | -102, -102, -102, 58, -102, -102, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 127, 58, 58, 58, 58, 58, 58, -102 |
| - | }, |
| - | |
| - | { |
| - | 11, -103, -103, -103, -103, -103, -103, -103, -103, -103, |
| - | -103, -103, -103, 58, -103, -103, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -103 |
| - | }, |
| - | |
| - | { |
| - | 11, -104, -104, -104, -104, -104, -104, -104, -104, -104, |
| - | -104, -104, -104, 58, -104, -104, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -104 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -105, -105, -105, -105, -105, -105, -105, -105, -105, |
| - | -105, -105, -105, 58, -105, -105, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 128, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -105 |
| - | }, |
| - | |
| - | { |
| - | 11, -106, -106, -106, -106, -106, -106, -106, -106, -106, |
| - | -106, -106, -106, 58, -106, -106, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 129, 58, -106 |
| - | }, |
| - | |
| - | { |
| - | 11, -107, -107, -107, -107, -107, -107, -107, -107, -107, |
| - | -107, -107, -107, 58, -107, -107, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 130, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -107 |
| - | }, |
| - | |
| - | { |
| - | 11, -108, -108, -108, -108, -108, -108, -108, -108, -108, |
| - | -108, -108, -108, 58, -108, -108, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 131, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -108 |
| - | }, |
| - | |
| - | { |
| - | 11, -109, -109, -109, -109, -109, -109, -109, -109, -109, |
| - | -109, -109, -109, 58, -109, -109, 58, 58, 58, 58, |
| - | 58, 58, 58, 132, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -109 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -110, -110, -110, -110, -110, -110, -110, -110, -110, |
| - | -110, -110, -110, 58, -110, -110, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 133, 58, -110 |
| - | }, |
| - | |
| - | { |
| - | 11, -111, -111, -111, -111, -111, -111, -111, -111, -111, |
| - | -111, -111, -111, 58, -111, -111, 58, 58, 58, 58, |
| - | 58, 134, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -111 |
| - | }, |
| - | |
| - | { |
| - | 11, -112, -112, -112, -112, -112, -112, -112, -112, -112, |
| - | -112, -112, -112, 58, -112, -112, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 135, 58, 58, 58, 58, -112 |
| - | }, |
| - | |
| - | { |
| - | 11, -113, -113, -113, -113, -113, -113, -113, -113, -113, |
| - | -113, -113, -113, 58, -113, -113, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 136, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -113 |
| - | }, |
| - | |
| - | { |
| - | 11, -114, -114, -114, -114, -114, -114, -114, -114, -114, |
| - | -114, -114, -114, 58, -114, -114, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 137, 58, 58, 58, -114 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -115, -115, -115, -115, -115, -115, -115, -115, -115, |
| - | -115, 89, 89, 89, -115, -115, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, |
| - | 89, 89, 89, 89, 89, 89, 89, -115 |
| - | }, |
| - | |
| - | { |
| - | 11, -116, -116, -116, -116, -116, -116, -116, -116, -116, |
| - | -116, -116, -116, 58, -116, -116, 58, 58, 58, 58, |
| - | 58, 138, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -116 |
| - | }, |
| - | |
| - | { |
| - | 11, -117, -117, -117, -117, -117, -117, -117, -117, -117, |
| - | -117, -117, -117, 58, -117, -117, 58, 58, 58, 139, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -117 |
| - | }, |
| - | |
| - | { |
| - | 11, -118, -118, -118, -118, -118, -118, -118, -118, -118, |
| - | -118, -118, -118, 58, -118, -118, 58, 58, 58, 58, |
| - | 58, 140, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -118 |
| - | }, |
| - | |
| - | { |
| - | 11, -119, -119, -119, -119, -119, -119, -119, -119, -119, |
| - | -119, -119, -119, 58, -119, -119, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 141, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -119 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -120, -120, -120, -120, -120, -120, -120, -120, -120, |
| - | -120, -120, -120, 58, -120, -120, 58, 58, 142, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 143, 58, 58, -120 |
| - | }, |
| - | |
| - | { |
| - | 11, -121, -121, -121, -121, -121, -121, -121, -121, -121, |
| - | -121, -121, -121, 58, -121, -121, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 144, 58, -121 |
| - | }, |
| - | |
| - | { |
| - | 11, -122, -122, -122, -122, -122, -122, -122, -122, -122, |
| - | -122, -122, -122, 58, -122, -122, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 145, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -122 |
| - | }, |
| - | |
| - | { |
| - | 11, -123, -123, -123, -123, -123, -123, -123, -123, -123, |
| - | -123, -123, -123, 58, -123, -123, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 146, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -123 |
| - | }, |
| - | |
| - | { |
| - | 11, -124, -124, -124, -124, -124, -124, -124, -124, -124, |
| - | -124, -124, -124, 58, -124, -124, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 147, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -124 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -125, -125, -125, -125, -125, -125, -125, -125, -125, |
| - | -125, -125, -125, 58, -125, -125, 58, 58, 58, 58, |
| - | 58, 58, 148, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -125 |
| - | }, |
| - | |
| - | { |
| - | 11, -126, -126, -126, -126, -126, -126, -126, -126, -126, |
| - | -126, -126, -126, 58, -126, -126, 58, 58, 58, 58, |
| - | 58, 149, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -126 |
| - | }, |
| - | |
| - | { |
| - | 11, -127, -127, -127, -127, -127, -127, -127, -127, -127, |
| - | -127, -127, -127, 58, -127, -127, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -127 |
| - | }, |
| - | |
| - | { |
| - | 11, -128, -128, -128, -128, -128, -128, -128, -128, -128, |
| - | -128, -128, -128, 58, -128, -128, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 150, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -128 |
| - | }, |
| - | |
| - | { |
| - | 11, -129, -129, -129, -129, -129, -129, -129, -129, -129, |
| - | -129, -129, -129, 58, -129, -129, 58, 58, 58, 151, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -129 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -130, -130, -130, -130, -130, -130, -130, -130, -130, |
| - | -130, -130, -130, 58, -130, -130, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 152, |
| - | 58, 58, 58, 58, 58, 58, 58, -130 |
| - | }, |
| - | |
| - | { |
| - | 11, -131, -131, -131, -131, -131, -131, -131, -131, -131, |
| - | -131, -131, -131, 58, -131, -131, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 153, 58, 58, 58, 58, 58, 58, -131 |
| - | }, |
| - | |
| - | { |
| - | 11, -132, -132, -132, -132, -132, -132, -132, -132, -132, |
| - | -132, -132, -132, 58, -132, -132, 58, 58, 58, 58, |
| - | |
| - | 58, 154, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -132 |
| - | }, |
| - | |
| - | { |
| - | 11, -133, -133, -133, -133, -133, -133, -133, -133, -133, |
| - | -133, -133, -133, 58, -133, -133, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 155, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -133 |
| - | }, |
| - | |
| - | { |
| - | 11, -134, -134, -134, -134, -134, -134, -134, -134, -134, |
| - | -134, -134, -134, 58, -134, -134, 58, 58, 58, 156, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -134 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -135, -135, -135, -135, -135, -135, -135, -135, -135, |
| - | -135, -135, -135, 58, -135, -135, 58, 58, 58, 157, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -135 |
| - | }, |
| - | |
| - | { |
| - | 11, -136, -136, -136, -136, -136, -136, -136, -136, -136, |
| - | -136, -136, -136, 58, -136, -136, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 158, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -136 |
| - | }, |
| - | |
| - | { |
| - | 11, -137, -137, -137, -137, -137, -137, -137, -137, -137, |
| - | -137, -137, -137, 58, -137, -137, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 159, 58, 58, -137 |
| - | }, |
| - | |
| - | { |
| - | 11, -138, -138, -138, -138, -138, -138, -138, -138, -138, |
| - | -138, -138, -138, 58, -138, -138, 58, 160, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -138 |
| - | }, |
| - | |
| - | { |
| - | 11, -139, -139, -139, -139, -139, -139, -139, -139, -139, |
| - | -139, -139, -139, 58, -139, -139, 58, 58, 58, 58, |
| - | 58, 161, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -139 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -140, -140, -140, -140, -140, -140, -140, -140, -140, |
| - | -140, -140, -140, 58, -140, -140, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 162, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -140 |
| - | }, |
| - | |
| - | { |
| - | 11, -141, -141, -141, -141, -141, -141, -141, -141, -141, |
| - | -141, -141, -141, 58, -141, -141, 58, 58, 58, 58, |
| - | 58, 58, 58, 163, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -141 |
| - | }, |
| - | |
| - | { |
| - | 11, -142, -142, -142, -142, -142, -142, -142, -142, -142, |
| - | -142, -142, -142, 58, -142, -142, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 164, |
| - | 58, 58, 58, 58, 58, 58, 58, -142 |
| - | }, |
| - | |
| - | { |
| - | 11, -143, -143, -143, -143, -143, -143, -143, -143, -143, |
| - | -143, -143, -143, 58, -143, -143, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 165, 58, 58, 58, 58, -143 |
| - | }, |
| - | |
| - | { |
| - | 11, -144, -144, -144, -144, -144, -144, -144, -144, -144, |
| - | -144, -144, -144, 58, -144, -144, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 166, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -144 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -145, -145, -145, -145, -145, -145, -145, -145, -145, |
| - | -145, -145, -145, 58, -145, -145, 58, 58, 58, 58, |
| - | 167, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -145 |
| - | }, |
| - | |
| - | { |
| - | 11, -146, -146, -146, -146, -146, -146, -146, -146, -146, |
| - | -146, -146, -146, 58, -146, -146, 58, 58, 58, 58, |
| - | 58, 168, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -146 |
| - | }, |
| - | |
| - | { |
| - | 11, -147, -147, -147, -147, -147, -147, -147, -147, -147, |
| - | -147, -147, -147, 58, -147, -147, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 169, |
| - | 58, 58, 58, 58, 58, 58, 58, -147 |
| - | }, |
| - | |
| - | { |
| - | 11, -148, -148, -148, -148, -148, -148, -148, -148, -148, |
| - | -148, -148, -148, 58, -148, -148, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -148 |
| - | }, |
| - | |
| - | { |
| - | 11, -149, -149, -149, -149, -149, -149, -149, -149, -149, |
| - | -149, -149, -149, 58, -149, -149, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 170, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -149 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -150, -150, -150, -150, -150, -150, -150, -150, -150, |
| - | -150, -150, -150, 58, -150, -150, 58, 58, 58, 58, |
| - | 58, 171, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -150 |
| - | }, |
| - | |
| - | { |
| - | 11, -151, -151, -151, -151, -151, -151, -151, -151, -151, |
| - | -151, -151, -151, 58, -151, -151, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 172, |
| - | 58, 58, 58, 58, 58, 58, 58, -151 |
| - | }, |
| - | |
| - | { |
| - | 11, -152, -152, -152, -152, -152, -152, -152, -152, -152, |
| - | -152, -152, -152, 58, -152, -152, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 173, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -152 |
| - | }, |
| - | |
| - | { |
| - | 11, -153, -153, -153, -153, -153, -153, -153, -153, -153, |
| - | -153, -153, -153, 58, -153, -153, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 174, 58, 58, -153 |
| - | }, |
| - | |
| - | { |
| - | 11, -154, -154, -154, -154, -154, -154, -154, -154, -154, |
| - | -154, -154, -154, 58, -154, -154, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -154 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -155, -155, -155, -155, -155, -155, -155, -155, -155, |
| - | -155, -155, -155, 58, -155, -155, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 175, 58, 58, 58, 58, -155 |
| - | }, |
| - | |
| - | { |
| - | 11, -156, -156, -156, -156, -156, -156, -156, -156, -156, |
| - | -156, -156, -156, 58, -156, -156, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 176, 58, 58, -156 |
| - | }, |
| - | |
| - | { |
| - | 11, -157, -157, -157, -157, -157, -157, -157, -157, -157, |
| - | -157, -157, -157, 58, -157, -157, 58, 58, 58, 58, |
| - | |
| - | 58, 177, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -157 |
| - | }, |
| - | |
| - | { |
| - | 11, -158, -158, -158, -158, -158, -158, -158, -158, -158, |
| - | -158, -158, -158, 58, -158, -158, 58, 58, 58, 58, |
| - | 58, 58, 58, 178, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -158 |
| - | }, |
| - | |
| - | { |
| - | 11, -159, -159, -159, -159, -159, -159, -159, -159, -159, |
| - | -159, -159, -159, 58, -159, -159, 58, 179, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -159 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -160, -160, -160, -160, -160, -160, -160, -160, -160, |
| - | -160, -160, -160, 58, -160, -160, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 180, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -160 |
| - | }, |
| - | |
| - | { |
| - | 11, -161, -161, -161, -161, -161, -161, -161, -161, -161, |
| - | -161, -161, -161, 58, -161, -161, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -161 |
| - | }, |
| - | |
| - | { |
| - | 11, -162, -162, -162, -162, -162, -162, -162, -162, -162, |
| - | -162, -162, -162, 58, -162, -162, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 181, 58, 58, -162 |
| - | }, |
| - | |
| - | { |
| - | 11, -163, -163, -163, -163, -163, -163, -163, -163, -163, |
| - | -163, -163, -163, 58, -163, -163, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -163 |
| - | }, |
| - | |
| - | { |
| - | 11, -164, -164, -164, -164, -164, -164, -164, -164, -164, |
| - | -164, -164, -164, 58, -164, -164, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 182, |
| - | 58, 58, 58, 58, 58, 58, 58, -164 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -165, -165, -165, -165, -165, -165, -165, -165, -165, |
| - | -165, -165, -165, 58, -165, -165, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 183, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -165 |
| - | }, |
| - | |
| - | { |
| - | 11, -166, -166, -166, -166, -166, -166, -166, -166, -166, |
| - | -166, -166, -166, 58, -166, -166, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 184, 58, 58, -166 |
| - | }, |
| - | |
| - | { |
| - | 11, -167, -167, -167, -167, -167, -167, -167, -167, -167, |
| - | -167, -167, -167, 58, -167, -167, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 185, 58, 58, 58, -167 |
| - | }, |
| - | |
| - | { |
| - | 11, -168, -168, -168, -168, -168, -168, -168, -168, -168, |
| - | -168, -168, -168, 58, -168, -168, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -168 |
| - | }, |
| - | |
| - | { |
| - | 11, -169, -169, -169, -169, -169, -169, -169, -169, -169, |
| - | -169, -169, -169, 58, -169, -169, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 186, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -169 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -170, -170, -170, -170, -170, -170, -170, -170, -170, |
| - | -170, -170, -170, 58, -170, -170, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 187, 58, -170 |
| - | }, |
| - | |
| - | { |
| - | 11, -171, -171, -171, -171, -171, -171, -171, -171, -171, |
| - | -171, -171, -171, 58, -171, -171, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 188, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -171 |
| - | }, |
| - | |
| - | { |
| - | 11, -172, -172, -172, -172, -172, -172, -172, -172, -172, |
| - | -172, -172, -172, 58, -172, -172, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 189, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -172 |
| - | }, |
| - | |
| - | { |
| - | 11, -173, -173, -173, -173, -173, -173, -173, -173, -173, |
| - | -173, -173, -173, 58, -173, -173, 58, 190, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -173 |
| - | }, |
| - | |
| - | { |
| - | 11, -174, -174, -174, -174, -174, -174, -174, -174, -174, |
| - | -174, -174, -174, 58, -174, -174, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -174 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -175, -175, -175, -175, -175, -175, -175, -175, -175, |
| - | -175, -175, -175, 58, -175, -175, 58, 58, 58, 58, |
| - | 58, 191, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -175 |
| - | }, |
| - | |
| - | { |
| - | 11, -176, -176, -176, -176, -176, -176, -176, -176, -176, |
| - | -176, -176, -176, 58, -176, -176, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -176 |
| - | }, |
| - | |
| - | { |
| - | 11, -177, -177, -177, -177, -177, -177, -177, -177, -177, |
| - | -177, -177, -177, 58, -177, -177, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -177 |
| - | }, |
| - | |
| - | { |
| - | 11, -178, -178, -178, -178, -178, -178, -178, -178, -178, |
| - | -178, -178, -178, 58, -178, -178, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -178 |
| - | }, |
| - | |
| - | { |
| - | 11, -179, -179, -179, -179, -179, -179, -179, -179, -179, |
| - | -179, -179, -179, 58, -179, -179, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 192, 58, 58, -179 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -180, -180, -180, -180, -180, -180, -180, -180, -180, |
| - | -180, -180, -180, 58, -180, -180, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -180 |
| - | }, |
| - | |
| - | { |
| - | 11, -181, -181, -181, -181, -181, -181, -181, -181, -181, |
| - | -181, -181, -181, 58, -181, -181, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -181 |
| - | }, |
| - | |
| - | { |
| - | 11, -182, -182, -182, -182, -182, -182, -182, -182, -182, |
| - | -182, -182, -182, 58, -182, -182, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 193, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -182 |
| - | }, |
| - | |
| - | { |
| - | 11, -183, -183, -183, -183, -183, -183, -183, -183, -183, |
| - | -183, -183, -183, 58, -183, -183, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 194, 58, 58, 58, -183 |
| - | }, |
| - | |
| - | { |
| - | 11, -184, -184, -184, -184, -184, -184, -184, -184, -184, |
| - | -184, -184, -184, 58, -184, -184, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -184 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -185, -185, -185, -185, -185, -185, -185, -185, -185, |
| - | -185, -185, -185, 58, -185, -185, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -185 |
| - | }, |
| - | |
| - | { |
| - | 11, -186, -186, -186, -186, -186, -186, -186, -186, -186, |
| - | -186, -186, -186, 58, -186, -186, 58, 58, 58, 195, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -186 |
| - | }, |
| - | |
| - | { |
| - | 11, -187, -187, -187, -187, -187, -187, -187, -187, -187, |
| - | -187, -187, -187, 58, -187, -187, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -187 |
| - | }, |
| - | |
| - | { |
| - | 11, -188, -188, -188, -188, -188, -188, -188, -188, -188, |
| - | -188, -188, -188, 58, -188, -188, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 196, 58, -188 |
| - | }, |
| - | |
| - | { |
| - | 11, -189, -189, -189, -189, -189, -189, -189, -189, -189, |
| - | -189, -189, -189, 58, -189, -189, 58, 58, 58, 58, |
| - | 58, 58, 197, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -189 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -190, -190, -190, -190, -190, -190, -190, -190, -190, |
| - | -190, -190, -190, 58, -190, -190, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 198, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -190 |
| - | }, |
| - | |
| - | { |
| - | 11, -191, -191, -191, -191, -191, -191, -191, -191, -191, |
| - | -191, -191, -191, 58, -191, -191, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 199, 58, 58, 58, -191 |
| - | }, |
| - | |
| - | { |
| - | 11, -192, -192, -192, -192, -192, -192, -192, -192, -192, |
| - | -192, -192, -192, 58, -192, -192, 58, 58, 58, 58, |
| - | |
| - | 58, 200, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -192 |
| - | }, |
| - | |
| - | { |
| - | 11, -193, -193, -193, -193, -193, -193, -193, -193, -193, |
| - | -193, -193, -193, 58, -193, -193, 58, 58, 58, 58, |
| - | 58, 201, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -193 |
| - | }, |
| - | |
| - | { |
| - | 11, -194, -194, -194, -194, -194, -194, -194, -194, -194, |
| - | -194, -194, -194, 58, -194, -194, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 202, 58, 58, -194 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -195, -195, -195, -195, -195, -195, -195, -195, -195, |
| - | -195, -195, -195, 58, -195, -195, 58, 58, 58, 58, |
| - | 58, 203, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -195 |
| - | }, |
| - | |
| - | { |
| - | 11, -196, -196, -196, -196, -196, -196, -196, -196, -196, |
| - | -196, -196, -196, 58, -196, -196, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -196 |
| - | }, |
| - | |
| - | { |
| - | 11, -197, -197, -197, -197, -197, -197, -197, -197, -197, |
| - | -197, -197, -197, 58, -197, -197, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 204, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -197 |
| - | }, |
| - | |
| - | { |
| - | 11, -198, -198, -198, -198, -198, -198, -198, -198, -198, |
| - | -198, -198, -198, 58, -198, -198, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -198 |
| - | }, |
| - | |
| - | { |
| - | 11, -199, -199, -199, -199, -199, -199, -199, -199, -199, |
| - | -199, -199, -199, 58, -199, -199, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -199 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -200, -200, -200, -200, -200, -200, -200, -200, -200, |
| - | -200, -200, -200, 58, -200, -200, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -200 |
| - | }, |
| - | |
| - | { |
| - | 11, -201, -201, -201, -201, -201, -201, -201, -201, -201, |
| - | -201, -201, -201, 58, -201, -201, 58, 205, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -201 |
| - | }, |
| - | |
| - | { |
| - | 11, -202, -202, -202, -202, -202, -202, -202, -202, -202, |
| - | -202, -202, -202, 58, -202, -202, 58, 206, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -202 |
| - | }, |
| - | |
| - | { |
| - | 11, -203, -203, -203, -203, -203, -203, -203, -203, -203, |
| - | -203, -203, -203, 58, -203, -203, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -203 |
| - | }, |
| - | |
| - | { |
| - | 11, -204, -204, -204, -204, -204, -204, -204, -204, -204, |
| - | -204, -204, -204, 58, -204, -204, 58, 58, 58, 58, |
| - | 58, 58, 58, 207, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -204 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -205, -205, -205, -205, -205, -205, -205, -205, -205, |
| - | -205, -205, -205, 58, -205, -205, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 208, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -205 |
| - | }, |
| - | |
| - | { |
| - | 11, -206, -206, -206, -206, -206, -206, -206, -206, -206, |
| - | -206, -206, -206, 58, -206, -206, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 209, 58, 58, -206 |
| - | }, |
| - | |
| - | { |
| - | 11, -207, -207, -207, -207, -207, -207, -207, -207, -207, |
| - | -207, -207, -207, 58, -207, -207, 58, 58, 58, 58, |
| - | |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -207 |
| - | }, |
| - | |
| - | { |
| - | 11, -208, -208, -208, -208, -208, -208, -208, -208, -208, |
| - | -208, -208, -208, 58, -208, -208, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -208 |
| - | }, |
| - | |
| - | { |
| - | 11, -209, -209, -209, -209, -209, -209, -209, -209, -209, |
| - | -209, -209, -209, 58, -209, -209, 58, 58, 58, 58, |
| - | 58, 210, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -209 |
| - | |
| - | }, |
| - | |
| - | { |
| - | 11, -210, -210, -210, -210, -210, -210, -210, -210, -210, |
| - | -210, -210, -210, 58, -210, -210, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, |
| - | 58, 58, 58, 58, 58, 58, 58, -210 |
| - | }, |
| - | |
| - | } ; |
| - | |
| - | static yy_state_type yy_get_previous_state (void ); |
| - | static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); |
| - | static int yy_get_next_buffer (void ); |
| - | static void yy_fatal_error (yyconst char msg[] ); |
| - | |
| - | /* Done after the current pattern has been matched and before the |
| - | * corresponding action - sets up zconftext. |
| - | */ |
| - | #define YY_DO_BEFORE_ACTION \ |
| - | (yytext_ptr) = yy_bp; \ |
| - | zconfleng = (size_t) (yy_cp - yy_bp); \ |
| - | (yy_hold_char) = *yy_cp; \ |
| - | *yy_cp = '\0'; \ |
| - | (yy_c_buf_p) = yy_cp; |
| - | |
| - | #define YY_NUM_RULES 64 |
| - | #define YY_END_OF_BUFFER 65 |
| - | /* This struct is not used in this scanner, |
| - | but its presence is necessary. */ |
| - | struct yy_trans_info |
| - | { |
| - | flex_int32_t yy_verify; |
| - | flex_int32_t yy_nxt; |
| - | }; |
| - | static yyconst flex_int16_t yy_accept[211] = |
| - | { 0, |
| - | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| - | 65, 5, 4, 3, 2, 36, 37, 35, 35, 35, |
| - | 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, |
| - | 63, 60, 62, 55, 59, 58, 57, 53, 48, 42, |
| - | 47, 51, 53, 40, 41, 50, 50, 43, 53, 50, |
| - | 50, 53, 4, 3, 2, 2, 1, 35, 35, 35, |
| - | 35, 35, 35, 35, 16, 35, 35, 35, 35, 35, |
| - | 35, 35, 35, 35, 35, 35, 63, 60, 62, 61, |
| - | 55, 54, 57, 56, 44, 51, 38, 50, 50, 52, |
| - | 45, 46, 39, 35, 35, 35, 35, 35, 35, 35, |
| - | |
| - | 35, 35, 30, 29, 35, 35, 35, 35, 35, 35, |
| - | 35, 35, 35, 35, 49, 25, 35, 35, 35, 35, |
| - | 35, 35, 35, 35, 35, 35, 15, 35, 7, 35, |
| - | 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, |
| - | 35, 35, 35, 35, 35, 35, 35, 17, 35, 35, |
| - | 35, 35, 35, 34, 35, 35, 35, 35, 35, 35, |
| - | 10, 35, 13, 35, 35, 35, 35, 33, 35, 35, |
| - | 35, 35, 35, 22, 35, 32, 9, 31, 35, 26, |
| - | 12, 35, 35, 21, 18, 35, 8, 35, 35, 35, |
| - | 35, 35, 27, 35, 35, 6, 35, 20, 19, 23, |
| - | |
| - | 35, 35, 11, 35, 35, 35, 14, 28, 35, 24 |
| - | } ; |
| - | |
| - | static yyconst flex_int32_t yy_ec[256] = |
| - | { 0, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 2, 4, 5, 6, 1, 1, 7, 8, 9, |
| - | 10, 1, 1, 1, 11, 12, 12, 13, 13, 13, |
| - | 13, 13, 13, 13, 13, 13, 13, 1, 1, 1, |
| - | 14, 1, 1, 1, 13, 13, 13, 13, 13, 13, |
| - | 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, |
| - | 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, |
| - | 1, 15, 1, 1, 16, 1, 17, 18, 19, 20, |
| - | |
| - | 21, 22, 23, 24, 25, 13, 13, 26, 27, 28, |
| - | 29, 30, 31, 32, 33, 34, 35, 13, 13, 36, |
| - | 13, 13, 1, 37, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| - | 1, 1, 1, 1, 1 |
| - | } ; |
| - | |
| - | extern int zconf_flex_debug; |
| - | int zconf_flex_debug = 0; |
| - | |
| - | /* The intent behind this definition is that it'll catch |
| - | * any uses of REJECT which flex missed. |
| - | */ |
| - | #define REJECT reject_used_but_not_detected |
| - | #define yymore() yymore_used_but_not_detected |
| - | #define YY_MORE_ADJ 0 |
| - | #define YY_RESTORE_YY_MORE_OFFSET |
| - | char *zconftext; |
| - | |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <limits.h> |
| - | #include <stdio.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <unistd.h> |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | #define START_STRSIZE 16 |
| - | |
| - | char *text; |
| - | static char *text_ptr; |
| - | static int text_size, text_asize; |
| - | |
| - | struct buffer { |
| - | struct buffer *parent; |
| - | YY_BUFFER_STATE state; |
| - | }; |
| - | |
| - | struct buffer *current_buf; |
| - | |
| - | static int last_ts, first_ts; |
| - | |
| - | static void zconf_endhelp(void); |
| - | static struct buffer *zconf_endfile(void); |
| - | |
| - | void new_string(void) |
| - | { |
| - | text = malloc(START_STRSIZE); |
| - | text_asize = START_STRSIZE; |
| - | text_ptr = text; |
| - | text_size = 0; |
| - | *text_ptr = 0; |
| - | } |
| - | |
| - | void append_string(const char *str, int size) |
| - | { |
| - | int new_size = text_size + size + 1; |
| - | if (new_size > text_asize) { |
| - | text = realloc(text, new_size); |
| - | text_asize = new_size; |
| - | text_ptr = text + text_size; |
| - | } |
| - | memcpy(text_ptr, str, size); |
| - | text_ptr += size; |
| - | text_size += size; |
| - | *text_ptr = 0; |
| - | } |
| - | |
| - | void alloc_string(const char *str, int size) |
| - | { |
| - | text = malloc(size + 1); |
| - | memcpy(text, str, size); |
| - | text[size] = 0; |
| - | } |
| - | |
| - | #define INITIAL 0 |
| - | #define COMMAND 1 |
| - | #define HELP 2 |
| - | #define STRING 3 |
| - | #define PARAM 4 |
| - | |
| - | /* Special case for "unistd.h", since it is non-ANSI. We include it way |
| - | * down here because we want the user's section 1 to have been scanned first. |
| - | * The user has a chance to override it with an option. |
| - | */ |
| - | #include <unistd.h> |
| - | |
| - | #ifndef YY_EXTRA_TYPE |
| - | #define YY_EXTRA_TYPE void * |
| - | #endif |
| - | |
| - | /* Macros after this point can all be overridden by user definitions in |
| - | * section 1. |
| - | */ |
| - | |
| - | #ifndef YY_SKIP_YYWRAP |
| - | #ifdef __cplusplus |
| - | extern "C" int zconfwrap (void ); |
| - | #else |
| - | extern int zconfwrap (void ); |
| - | #endif |
| - | #endif |
| - | |
| - | static void yyunput (int c,char *buf_ptr ); |
| - | |
| - | #ifndef yytext_ptr |
| - | static void yy_flex_strncpy (char *,yyconst char *,int ); |
| - | #endif |
| - | |
| - | #ifdef YY_NEED_STRLEN |
| - | static int yy_flex_strlen (yyconst char * ); |
| - | #endif |
| - | |
| - | #ifndef YY_NO_INPUT |
| - | |
| - | #ifdef __cplusplus |
| - | static int yyinput (void ); |
| - | #else |
| - | static int input (void ); |
| - | #endif |
| - | |
| - | #endif |
| - | |
| - | /* Amount of stuff to slurp up with each read. */ |
| - | #ifndef YY_READ_BUF_SIZE |
| - | #define YY_READ_BUF_SIZE 8192 |
| - | #endif |
| - | |
| - | /* Copy whatever the last rule matched to the standard output. */ |
| - | #ifndef ECHO |
| - | /* This used to be an fputs(), but since the string might contain NUL's, |
| - | * we now use fwrite(). |
| - | */ |
| - | #define ECHO (void) fwrite( zconftext, zconfleng, 1, zconfout ) |
| - | #endif |
| - | |
| - | /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, |
| - | * is returned in "result". |
| - | */ |
| - | #ifndef YY_INPUT |
| - | #define YY_INPUT(buf,result,max_size) \ |
| - | errno=0; \ |
| - | while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \ |
| - | { \ |
| - | if( errno != EINTR) \ |
| - | { \ |
| - | YY_FATAL_ERROR( "input in flex scanner failed" ); \ |
| - | break; \ |
| - | } \ |
| - | errno=0; \ |
| - | clearerr(zconfin); \ |
| - | }\ |
| - | \ |
| - | |
| - | #endif |
| - | |
| - | /* No semi-colon after return; correct usage is to write "yyterminate();" - |
| - | * we don't want an extra ';' after the "return" because that will cause |
| - | * some compilers to complain about unreachable statements. |
| - | */ |
| - | #ifndef yyterminate |
| - | #define yyterminate() return YY_NULL |
| - | #endif |
| - | |
| - | /* Number of entries by which start-condition stack grows. */ |
| - | #ifndef YY_START_STACK_INCR |
| - | #define YY_START_STACK_INCR 25 |
| - | #endif |
| - | |
| - | /* Report a fatal error. */ |
| - | #ifndef YY_FATAL_ERROR |
| - | #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) |
| - | #endif |
| - | |
| - | /* end tables serialization structures and prototypes */ |
| - | |
| - | /* Default declaration of generated scanner - a define so the user can |
| - | * easily add parameters. |
| - | */ |
| - | #ifndef YY_DECL |
| - | #define YY_DECL_IS_OURS 1 |
| - | |
| - | extern int zconflex (void); |
| - | |
| - | #define YY_DECL int zconflex (void) |
| - | #endif /* !YY_DECL */ |
| - | |
| - | /* Code executed at the beginning of each rule, after zconftext and zconfleng |
| - | * have been set up. |
| - | */ |
| - | #ifndef YY_USER_ACTION |
| - | #define YY_USER_ACTION |
| - | #endif |
| - | |
| - | /* Code executed at the end of each rule. */ |
| - | #ifndef YY_BREAK |
| - | #define YY_BREAK break; |
| - | #endif |
| - | |
| - | #define YY_RULE_SETUP \ |
| - | YY_USER_ACTION |
| - | |
| - | /** The main scanner function which does all the work. |
| - | */ |
| - | YY_DECL |
| - | { |
| - | register yy_state_type yy_current_state; |
| - | register char *yy_cp, *yy_bp; |
| - | register int yy_act; |
| - | |
| - | int str = 0; |
| - | int ts, i; |
| - | |
| - | if ( (yy_init) ) |
| - | { |
| - | (yy_init) = 0; |
| - | |
| - | #ifdef YY_USER_INIT |
| - | YY_USER_INIT; |
| - | #endif |
| - | |
| - | if ( ! (yy_start) ) |
| - | (yy_start) = 1; /* first start state */ |
| - | |
| - | if ( ! zconfin ) |
| - | zconfin = stdin; |
| - | |
| - | if ( ! zconfout ) |
| - | zconfout = stdout; |
| - | |
| - | if ( ! YY_CURRENT_BUFFER ) { |
| - | zconfensure_buffer_stack (); |
| - | YY_CURRENT_BUFFER_LVALUE = |
| - | zconf_create_buffer(zconfin,YY_BUF_SIZE ); |
| - | } |
| - | |
| - | zconf_load_buffer_state( ); |
| - | } |
| - | |
| - | while ( 1 ) /* loops until end-of-file is reached */ |
| - | { |
| - | yy_cp = (yy_c_buf_p); |
| - | |
| - | /* Support of zconftext. */ |
| - | *yy_cp = (yy_hold_char); |
| - | |
| - | /* yy_bp points to the position in yy_ch_buf of the start of |
| - | * the current run. |
| - | */ |
| - | yy_bp = yy_cp; |
| - | |
| - | yy_current_state = (yy_start); |
| - | yy_match: |
| - | while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)] ]) > 0 ) |
| - | ++yy_cp; |
| - | |
| - | yy_current_state = -yy_current_state; |
| - | |
| - | yy_find_action: |
| - | yy_act = yy_accept[yy_current_state]; |
| - | |
| - | YY_DO_BEFORE_ACTION; |
| - | |
| - | do_action: /* This label is used only to access EOF actions. */ |
| - | |
| - | switch ( yy_act ) |
| - | { /* beginning of action switch */ |
| - | case 1: |
| - | /* rule 1 can match eol */ |
| - | YY_RULE_SETUP |
| - | current_file->lineno++; |
| - | YY_BREAK |
| - | case 2: |
| - | YY_RULE_SETUP |
| - | |
| - | YY_BREAK |
| - | case 3: |
| - | /* rule 3 can match eol */ |
| - | YY_RULE_SETUP |
| - | current_file->lineno++; return T_EOL; |
| - | YY_BREAK |
| - | case 4: |
| - | YY_RULE_SETUP |
| - | { |
| - | BEGIN(COMMAND); |
| - | } |
| - | YY_BREAK |
| - | case 5: |
| - | YY_RULE_SETUP |
| - | { |
| - | unput(zconftext[0]); |
| - | BEGIN(COMMAND); |
| - | } |
| - | YY_BREAK |
| - | |
| - | case 6: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_MAINMENU; |
| - | YY_BREAK |
| - | case 7: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_MENU; |
| - | YY_BREAK |
| - | case 8: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_ENDMENU; |
| - | YY_BREAK |
| - | case 9: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_SOURCE; |
| - | YY_BREAK |
| - | case 10: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_CHOICE; |
| - | YY_BREAK |
| - | case 11: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_ENDCHOICE; |
| - | YY_BREAK |
| - | case 12: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_COMMENT; |
| - | YY_BREAK |
| - | case 13: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_CONFIG; |
| - | YY_BREAK |
| - | case 14: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_MENUCONFIG; |
| - | YY_BREAK |
| - | case 15: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_HELP; |
| - | YY_BREAK |
| - | case 16: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_IF; |
| - | YY_BREAK |
| - | case 17: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_ENDIF; |
| - | YY_BREAK |
| - | case 18: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_DEPENDS; |
| - | YY_BREAK |
| - | case 19: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_REQUIRES; |
| - | YY_BREAK |
| - | case 20: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_OPTIONAL; |
| - | YY_BREAK |
| - | case 21: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_DEFAULT; |
| - | YY_BREAK |
| - | case 22: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_PROMPT; |
| - | YY_BREAK |
| - | case 23: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_TRISTATE; |
| - | YY_BREAK |
| - | case 24: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_DEF_TRISTATE; |
| - | YY_BREAK |
| - | case 25: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_BOOLEAN; |
| - | YY_BREAK |
| - | case 26: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_BOOLEAN; |
| - | YY_BREAK |
| - | case 27: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_DEF_BOOLEAN; |
| - | YY_BREAK |
| - | case 28: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_DEF_BOOLEAN; |
| - | YY_BREAK |
| - | case 29: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_INT; |
| - | YY_BREAK |
| - | case 30: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_HEX; |
| - | YY_BREAK |
| - | case 31: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_STRING; |
| - | YY_BREAK |
| - | case 32: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_SELECT; |
| - | YY_BREAK |
| - | case 33: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_SELECT; |
| - | YY_BREAK |
| - | case 34: |
| - | YY_RULE_SETUP |
| - | BEGIN(PARAM); return T_RANGE; |
| - | YY_BREAK |
| - | case 35: |
| - | YY_RULE_SETUP |
| - | { |
| - | alloc_string(zconftext, zconfleng); |
| - | zconflval.string = text; |
| - | return T_WORD; |
| - | } |
| - | YY_BREAK |
| - | case 36: |
| - | YY_RULE_SETUP |
| - | |
| - | YY_BREAK |
| - | case 37: |
| - | /* rule 37 can match eol */ |
| - | YY_RULE_SETUP |
| - | current_file->lineno++; BEGIN(INITIAL); |
| - | YY_BREAK |
| - | |
| - | case 38: |
| - | YY_RULE_SETUP |
| - | return T_AND; |
| - | YY_BREAK |
| - | case 39: |
| - | YY_RULE_SETUP |
| - | return T_OR; |
| - | YY_BREAK |
| - | case 40: |
| - | YY_RULE_SETUP |
| - | return T_OPEN_PAREN; |
| - | YY_BREAK |
| - | case 41: |
| - | YY_RULE_SETUP |
| - | return T_CLOSE_PAREN; |
| - | YY_BREAK |
| - | case 42: |
| - | YY_RULE_SETUP |
| - | return T_NOT; |
| - | YY_BREAK |
| - | case 43: |
| - | YY_RULE_SETUP |
| - | return T_EQUAL; |
| - | YY_BREAK |
| - | case 44: |
| - | YY_RULE_SETUP |
| - | return T_UNEQUAL; |
| - | YY_BREAK |
| - | case 45: |
| - | YY_RULE_SETUP |
| - | return T_IF; |
| - | YY_BREAK |
| - | case 46: |
| - | YY_RULE_SETUP |
| - | return T_ON; |
| - | YY_BREAK |
| - | case 47: |
| - | YY_RULE_SETUP |
| - | { |
| - | str = zconftext[0]; |
| - | new_string(); |
| - | BEGIN(STRING); |
| - | } |
| - | YY_BREAK |
| - | case 48: |
| - | /* rule 48 can match eol */ |
| - | YY_RULE_SETUP |
| - | BEGIN(INITIAL); current_file->lineno++; return T_EOL; |
| - | YY_BREAK |
| - | case 49: |
| - | YY_RULE_SETUP |
| - | /* ignore */ |
| - | YY_BREAK |
| - | case 50: |
| - | YY_RULE_SETUP |
| - | { |
| - | alloc_string(zconftext, zconfleng); |
| - | zconflval.string = text; |
| - | return T_WORD; |
| - | } |
| - | YY_BREAK |
| - | case 51: |
| - | YY_RULE_SETUP |
| - | /* comment */ |
| - | YY_BREAK |
| - | case 52: |
| - | /* rule 52 can match eol */ |
| - | YY_RULE_SETUP |
| - | current_file->lineno++; |
| - | YY_BREAK |
| - | case 53: |
| - | YY_RULE_SETUP |
| - | |
| - | YY_BREAK |
| - | case YY_STATE_EOF(PARAM): |
| - | { |
| - | BEGIN(INITIAL); |
| - | } |
| - | YY_BREAK |
| - | |
| - | case 54: |
| - | /* rule 54 can match eol */ |
| - | *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */ |
| - | (yy_c_buf_p) = yy_cp -= 1; |
| - | YY_DO_BEFORE_ACTION; /* set up zconftext again */ |
| - | YY_RULE_SETUP |
| - | { |
| - | append_string(zconftext, zconfleng); |
| - | zconflval.string = text; |
| - | return T_WORD_QUOTE; |
| - | } |
| - | YY_BREAK |
| - | case 55: |
| - | YY_RULE_SETUP |
| - | { |
| - | append_string(zconftext, zconfleng); |
| - | } |
| - | YY_BREAK |
| - | case 56: |
| - | /* rule 56 can match eol */ |
| - | *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */ |
| - | (yy_c_buf_p) = yy_cp -= 1; |
| - | YY_DO_BEFORE_ACTION; /* set up zconftext again */ |
| - | YY_RULE_SETUP |
| - | { |
| - | append_string(zconftext + 1, zconfleng - 1); |
| - | zconflval.string = text; |
| - | return T_WORD_QUOTE; |
| - | } |
| - | YY_BREAK |
| - | case 57: |
| - | YY_RULE_SETUP |
| - | { |
| - | append_string(zconftext + 1, zconfleng - 1); |
| - | } |
| - | YY_BREAK |
| - | case 58: |
| - | YY_RULE_SETUP |
| - | { |
| - | if (str == zconftext[0]) { |
| - | BEGIN(PARAM); |
| - | zconflval.string = text; |
| - | return T_WORD_QUOTE; |
| - | } else |
| - | append_string(zconftext, 1); |
| - | } |
| - | YY_BREAK |
| - | case 59: |
| - | /* rule 59 can match eol */ |
| - | YY_RULE_SETUP |
| - | { |
| - | printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno()); |
| - | current_file->lineno++; |
| - | BEGIN(INITIAL); |
| - | return T_EOL; |
| - | } |
| - | YY_BREAK |
| - | case YY_STATE_EOF(STRING): |
| - | { |
| - | BEGIN(INITIAL); |
| - | } |
| - | YY_BREAK |
| - | |
| - | case 60: |
| - | YY_RULE_SETUP |
| - | { |
| - | ts = 0; |
| - | for (i = 0; i < zconfleng; i++) { |
| - | if (zconftext[i] == '\t') |
| - | ts = (ts & ~7) + 8; |
| - | else |
| - | ts++; |
| - | } |
| - | last_ts = ts; |
| - | if (first_ts) { |
| - | if (ts < first_ts) { |
| - | zconf_endhelp(); |
| - | return T_HELPTEXT; |
| - | } |
| - | ts -= first_ts; |
| - | while (ts > 8) { |
| - | append_string(" ", 8); |
| - | ts -= 8; |
| - | } |
| - | append_string(" ", ts); |
| - | } |
| - | } |
| - | YY_BREAK |
| - | case 61: |
| - | /* rule 61 can match eol */ |
| - | *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */ |
| - | (yy_c_buf_p) = yy_cp -= 1; |
| - | YY_DO_BEFORE_ACTION; /* set up zconftext again */ |
| - | YY_RULE_SETUP |
| - | { |
| - | current_file->lineno++; |
| - | zconf_endhelp(); |
| - | return T_HELPTEXT; |
| - | } |
| - | YY_BREAK |
| - | case 62: |
| - | /* rule 62 can match eol */ |
| - | YY_RULE_SETUP |
| - | { |
| - | current_file->lineno++; |
| - | append_string("\n", 1); |
| - | } |
| - | YY_BREAK |
| - | case 63: |
| - | YY_RULE_SETUP |
| - | { |
| - | append_string(zconftext, zconfleng); |
| - | if (!first_ts) |
| - | first_ts = last_ts; |
| - | } |
| - | YY_BREAK |
| - | case YY_STATE_EOF(HELP): |
| - | { |
| - | zconf_endhelp(); |
| - | return T_HELPTEXT; |
| - | } |
| - | YY_BREAK |
| - | |
| - | case YY_STATE_EOF(INITIAL): |
| - | case YY_STATE_EOF(COMMAND): |
| - | { |
| - | if (current_buf) { |
| - | zconf_endfile(); |
| - | return T_EOF; |
| - | } |
| - | fclose(zconfin); |
| - | yyterminate(); |
| - | } |
| - | YY_BREAK |
| - | case 64: |
| - | YY_RULE_SETUP |
| - | YY_FATAL_ERROR( "flex scanner jammed" ); |
| - | YY_BREAK |
| - | |
| - | case YY_END_OF_BUFFER: |
| - | { |
| - | /* Amount of text matched not including the EOB char. */ |
| - | int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; |
| - | |
| - | /* Undo the effects of YY_DO_BEFORE_ACTION. */ |
| - | *yy_cp = (yy_hold_char); |
| - | YY_RESTORE_YY_MORE_OFFSET |
| - | |
| - | if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) |
| - | { |
| - | /* We're scanning a new file or input source. It's |
| - | * possible that this happened because the user |
| - | * just pointed zconfin at a new source and called |
| - | * zconflex(). If so, then we have to assure |
| - | * consistency between YY_CURRENT_BUFFER and our |
| - | * globals. Here is the right place to do so, because |
| - | * this is the first action (other than possibly a |
| - | * back-up) that will match for the new input source. |
| - | */ |
| - | (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; |
| - | YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin; |
| - | YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; |
| - | } |
| - | |
| - | /* Note that here we test for yy_c_buf_p "<=" to the position |
| - | * of the first EOB in the buffer, since yy_c_buf_p will |
| - | * already have been incremented past the NUL character |
| - | * (since all states make transitions on EOB to the |
| - | * end-of-buffer state). Contrast this with the test |
| - | * in input(). |
| - | */ |
| - | if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) |
| - | { /* This was really a NUL. */ |
| - | yy_state_type yy_next_state; |
| - | |
| - | (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; |
| - | |
| - | yy_current_state = yy_get_previous_state( ); |
| - | |
| - | /* Okay, we're now positioned to make the NUL |
| - | * transition. We couldn't have |
| - | * yy_get_previous_state() go ahead and do it |
| - | * for us because it doesn't know how to deal |
| - | * with the possibility of jamming (and we don't |
| - | * want to build jamming into it because then it |
| - | * will run more slowly). |
| - | */ |
| - | |
| - | yy_next_state = yy_try_NUL_trans( yy_current_state ); |
| - | |
| - | yy_bp = (yytext_ptr) + YY_MORE_ADJ; |
| - | |
| - | if ( yy_next_state ) |
| - | { |
| - | /* Consume the NUL. */ |
| - | yy_cp = ++(yy_c_buf_p); |
| - | yy_current_state = yy_next_state; |
| - | goto yy_match; |
| - | } |
| - | |
| - | else |
| - | { |
| - | yy_cp = (yy_c_buf_p); |
| - | goto yy_find_action; |
| - | } |
| - | } |
| - | |
| - | else switch ( yy_get_next_buffer( ) ) |
| - | { |
| - | case EOB_ACT_END_OF_FILE: |
| - | { |
| - | (yy_did_buffer_switch_on_eof) = 0; |
| - | |
| - | if ( zconfwrap( ) ) |
| - | { |
| - | /* Note: because we've taken care in |
| - | * yy_get_next_buffer() to have set up |
| - | * zconftext, we can now set up |
| - | * yy_c_buf_p so that if some total |
| - | * hoser (like flex itself) wants to |
| - | * call the scanner after we return the |
| - | * YY_NULL, it'll still work - another |
| - | * YY_NULL will get returned. |
| - | */ |
| - | (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; |
| - | |
| - | yy_act = YY_STATE_EOF(YY_START); |
| - | goto do_action; |
| - | } |
| - | |
| - | else |
| - | { |
| - | if ( ! (yy_did_buffer_switch_on_eof) ) |
| - | YY_NEW_FILE; |
| - | } |
| - | break; |
| - | } |
| - | |
| - | case EOB_ACT_CONTINUE_SCAN: |
| - | (yy_c_buf_p) = |
| - | (yytext_ptr) + yy_amount_of_matched_text; |
| - | |
| - | yy_current_state = yy_get_previous_state( ); |
| - | |
| - | yy_cp = (yy_c_buf_p); |
| - | yy_bp = (yytext_ptr) + YY_MORE_ADJ; |
| - | goto yy_match; |
| - | |
| - | case EOB_ACT_LAST_MATCH: |
| - | (yy_c_buf_p) = |
| - | &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; |
| - | |
| - | yy_current_state = yy_get_previous_state( ); |
| - | |
| - | yy_cp = (yy_c_buf_p); |
| - | yy_bp = (yytext_ptr) + YY_MORE_ADJ; |
| - | goto yy_find_action; |
| - | } |
| - | break; |
| - | } |
| - | |
| - | default: |
| - | YY_FATAL_ERROR( |
| - | "fatal flex scanner internal error--no action found" ); |
| - | } /* end of action switch */ |
| - | } /* end of scanning one token */ |
| - | } /* end of zconflex */ |
| - | |
| - | /* yy_get_next_buffer - try to read in a new buffer |
| - | * |
| - | * Returns a code representing an action: |
| - | * EOB_ACT_LAST_MATCH - |
| - | * EOB_ACT_CONTINUE_SCAN - continue scanning from current position |
| - | * EOB_ACT_END_OF_FILE - end of file |
| - | */ |
| - | static int yy_get_next_buffer (void) |
| - | { |
| - | register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; |
| - | register char *source = (yytext_ptr); |
| - | register int number_to_move, i; |
| - | int ret_val; |
| - | |
| - | if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) |
| - | YY_FATAL_ERROR( |
| - | "fatal flex scanner internal error--end of buffer missed" ); |
| - | |
| - | if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) |
| - | { /* Don't try to fill the buffer, so this is an EOF. */ |
| - | if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) |
| - | { |
| - | /* We matched a single character, the EOB, so |
| - | * treat this as a final EOF. |
| - | */ |
| - | return EOB_ACT_END_OF_FILE; |
| - | } |
| - | |
| - | else |
| - | { |
| - | /* We matched some text prior to the EOB, first |
| - | * process it. |
| - | */ |
| - | return EOB_ACT_LAST_MATCH; |
| - | } |
| - | } |
| - | |
| - | /* Try to read more data. */ |
| - | |
| - | /* First move last chars to start of buffer. */ |
| - | number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; |
| - | |
| - | for ( i = 0; i < number_to_move; ++i ) |
| - | *(dest++) = *(source++); |
| - | |
| - | if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) |
| - | /* don't do the read, it's not guaranteed to return an EOF, |
| - | * just force an EOF |
| - | */ |
| - | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; |
| - | |
| - | else |
| - | { |
| - | size_t num_to_read = |
| - | YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; |
| - | |
| - | while ( num_to_read <= 0 ) |
| - | { /* Not enough room in the buffer - grow it. */ |
| - | |
| - | /* just a shorter name for the current buffer */ |
| - | YY_BUFFER_STATE b = YY_CURRENT_BUFFER; |
| - | |
| - | int yy_c_buf_p_offset = |
| - | (int) ((yy_c_buf_p) - b->yy_ch_buf); |
| - | |
| - | if ( b->yy_is_our_buffer ) |
| - | { |
| - | int new_size = b->yy_buf_size * 2; |
| - | |
| - | if ( new_size <= 0 ) |
| - | b->yy_buf_size += b->yy_buf_size / 8; |
| - | else |
| - | b->yy_buf_size *= 2; |
| - | |
| - | b->yy_ch_buf = (char *) |
| - | /* Include room in for 2 EOB chars. */ |
| - | zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); |
| - | } |
| - | else |
| - | /* Can't grow it, we don't own it. */ |
| - | b->yy_ch_buf = 0; |
| - | |
| - | if ( ! b->yy_ch_buf ) |
| - | YY_FATAL_ERROR( |
| - | "fatal error - scanner input buffer overflow" ); |
| - | |
| - | (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; |
| - | |
| - | num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - |
| - | number_to_move - 1; |
| - | |
| - | } |
| - | |
| - | if ( num_to_read > YY_READ_BUF_SIZE ) |
| - | num_to_read = YY_READ_BUF_SIZE; |
| - | |
| - | /* Read in more data. */ |
| - | YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), |
| - | (yy_n_chars), num_to_read ); |
| - | |
| - | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
| - | } |
| - | |
| - | if ( (yy_n_chars) == 0 ) |
| - | { |
| - | if ( number_to_move == YY_MORE_ADJ ) |
| - | { |
| - | ret_val = EOB_ACT_END_OF_FILE; |
| - | zconfrestart(zconfin ); |
| - | } |
| - | |
| - | else |
| - | { |
| - | ret_val = EOB_ACT_LAST_MATCH; |
| - | YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = |
| - | YY_BUFFER_EOF_PENDING; |
| - | } |
| - | } |
| - | |
| - | else |
| - | ret_val = EOB_ACT_CONTINUE_SCAN; |
| - | |
| - | (yy_n_chars) += number_to_move; |
| - | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; |
| - | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; |
| - | |
| - | (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; |
| - | |
| - | return ret_val; |
| - | } |
| - | |
| - | /* yy_get_previous_state - get the state just before the EOB char was reached */ |
| - | |
| - | static yy_state_type yy_get_previous_state (void) |
| - | { |
| - | register yy_state_type yy_current_state; |
| - | register char *yy_cp; |
| - | |
| - | yy_current_state = (yy_start); |
| - | |
| - | for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) |
| - | { |
| - | yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)]; |
| - | } |
| - | |
| - | return yy_current_state; |
| - | } |
| - | |
| - | /* yy_try_NUL_trans - try to make a transition on the NUL character |
| - | * |
| - | * synopsis |
| - | * next_state = yy_try_NUL_trans( current_state ); |
| - | */ |
| - | static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) |
| - | { |
| - | register int yy_is_jam; |
| - | |
| - | yy_current_state = yy_nxt[yy_current_state][1]; |
| - | yy_is_jam = (yy_current_state <= 0); |
| - | |
| - | return yy_is_jam ? 0 : yy_current_state; |
| - | } |
| - | |
| - | static void yyunput (int c, register char * yy_bp ) |
| - | { |
| - | register char *yy_cp; |
| - | |
| - | yy_cp = (yy_c_buf_p); |
| - | |
| - | /* undo effects of setting up zconftext */ |
| - | *yy_cp = (yy_hold_char); |
| - | |
| - | if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) |
| - | { /* need to shift things up to make room */ |
| - | /* +2 for EOB chars. */ |
| - | register int number_to_move = (yy_n_chars) + 2; |
| - | register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ |
| - | YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; |
| - | register char *source = |
| - | &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; |
| - | |
| - | while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) |
| - | *--dest = *--source; |
| - | |
| - | yy_cp += (int) (dest - source); |
| - | yy_bp += (int) (dest - source); |
| - | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = |
| - | (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; |
| - | |
| - | if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) |
| - | YY_FATAL_ERROR( "flex scanner push-back overflow" ); |
| - | } |
| - | |
| - | *--yy_cp = (char) c; |
| - | |
| - | (yytext_ptr) = yy_bp; |
| - | (yy_hold_char) = *yy_cp; |
| - | (yy_c_buf_p) = yy_cp; |
| - | } |
| - | |
| - | #ifndef YY_NO_INPUT |
| - | #ifdef __cplusplus |
| - | static int yyinput (void) |
| - | #else |
| - | static int input (void) |
| - | #endif |
| - | |
| - | { |
| - | int c; |
| - | |
| - | *(yy_c_buf_p) = (yy_hold_char); |
| - | |
| - | if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) |
| - | { |
| - | /* yy_c_buf_p now points to the character we want to return. |
| - | * If this occurs *before* the EOB characters, then it's a |
| - | * valid NUL; if not, then we've hit the end of the buffer. |
| - | */ |
| - | if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) |
| - | /* This was really a NUL. */ |
| - | *(yy_c_buf_p) = '\0'; |
| - | |
| - | else |
| - | { /* need more input */ |
| - | int offset = (yy_c_buf_p) - (yytext_ptr); |
| - | ++(yy_c_buf_p); |
| - | |
| - | switch ( yy_get_next_buffer( ) ) |
| - | { |
| - | case EOB_ACT_LAST_MATCH: |
| - | /* This happens because yy_g_n_b() |
| - | * sees that we've accumulated a |
| - | * token and flags that we need to |
| - | * try matching the token before |
| - | * proceeding. But for input(), |
| - | * there's no matching to consider. |
| - | * So convert the EOB_ACT_LAST_MATCH |
| - | * to EOB_ACT_END_OF_FILE. |
| - | */ |
| - | |
| - | /* Reset buffer status. */ |
| - | zconfrestart(zconfin ); |
| - | |
| - | /*FALLTHROUGH*/ |
| - | |
| - | case EOB_ACT_END_OF_FILE: |
| - | { |
| - | if ( zconfwrap( ) ) |
| - | return EOF; |
| - | |
| - | if ( ! (yy_did_buffer_switch_on_eof) ) |
| - | YY_NEW_FILE; |
| - | #ifdef __cplusplus |
| - | return yyinput(); |
| - | #else |
| - | return input(); |
| - | #endif |
| - | } |
| - | |
| - | case EOB_ACT_CONTINUE_SCAN: |
| - | (yy_c_buf_p) = (yytext_ptr) + offset; |
| - | break; |
| - | } |
| - | } |
| - | } |
| - | |
| - | c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ |
| - | *(yy_c_buf_p) = '\0'; /* preserve zconftext */ |
| - | (yy_hold_char) = *++(yy_c_buf_p); |
| - | |
| - | return c; |
| - | } |
| - | #endif /* ifndef YY_NO_INPUT */ |
| - | |
| - | /** Immediately switch to a different input stream. |
| - | * @param input_file A readable stream. |
| - | * |
| - | * @note This function does not reset the start condition to @c INITIAL . |
| - | */ |
| - | void zconfrestart (FILE * input_file ) |
| - | { |
| - | |
| - | if ( ! YY_CURRENT_BUFFER ){ |
| - | zconfensure_buffer_stack (); |
| - | YY_CURRENT_BUFFER_LVALUE = |
| - | zconf_create_buffer(zconfin,YY_BUF_SIZE ); |
| - | } |
| - | |
| - | zconf_init_buffer(YY_CURRENT_BUFFER,input_file ); |
| - | zconf_load_buffer_state( ); |
| - | } |
| - | |
| - | /** Switch to a different input buffer. |
| - | * @param new_buffer The new input buffer. |
| - | * |
| - | */ |
| - | void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer ) |
| - | { |
| - | |
| - | /* TODO. We should be able to replace this entire function body |
| - | * with |
| - | * zconfpop_buffer_state(); |
| - | * zconfpush_buffer_state(new_buffer); |
| - | */ |
| - | zconfensure_buffer_stack (); |
| - | if ( YY_CURRENT_BUFFER == new_buffer ) |
| - | return; |
| - | |
| - | if ( YY_CURRENT_BUFFER ) |
| - | { |
| - | /* Flush out information for old buffer. */ |
| - | *(yy_c_buf_p) = (yy_hold_char); |
| - | YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); |
| - | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
| - | } |
| - | |
| - | YY_CURRENT_BUFFER_LVALUE = new_buffer; |
| - | zconf_load_buffer_state( ); |
| - | |
| - | /* We don't actually know whether we did this switch during |
| - | * EOF (zconfwrap()) processing, but the only time this flag |
| - | * is looked at is after zconfwrap() is called, so it's safe |
| - | * to go ahead and always set it. |
| - | */ |
| - | (yy_did_buffer_switch_on_eof) = 1; |
| - | } |
| - | |
| - | static void zconf_load_buffer_state (void) |
| - | { |
| - | (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; |
| - | (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; |
| - | zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; |
| - | (yy_hold_char) = *(yy_c_buf_p); |
| - | } |
| - | |
| - | /** Allocate and initialize an input buffer state. |
| - | * @param file A readable stream. |
| - | * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. |
| - | * |
| - | * @return the allocated buffer state. |
| - | */ |
| - | YY_BUFFER_STATE zconf_create_buffer (FILE * file, int size ) |
| - | { |
| - | YY_BUFFER_STATE b; |
| - | |
| - | b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) ); |
| - | if ( ! b ) |
| - | YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" ); |
| - | |
| - | b->yy_buf_size = size; |
| - | |
| - | /* yy_ch_buf has to be 2 characters longer than the size given because |
| - | * we need to put in 2 end-of-buffer characters. |
| - | */ |
| - | b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2 ); |
| - | if ( ! b->yy_ch_buf ) |
| - | YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" ); |
| - | |
| - | b->yy_is_our_buffer = 1; |
| - | |
| - | zconf_init_buffer(b,file ); |
| - | |
| - | return b; |
| - | } |
| - | |
| - | /** Destroy the buffer. |
| - | * @param b a buffer created with zconf_create_buffer() |
| - | * |
| - | */ |
| - | void zconf_delete_buffer (YY_BUFFER_STATE b ) |
| - | { |
| - | |
| - | if ( ! b ) |
| - | return; |
| - | |
| - | if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ |
| - | YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; |
| - | |
| - | if ( b->yy_is_our_buffer ) |
| - | zconffree((void *) b->yy_ch_buf ); |
| - | |
| - | zconffree((void *) b ); |
| - | } |
| - | |
| - | /* Initializes or reinitializes a buffer. |
| - | * This function is sometimes called more than once on the same buffer, |
| - | * such as during a zconfrestart() or at EOF. |
| - | */ |
| - | static void zconf_init_buffer (YY_BUFFER_STATE b, FILE * file ) |
| - | |
| - | { |
| - | int oerrno = errno; |
| - | |
| - | zconf_flush_buffer(b ); |
| - | |
| - | b->yy_input_file = file; |
| - | b->yy_fill_buffer = 1; |
| - | |
| - | /* If b is the current buffer, then zconf_init_buffer was _probably_ |
| - | * called from zconfrestart() or through yy_get_next_buffer. |
| - | * In that case, we don't want to reset the lineno or column. |
| - | */ |
| - | if (b != YY_CURRENT_BUFFER){ |
| - | b->yy_bs_lineno = 1; |
| - | b->yy_bs_column = 0; |
| - | } |
| - | |
| - | b->yy_is_interactive = 0; |
| - | |
| - | errno = oerrno; |
| - | } |
| - | |
| - | /** Discard all buffered characters. On the next scan, YY_INPUT will be called. |
| - | * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. |
| - | * |
| - | */ |
| - | void zconf_flush_buffer (YY_BUFFER_STATE b ) |
| - | { |
| - | if ( ! b ) |
| - | return; |
| - | |
| - | b->yy_n_chars = 0; |
| - | |
| - | /* We always need two end-of-buffer characters. The first causes |
| - | * a transition to the end-of-buffer state. The second causes |
| - | * a jam in that state. |
| - | */ |
| - | b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; |
| - | b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; |
| - | |
| - | b->yy_buf_pos = &b->yy_ch_buf[0]; |
| - | |
| - | b->yy_at_bol = 1; |
| - | b->yy_buffer_status = YY_BUFFER_NEW; |
| - | |
| - | if ( b == YY_CURRENT_BUFFER ) |
| - | zconf_load_buffer_state( ); |
| - | } |
| - | |
| - | /** Pushes the new state onto the stack. The new state becomes |
| - | * the current state. This function will allocate the stack |
| - | * if necessary. |
| - | * @param new_buffer The new state. |
| - | * |
| - | */ |
| - | void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer ) |
| - | { |
| - | if (new_buffer == NULL) |
| - | return; |
| - | |
| - | zconfensure_buffer_stack(); |
| - | |
| - | /* This block is copied from zconf_switch_to_buffer. */ |
| - | if ( YY_CURRENT_BUFFER ) |
| - | { |
| - | /* Flush out information for old buffer. */ |
| - | *(yy_c_buf_p) = (yy_hold_char); |
| - | YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); |
| - | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
| - | } |
| - | |
| - | /* Only push if top exists. Otherwise, replace top. */ |
| - | if (YY_CURRENT_BUFFER) |
| - | (yy_buffer_stack_top)++; |
| - | YY_CURRENT_BUFFER_LVALUE = new_buffer; |
| - | |
| - | /* copied from zconf_switch_to_buffer. */ |
| - | zconf_load_buffer_state( ); |
| - | (yy_did_buffer_switch_on_eof) = 1; |
| - | } |
| - | |
| - | /** Removes and deletes the top of the stack, if present. |
| - | * The next element becomes the new top. |
| - | * |
| - | */ |
| - | void zconfpop_buffer_state (void) |
| - | { |
| - | if (!YY_CURRENT_BUFFER) |
| - | return; |
| - | |
| - | zconf_delete_buffer(YY_CURRENT_BUFFER ); |
| - | YY_CURRENT_BUFFER_LVALUE = NULL; |
| - | if ((yy_buffer_stack_top) > 0) |
| - | --(yy_buffer_stack_top); |
| - | |
| - | if (YY_CURRENT_BUFFER) { |
| - | zconf_load_buffer_state( ); |
| - | (yy_did_buffer_switch_on_eof) = 1; |
| - | } |
| - | } |
| - | |
| - | /* Allocates the stack if it does not exist. |
| - | * Guarantees space for at least one push. |
| - | */ |
| - | static void zconfensure_buffer_stack (void) |
| - | { |
| - | int num_to_alloc; |
| - | |
| - | if (!(yy_buffer_stack)) { |
| - | |
| - | /* First allocation is just for 2 elements, since we don't know if this |
| - | * scanner will even need a stack. We use 2 instead of 1 to avoid an |
| - | * immediate realloc on the next call. |
| - | */ |
| - | num_to_alloc = 1; |
| - | (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc |
| - | (num_to_alloc * sizeof(struct yy_buffer_state*) |
| - | ); |
| - | |
| - | memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); |
| - | |
| - | (yy_buffer_stack_max) = num_to_alloc; |
| - | (yy_buffer_stack_top) = 0; |
| - | return; |
| - | } |
| - | |
| - | if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ |
| - | |
| - | /* Increase the buffer to prepare for a possible push. */ |
| - | int grow_size = 8 /* arbitrary grow size */; |
| - | |
| - | num_to_alloc = (yy_buffer_stack_max) + grow_size; |
| - | (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc |
| - | ((yy_buffer_stack), |
| - | num_to_alloc * sizeof(struct yy_buffer_state*) |
| - | ); |
| - | |
| - | /* zero only the new slots.*/ |
| - | memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); |
| - | (yy_buffer_stack_max) = num_to_alloc; |
| - | } |
| - | } |
| - | |
| - | /** Setup the input buffer state to scan directly from a user-specified character buffer. |
| - | * @param base the character buffer |
| - | * @param size the size in bytes of the character buffer |
| - | * |
| - | * @return the newly allocated buffer state object. |
| - | */ |
| - | YY_BUFFER_STATE zconf_scan_buffer (char * base, yy_size_t size ) |
| - | { |
| - | YY_BUFFER_STATE b; |
| - | |
| - | if ( size < 2 || |
| - | base[size-2] != YY_END_OF_BUFFER_CHAR || |
| - | base[size-1] != YY_END_OF_BUFFER_CHAR ) |
| - | /* They forgot to leave room for the EOB's. */ |
| - | return 0; |
| - | |
| - | b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state ) ); |
| - | if ( ! b ) |
| - | YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" ); |
| - | |
| - | b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ |
| - | b->yy_buf_pos = b->yy_ch_buf = base; |
| - | b->yy_is_our_buffer = 0; |
| - | b->yy_input_file = 0; |
| - | b->yy_n_chars = b->yy_buf_size; |
| - | b->yy_is_interactive = 0; |
| - | b->yy_at_bol = 1; |
| - | b->yy_fill_buffer = 0; |
| - | b->yy_buffer_status = YY_BUFFER_NEW; |
| - | |
| - | zconf_switch_to_buffer(b ); |
| - | |
| - | return b; |
| - | } |
| - | |
| - | /** Setup the input buffer state to scan a string. The next call to zconflex() will |
| - | * scan from a @e copy of @a str. |
| - | * @param str a NUL-terminated string to scan |
| - | * |
| - | * @return the newly allocated buffer state object. |
| - | * @note If you want to scan bytes that may contain NUL values, then use |
| - | * zconf_scan_bytes() instead. |
| - | */ |
| - | YY_BUFFER_STATE zconf_scan_string (yyconst char * str ) |
| - | { |
| - | |
| - | return zconf_scan_bytes(str,strlen(str) ); |
| - | } |
| - | |
| - | /** Setup the input buffer state to scan the given bytes. The next call to zconflex() will |
| - | * scan from a @e copy of @a bytes. |
| - | * @param bytes the byte buffer to scan |
| - | * @param len the number of bytes in the buffer pointed to by @a bytes. |
| - | * |
| - | * @return the newly allocated buffer state object. |
| - | */ |
| - | YY_BUFFER_STATE zconf_scan_bytes (yyconst char * bytes, int len ) |
| - | { |
| - | YY_BUFFER_STATE b; |
| - | char *buf; |
| - | yy_size_t n; |
| - | int i; |
| - | |
| - | /* Get memory for full buffer, including space for trailing EOB's. */ |
| - | n = len + 2; |
| - | buf = (char *) zconfalloc(n ); |
| - | if ( ! buf ) |
| - | YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" ); |
| - | |
| - | for ( i = 0; i < len; ++i ) |
| - | buf[i] = bytes[i]; |
| - | |
| - | buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; |
| - | |
| - | b = zconf_scan_buffer(buf,n ); |
| - | if ( ! b ) |
| - | YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" ); |
| - | |
| - | /* It's okay to grow etc. this buffer, and we should throw it |
| - | * away when we're done. |
| - | */ |
| - | b->yy_is_our_buffer = 1; |
| - | |
| - | return b; |
| - | } |
| - | |
| - | #ifndef YY_EXIT_FAILURE |
| - | #define YY_EXIT_FAILURE 2 |
| - | #endif |
| - | |
| - | static void yy_fatal_error (yyconst char* msg ) |
| - | { |
| - | (void) fprintf( stderr, "%s\n", msg ); |
| - | exit( YY_EXIT_FAILURE ); |
| - | } |
| - | |
| - | /* Redefine yyless() so it works in section 3 code. */ |
| - | |
| - | #undef yyless |
| - | #define yyless(n) \ |
| - | do \ |
| - | { \ |
| - | /* Undo effects of setting up zconftext. */ \ |
| - | int yyless_macro_arg = (n); \ |
| - | YY_LESS_LINENO(yyless_macro_arg);\ |
| - | zconftext[zconfleng] = (yy_hold_char); \ |
| - | (yy_c_buf_p) = zconftext + yyless_macro_arg; \ |
| - | (yy_hold_char) = *(yy_c_buf_p); \ |
| - | *(yy_c_buf_p) = '\0'; \ |
| - | zconfleng = yyless_macro_arg; \ |
| - | } \ |
| - | while ( 0 ) |
| - | |
| - | /* Accessor methods (get/set functions) to struct members. */ |
| - | |
| - | /** Get the current line number. |
| - | * |
| - | */ |
| - | int zconfget_lineno (void) |
| - | { |
| - | |
| - | return zconflineno; |
| - | } |
| - | |
| - | /** Get the input stream. |
| - | * |
| - | */ |
| - | FILE *zconfget_in (void) |
| - | { |
| - | return zconfin; |
| - | } |
| - | |
| - | /** Get the output stream. |
| - | * |
| - | */ |
| - | FILE *zconfget_out (void) |
| - | { |
| - | return zconfout; |
| - | } |
| - | |
| - | /** Get the length of the current token. |
| - | * |
| - | */ |
| - | int zconfget_leng (void) |
| - | { |
| - | return zconfleng; |
| - | } |
| - | |
| - | /** Get the current token. |
| - | * |
| - | */ |
| - | |
| - | char *zconfget_text (void) |
| - | { |
| - | return zconftext; |
| - | } |
| - | |
| - | /** Set the current line number. |
| - | * @param line_number |
| - | * |
| - | */ |
| - | void zconfset_lineno (int line_number ) |
| - | { |
| - | |
| - | zconflineno = line_number; |
| - | } |
| - | |
| - | /** Set the input stream. This does not discard the current |
| - | * input buffer. |
| - | * @param in_str A readable stream. |
| - | * |
| - | * @see zconf_switch_to_buffer |
| - | */ |
| - | void zconfset_in (FILE * in_str ) |
| - | { |
| - | zconfin = in_str ; |
| - | } |
| - | |
| - | void zconfset_out (FILE * out_str ) |
| - | { |
| - | zconfout = out_str ; |
| - | } |
| - | |
| - | int zconfget_debug (void) |
| - | { |
| - | return zconf_flex_debug; |
| - | } |
| - | |
| - | void zconfset_debug (int bdebug ) |
| - | { |
| - | zconf_flex_debug = bdebug ; |
| - | } |
| - | |
| - | /* zconflex_destroy is for both reentrant and non-reentrant scanners. */ |
| - | int zconflex_destroy (void) |
| - | { |
| - | |
| - | /* Pop the buffer stack, destroying each element. */ |
| - | while(YY_CURRENT_BUFFER){ |
| - | zconf_delete_buffer(YY_CURRENT_BUFFER ); |
| - | YY_CURRENT_BUFFER_LVALUE = NULL; |
| - | zconfpop_buffer_state(); |
| - | } |
| - | |
| - | /* Destroy the stack itself. */ |
| - | zconffree((yy_buffer_stack) ); |
| - | (yy_buffer_stack) = NULL; |
| - | |
| - | return 0; |
| - | } |
| - | |
| - | /* |
| - | * Internal utility routines. |
| - | */ |
| - | |
| - | #ifndef yytext_ptr |
| - | static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) |
| - | { |
| - | register int i; |
| - | for ( i = 0; i < n; ++i ) |
| - | s1[i] = s2[i]; |
| - | } |
| - | #endif |
| - | |
| - | #ifdef YY_NEED_STRLEN |
| - | static int yy_flex_strlen (yyconst char * s ) |
| - | { |
| - | register int n; |
| - | for ( n = 0; s[n]; ++n ) |
| - | ; |
| - | |
| - | return n; |
| - | } |
| - | #endif |
| - | |
| - | void *zconfalloc (yy_size_t size ) |
| - | { |
| - | return (void *) malloc( size ); |
| - | } |
| - | |
| - | void *zconfrealloc (void * ptr, yy_size_t size ) |
| - | { |
| - | /* The cast to (char *) in the following accommodates both |
| - | * implementations that use char* generic pointers, and those |
| - | * that use void* generic pointers. It works with the latter |
| - | * because both ANSI C and C++ allow castless assignment from |
| - | * any pointer type to void*, and deal with argument conversions |
| - | * as though doing an assignment. |
| - | */ |
| - | return (void *) realloc( (char *) ptr, size ); |
| - | } |
| - | |
| - | void zconffree (void * ptr ) |
| - | { |
| - | free( (char *) ptr ); /* see zconfrealloc() for (char *) cast */ |
| - | } |
| - | |
| - | #define YYTABLES_NAME "yytables" |
| - | |
| - | #undef YY_NEW_FILE |
| - | #undef YY_FLUSH_BUFFER |
| - | #undef yy_set_bol |
| - | #undef yy_new_buffer |
| - | #undef yy_set_interactive |
| - | #undef yytext_ptr |
| - | #undef YY_DO_BEFORE_ACTION |
| - | |
| - | #ifdef YY_DECL_IS_OURS |
| - | #undef YY_DECL_IS_OURS |
| - | #undef YY_DECL |
| - | #endif |
| - | |
| - | void zconf_starthelp(void) |
| - | { |
| - | new_string(); |
| - | last_ts = first_ts = 0; |
| - | BEGIN(HELP); |
| - | } |
| - | |
| - | static void zconf_endhelp(void) |
| - | { |
| - | zconflval.string = text; |
| - | BEGIN(INITIAL); |
| - | } |
| - | |
| - | /* |
| - | * Try to open specified file with following names: |
| - | * ./name |
| - | * $(srctree)/name |
| - | * The latter is used when srctree is separate from objtree |
| - | * when compiling the kernel. |
| - | * Return NULL if file is not found. |
| - | */ |
| - | FILE *zconf_fopen(const char *name) |
| - | { |
| - | char *env, fullname[PATH_MAX+1]; |
| - | FILE *f; |
| - | |
| - | f = fopen(name, "r"); |
| - | if (!f && name[0] != '/') { |
| - | env = getenv(SRCTREE); |
| - | if (env) { |
| - | sprintf(fullname, "%s/%s", env, name); |
| - | f = fopen(fullname, "r"); |
| - | } |
| - | } |
| - | return f; |
| - | } |
| - | |
| - | void zconf_initscan(const char *name) |
| - | { |
| - | zconfin = zconf_fopen(name); |
| - | if (!zconfin) { |
| - | printf("can't find file %s\n", name); |
| - | exit(1); |
| - | } |
| - | |
| - | current_buf = malloc(sizeof(*current_buf)); |
| - | memset(current_buf, 0, sizeof(*current_buf)); |
| - | |
| - | current_file = file_lookup(name); |
| - | current_file->lineno = 1; |
| - | current_file->flags = FILE_BUSY; |
| - | } |
| - | |
| - | void zconf_nextfile(const char *name) |
| - | { |
| - | struct file *file = file_lookup(name); |
| - | struct buffer *buf = malloc(sizeof(*buf)); |
| - | memset(buf, 0, sizeof(*buf)); |
| - | |
| - | current_buf->state = YY_CURRENT_BUFFER; |
| - | zconfin = zconf_fopen(name); |
| - | if (!zconfin) { |
| - | printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name); |
| - | exit(1); |
| - | } |
| - | zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE)); |
| - | buf->parent = current_buf; |
| - | current_buf = buf; |
| - | |
| - | if (file->flags & FILE_BUSY) { |
| - | printf("recursive scan (%s)?\n", name); |
| - | exit(1); |
| - | } |
| - | if (file->flags & FILE_SCANNED) { |
| - | printf("file %s already scanned?\n", name); |
| - | exit(1); |
| - | } |
| - | file->flags |= FILE_BUSY; |
| - | file->lineno = 1; |
| - | file->parent = current_file; |
| - | current_file = file; |
| - | } |
| - | |
| - | static struct buffer *zconf_endfile(void) |
| - | { |
| - | struct buffer *parent; |
| - | |
| - | current_file->flags |= FILE_SCANNED; |
| - | current_file->flags &= ~FILE_BUSY; |
| - | current_file = current_file->parent; |
| - | |
| - | parent = current_buf->parent; |
| - | if (parent) { |
| - | fclose(zconfin); |
| - | zconf_delete_buffer(YY_CURRENT_BUFFER); |
| - | zconf_switch_to_buffer(parent->state); |
| - | } |
| - | free(current_buf); |
| - | current_buf = parent; |
| - | |
| - | return parent; |
| - | } |
| - | |
| - | int zconf_lineno(void) |
| - | { |
| - | if (current_buf) |
| - | return current_file->lineno - 1; |
| - | else |
| - | return 0; |
| - | } |
| - | |
| - | char *zconf_curname(void) |
| - | { |
| - | if (current_buf) |
| - | return current_file->name; |
| - | else |
| - | return "<none>"; |
| - | } |
| - | |
| @@ -1,124 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #ifndef LKC_H |
| - | #define LKC_H |
| - | |
| - | #include "expr.h" |
| - | |
| - | #ifdef __cplusplus |
| - | extern "C" { |
| - | #endif |
| - | |
| - | #ifdef LKC_DIRECT_LINK |
| - | #define P(name,type,arg) extern type name arg |
| - | #else |
| - | #include "lkc_defs.h" |
| - | #define P(name,type,arg) extern type (*name ## _p) arg |
| - | #endif |
| - | #include "lkc_proto.h" |
| - | #undef P |
| - | |
| - | #define SRCTREE "srctree" |
| - | |
| - | int zconfparse(void); |
| - | void zconfdump(FILE *out); |
| - | |
| - | extern int zconfdebug; |
| - | void zconf_starthelp(void); |
| - | FILE *zconf_fopen(const char *name); |
| - | void zconf_initscan(const char *name); |
| - | void zconf_nextfile(const char *name); |
| - | int zconf_lineno(void); |
| - | char *zconf_curname(void); |
| - | |
| - | /* confdata.c */ |
| - | extern const char conf_def_filename[]; |
| - | extern char conf_filename[]; |
| - | |
| - | char *conf_get_default_confname(void); |
| - | |
| - | /* kconfig_load.c */ |
| - | void kconfig_load(void); |
| - | |
| - | /* menu.c */ |
| - | void menu_init(void); |
| - | void menu_add_menu(void); |
| - | void menu_end_menu(void); |
| - | void menu_add_entry(struct symbol *sym); |
| - | void menu_end_entry(void); |
| - | void menu_add_dep(struct expr *dep); |
| - | struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep); |
| - | void menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep); |
| - | void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep); |
| - | void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep); |
| - | void menu_finalize(struct menu *parent); |
| - | void menu_set_type(int type); |
| - | |
| - | /* util.c */ |
| - | struct file *file_lookup(const char *name); |
| - | int file_write_dep(const char *name); |
| - | |
| - | struct gstr { |
| - | size_t len; |
| - | char *s; |
| - | }; |
| - | struct gstr str_new(void); |
| - | struct gstr str_assign(const char *s); |
| - | void str_free(struct gstr *gs); |
| - | void str_append(struct gstr *gs, const char *s); |
| - | void str_printf(struct gstr *gs, const char *fmt, ...); |
| - | const char *str_get(struct gstr *gs); |
| - | |
| - | /* symbol.c */ |
| - | void sym_init(void); |
| - | void sym_clear_all_valid(void); |
| - | void sym_set_changed(struct symbol *sym); |
| - | struct symbol *sym_check_deps(struct symbol *sym); |
| - | struct property *prop_alloc(enum prop_type type, struct symbol *sym); |
| - | struct symbol *prop_get_symbol(struct property *prop); |
| - | |
| - | static inline tristate sym_get_tristate_value(struct symbol *sym) |
| - | { |
| - | return sym->curr.tri; |
| - | } |
| - | |
| - | |
| - | static inline struct symbol *sym_get_choice_value(struct symbol *sym) |
| - | { |
| - | return (struct symbol *)sym->curr.val; |
| - | } |
| - | |
| - | static inline bool sym_set_choice_value(struct symbol *ch, struct symbol *chval) |
| - | { |
| - | return sym_set_tristate_value(chval, yes); |
| - | } |
| - | |
| - | static inline bool sym_is_choice(struct symbol *sym) |
| - | { |
| - | return sym->flags & SYMBOL_CHOICE ? true : false; |
| - | } |
| - | |
| - | static inline bool sym_is_choice_value(struct symbol *sym) |
| - | { |
| - | return sym->flags & SYMBOL_CHOICEVAL ? true : false; |
| - | } |
| - | |
| - | static inline bool sym_is_optional(struct symbol *sym) |
| - | { |
| - | return sym->flags & SYMBOL_OPTIONAL ? true : false; |
| - | } |
| - | |
| - | static inline bool sym_has_value(struct symbol *sym) |
| - | { |
| - | return sym->flags & SYMBOL_NEW ? false : true; |
| - | } |
| - | |
| - | #ifdef __cplusplus |
| - | } |
| - | #endif |
| - | |
| - | #endif /* LKC_H */ |
| @@ -1,41 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | |
| - | /* confdata.c */ |
| - | P(conf_parse,void,(const char *name)); |
| - | P(conf_read,int,(const char *name)); |
| - | P(conf_write,int,(const char *name)); |
| - | |
| - | /* menu.c */ |
| - | P(rootmenu,struct menu,); |
| - | |
| - | P(menu_is_visible,bool,(struct menu *menu)); |
| - | P(menu_get_prompt,const char *,(struct menu *menu)); |
| - | P(menu_get_root_menu,struct menu *,(struct menu *menu)); |
| - | P(menu_get_parent_menu,struct menu *,(struct menu *menu)); |
| - | |
| - | /* symbol.c */ |
| - | P(symbol_hash,struct symbol *,[SYMBOL_HASHSIZE]); |
| - | P(sym_change_count,int,); |
| - | |
| - | P(sym_lookup,struct symbol *,(const char *name, int isconst)); |
| - | P(sym_find,struct symbol *,(const char *name)); |
| - | P(sym_re_search,struct symbol **,(const char *pattern)); |
| - | P(sym_type_name,const char *,(enum symbol_type type)); |
| - | P(sym_calc_value,void,(struct symbol *sym)); |
| - | P(sym_get_type,enum symbol_type,(struct symbol *sym)); |
| - | P(sym_tristate_within_range,bool,(struct symbol *sym,tristate tri)); |
| - | P(sym_set_tristate_value,bool,(struct symbol *sym,tristate tri)); |
| - | P(sym_toggle_tristate_value,tristate,(struct symbol *sym)); |
| - | P(sym_string_valid,bool,(struct symbol *sym, const char *newval)); |
| - | P(sym_string_within_range,bool,(struct symbol *sym, const char *str)); |
| - | P(sym_set_string_value,bool,(struct symbol *sym, const char *newval)); |
| - | P(sym_is_changable,bool,(struct symbol *sym)); |
| - | P(sym_get_choice_prop,struct property *,(struct symbol *sym)); |
| - | P(sym_get_default_prop,struct property *,(struct symbol *sym)); |
| - | P(sym_get_string_value,const char *,(struct symbol *sym)); |
| - | |
| - | P(prop_get_type_name,const char *,(enum prop_type type)); |
| - | |
| - | /* expr.c */ |
| - | P(expr_compare_type,int,(enum expr_type t1, enum expr_type t2)); |
| - | P(expr_print,void,(struct expr *e, void (*fn)(void *, const char *), void *data, int prevtoken)); |
| @@ -1,4 +0,0 @@ | |
| - | This is NOT the official version of dialog. This version has been |
| - | significantly modified from the original. It is for use by the Linux |
| - | kernel configuration script. Please do not bother Savio Lam with |
| - | questions about this program. |
| @@ -1,373 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * checklist.c -- implements the checklist box |
| - | * |
| - | * ORIGINAL AUTHOR: Savio Lam ([email protected]) |
| - | * Stuart Herbert - [email protected]: radiolist extension |
| - | * Alessandro Rubini - [email protected]: merged the two |
| - | * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | #include "dialog.h" |
| - | |
| - | static int list_width, check_x, item_x, checkflag; |
| - | |
| - | /* |
| - | * Print list item |
| - | */ |
| - | static void |
| - | print_item (WINDOW * win, const char *item, int status, |
| - | int choice, int selected) |
| - | { |
| - | int i; |
| - | |
| - | /* Clear 'residue' of last item */ |
| - | wattrset (win, menubox_attr); |
| - | wmove (win, choice, 0); |
| - | for (i = 0; i < list_width; i++) |
| - | waddch (win, ' '); |
| - | |
| - | wmove (win, choice, check_x); |
| - | wattrset (win, selected ? check_selected_attr : check_attr); |
| - | if (checkflag == FLAG_CHECK) |
| - | wprintw (win, "[%c]", status ? 'X' : ' '); |
| - | else |
| - | wprintw (win, "(%c)", status ? 'X' : ' '); |
| - | |
| - | wattrset (win, selected ? tag_selected_attr : tag_attr); |
| - | mvwaddch(win, choice, item_x, item[0]); |
| - | wattrset (win, selected ? item_selected_attr : item_attr); |
| - | waddstr (win, (char *)item+1); |
| - | if (selected) { |
| - | wmove (win, choice, check_x+1); |
| - | wrefresh (win); |
| - | } |
| - | } |
| - | |
| - | /* |
| - | * Print the scroll indicators. |
| - | */ |
| - | static void |
| - | print_arrows (WINDOW * win, int choice, int item_no, int scroll, |
| - | int y, int x, int height) |
| - | { |
| - | wmove(win, y, x); |
| - | |
| - | if (scroll > 0) { |
| - | wattrset (win, uarrow_attr); |
| - | waddch (win, ACS_UARROW); |
| - | waddstr (win, "(-)"); |
| - | } |
| - | else { |
| - | wattrset (win, menubox_attr); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | } |
| - | |
| - | y = y + height + 1; |
| - | wmove(win, y, x); |
| - | |
| - | if ((height < item_no) && (scroll + choice < item_no - 1)) { |
| - | wattrset (win, darrow_attr); |
| - | waddch (win, ACS_DARROW); |
| - | waddstr (win, "(+)"); |
| - | } |
| - | else { |
| - | wattrset (win, menubox_border_attr); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | } |
| - | } |
| - | |
| - | /* |
| - | * Display the termination buttons |
| - | */ |
| - | static void |
| - | print_buttons( WINDOW *dialog, int height, int width, int selected) |
| - | { |
| - | int x = width / 2 - 11; |
| - | int y = height - 2; |
| - | |
| - | print_button (dialog, "Select", y, x, selected == 0); |
| - | print_button (dialog, " Help ", y, x + 14, selected == 1); |
| - | |
| - | wmove(dialog, y, x+1 + 14*selected); |
| - | wrefresh (dialog); |
| - | } |
| - | |
| - | /* |
| - | * Display a dialog box with a list of options that can be turned on or off |
| - | * The `flag' parameter is used to select between radiolist and checklist. |
| - | */ |
| - | int |
| - | dialog_checklist (const char *title, const char *prompt, int height, int width, |
| - | int list_height, int item_no, struct dialog_list_item ** items, |
| - | int flag) |
| - | |
| - | { |
| - | int i, x, y, box_x, box_y; |
| - | int key = 0, button = 0, choice = 0, scroll = 0, max_choice, *status; |
| - | WINDOW *dialog, *list; |
| - | |
| - | checkflag = flag; |
| - | |
| - | /* Allocate space for storing item on/off status */ |
| - | if ((status = malloc (sizeof (int) * item_no)) == NULL) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nCan't allocate memory in dialog_checklist().\n"); |
| - | exit (-1); |
| - | } |
| - | |
| - | /* Initializes status */ |
| - | for (i = 0; i < item_no; i++) { |
| - | status[i] = (items[i]->selected == 1); /* ON */ |
| - | if ((!choice && status[i]) || items[i]->selected == 2) /* SELECTED */ |
| - | choice = i + 1; |
| - | } |
| - | if (choice) |
| - | choice--; |
| - | |
| - | max_choice = MIN (list_height, item_no); |
| - | |
| - | /* center dialog box on screen */ |
| - | x = (COLS - width) / 2; |
| - | y = (LINES - height) / 2; |
| - | |
| - | draw_shadow (stdscr, y, x, height, width); |
| - | |
| - | dialog = newwin (height, width, y, x); |
| - | keypad (dialog, TRUE); |
| - | |
| - | draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); |
| - | wattrset (dialog, border_attr); |
| - | mvwaddch (dialog, height-3, 0, ACS_LTEE); |
| - | for (i = 0; i < width - 2; i++) |
| - | waddch (dialog, ACS_HLINE); |
| - | wattrset (dialog, dialog_attr); |
| - | waddch (dialog, ACS_RTEE); |
| - | |
| - | if (title != NULL && strlen(title) >= width-2 ) { |
| - | /* truncate long title -- mec */ |
| - | char * title2 = malloc(width-2+1); |
| - | memcpy( title2, title, width-2 ); |
| - | title2[width-2] = '\0'; |
| - | title = title2; |
| - | } |
| - | |
| - | if (title != NULL) { |
| - | wattrset (dialog, title_attr); |
| - | mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); |
| - | waddstr (dialog, (char *)title); |
| - | waddch (dialog, ' '); |
| - | } |
| - | |
| - | wattrset (dialog, dialog_attr); |
| - | print_autowrap (dialog, prompt, width - 2, 1, 3); |
| - | |
| - | list_width = width - 6; |
| - | box_y = height - list_height - 5; |
| - | box_x = (width - list_width) / 2 - 1; |
| - | |
| - | /* create new window for the list */ |
| - | list = subwin (dialog, list_height, list_width, y+box_y+1, x+box_x+1); |
| - | |
| - | keypad (list, TRUE); |
| - | |
| - | /* draw a box around the list items */ |
| - | draw_box (dialog, box_y, box_x, list_height + 2, list_width + 2, |
| - | menubox_border_attr, menubox_attr); |
| - | |
| - | /* Find length of longest item in order to center checklist */ |
| - | check_x = 0; |
| - | for (i = 0; i < item_no; i++) |
| - | check_x = MAX (check_x, + strlen (items[i]->name) + 4); |
| - | |
| - | check_x = (list_width - check_x) / 2; |
| - | item_x = check_x + 4; |
| - | |
| - | if (choice >= list_height) { |
| - | scroll = choice - list_height + 1; |
| - | choice -= scroll; |
| - | } |
| - | |
| - | /* Print the list */ |
| - | for (i = 0; i < max_choice; i++) { |
| - | print_item (list, items[scroll + i]->name, |
| - | status[i+scroll], i, i == choice); |
| - | } |
| - | |
| - | print_arrows(dialog, choice, item_no, scroll, |
| - | box_y, box_x + check_x + 5, list_height); |
| - | |
| - | print_buttons(dialog, height, width, 0); |
| - | |
| - | wnoutrefresh (list); |
| - | wnoutrefresh (dialog); |
| - | doupdate (); |
| - | |
| - | while (key != ESC) { |
| - | key = wgetch (dialog); |
| - | |
| - | for (i = 0; i < max_choice; i++) |
| - | if (toupper(key) == toupper(items[scroll + i]->name[0])) |
| - | break; |
| - | |
| - | |
| - | if ( i < max_choice || key == KEY_UP || key == KEY_DOWN || |
| - | key == '+' || key == '-' ) { |
| - | if (key == KEY_UP || key == '-') { |
| - | if (!choice) { |
| - | if (!scroll) |
| - | continue; |
| - | /* Scroll list down */ |
| - | if (list_height > 1) { |
| - | /* De-highlight current first item */ |
| - | print_item (list, items[scroll]->name, |
| - | status[scroll], 0, FALSE); |
| - | scrollok (list, TRUE); |
| - | wscrl (list, -1); |
| - | scrollok (list, FALSE); |
| - | } |
| - | scroll--; |
| - | print_item (list, items[scroll]->name, |
| - | status[scroll], 0, TRUE); |
| - | wnoutrefresh (list); |
| - | |
| - | print_arrows(dialog, choice, item_no, scroll, |
| - | box_y, box_x + check_x + 5, list_height); |
| - | |
| - | wrefresh (dialog); |
| - | |
| - | continue; /* wait for another key press */ |
| - | } else |
| - | i = choice - 1; |
| - | } else if (key == KEY_DOWN || key == '+') { |
| - | if (choice == max_choice - 1) { |
| - | if (scroll + choice >= item_no - 1) |
| - | continue; |
| - | /* Scroll list up */ |
| - | if (list_height > 1) { |
| - | /* De-highlight current last item before scrolling up */ |
| - | print_item (list, items[scroll + max_choice - 1]->name, |
| - | status[scroll + max_choice - 1], |
| - | max_choice - 1, FALSE); |
| - | scrollok (list, TRUE); |
| - | scroll (list); |
| - | scrollok (list, FALSE); |
| - | } |
| - | scroll++; |
| - | print_item (list, items[scroll + max_choice - 1]->name, |
| - | status[scroll + max_choice - 1], |
| - | max_choice - 1, TRUE); |
| - | wnoutrefresh (list); |
| - | |
| - | print_arrows(dialog, choice, item_no, scroll, |
| - | box_y, box_x + check_x + 5, list_height); |
| - | |
| - | wrefresh (dialog); |
| - | |
| - | continue; /* wait for another key press */ |
| - | } else |
| - | i = choice + 1; |
| - | } |
| - | if (i != choice) { |
| - | /* De-highlight current item */ |
| - | print_item (list, items[scroll + choice]->name, |
| - | status[scroll + choice], choice, FALSE); |
| - | /* Highlight new item */ |
| - | choice = i; |
| - | print_item (list, items[scroll + choice]->name, |
| - | status[scroll + choice], choice, TRUE); |
| - | wnoutrefresh (list); |
| - | wrefresh (dialog); |
| - | } |
| - | continue; /* wait for another key press */ |
| - | } |
| - | switch (key) { |
| - | case 'H': |
| - | case 'h': |
| - | case '?': |
| - | for (i = 0; i < item_no; i++) |
| - | items[i]->selected = 0; |
| - | items[scroll + choice]->selected = 1; |
| - | delwin (dialog); |
| - | free (status); |
| - | return 1; |
| - | case TAB: |
| - | case KEY_LEFT: |
| - | case KEY_RIGHT: |
| - | button = ((key == KEY_LEFT ? --button : ++button) < 0) |
| - | ? 1 : (button > 1 ? 0 : button); |
| - | |
| - | print_buttons(dialog, height, width, button); |
| - | wrefresh (dialog); |
| - | break; |
| - | case 'S': |
| - | case 's': |
| - | case ' ': |
| - | case '\n': |
| - | if (!button) { |
| - | if (flag == FLAG_CHECK) { |
| - | status[scroll + choice] = !status[scroll + choice]; |
| - | wmove (list, choice, check_x); |
| - | wattrset (list, check_selected_attr); |
| - | wprintw (list, "[%c]", status[scroll + choice] ? 'X' : ' '); |
| - | } else { |
| - | if (!status[scroll + choice]) { |
| - | for (i = 0; i < item_no; i++) |
| - | status[i] = 0; |
| - | status[scroll + choice] = 1; |
| - | for (i = 0; i < max_choice; i++) |
| - | print_item (list, items[scroll + i]->name, |
| - | status[scroll + i], i, i == choice); |
| - | } |
| - | } |
| - | wnoutrefresh (list); |
| - | wrefresh (dialog); |
| - | |
| - | for (i = 0; i < item_no; i++) { |
| - | items[i]->selected = status[i]; |
| - | } |
| - | } else { |
| - | for (i = 0; i < item_no; i++) |
| - | items[i]->selected = 0; |
| - | items[scroll + choice]->selected = 1; |
| - | } |
| - | delwin (dialog); |
| - | free (status); |
| - | return button; |
| - | case 'X': |
| - | case 'x': |
| - | key = ESC; |
| - | case ESC: |
| - | break; |
| - | } |
| - | |
| - | /* Now, update everything... */ |
| - | doupdate (); |
| - | } |
| - | |
| - | |
| - | delwin (dialog); |
| - | free (status); |
| - | return -1; /* ESC pressed */ |
| - | } |
| @@ -1,162 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * colors.h -- color attribute definitions |
| - | * |
| - | * AUTHOR: Savio Lam ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | |
| - | /* |
| - | * Default color definitions |
| - | * |
| - | * *_FG = foreground |
| - | * *_BG = background |
| - | * *_HL = highlight? |
| - | */ |
| - | #define SCREEN_FG COLOR_CYAN |
| - | #define SCREEN_BG COLOR_BLUE |
| - | #define SCREEN_HL TRUE |
| - | |
| - | #define SHADOW_FG COLOR_BLACK |
| - | #define SHADOW_BG COLOR_BLACK |
| - | #define SHADOW_HL TRUE |
| - | |
| - | #define DIALOG_FG COLOR_BLACK |
| - | #define DIALOG_BG COLOR_WHITE |
| - | #define DIALOG_HL FALSE |
| - | |
| - | #define TITLE_FG COLOR_YELLOW |
| - | #define TITLE_BG COLOR_WHITE |
| - | #define TITLE_HL TRUE |
| - | |
| - | #define BORDER_FG COLOR_WHITE |
| - | #define BORDER_BG COLOR_WHITE |
| - | #define BORDER_HL TRUE |
| - | |
| - | #define BUTTON_ACTIVE_FG COLOR_WHITE |
| - | #define BUTTON_ACTIVE_BG COLOR_BLUE |
| - | #define BUTTON_ACTIVE_HL TRUE |
| - | |
| - | #define BUTTON_INACTIVE_FG COLOR_BLACK |
| - | #define BUTTON_INACTIVE_BG COLOR_WHITE |
| - | #define BUTTON_INACTIVE_HL FALSE |
| - | |
| - | #define BUTTON_KEY_ACTIVE_FG COLOR_WHITE |
| - | #define BUTTON_KEY_ACTIVE_BG COLOR_BLUE |
| - | #define BUTTON_KEY_ACTIVE_HL TRUE |
| - | |
| - | #define BUTTON_KEY_INACTIVE_FG COLOR_RED |
| - | #define BUTTON_KEY_INACTIVE_BG COLOR_WHITE |
| - | #define BUTTON_KEY_INACTIVE_HL FALSE |
| - | |
| - | #define BUTTON_LABEL_ACTIVE_FG COLOR_YELLOW |
| - | #define BUTTON_LABEL_ACTIVE_BG COLOR_BLUE |
| - | #define BUTTON_LABEL_ACTIVE_HL TRUE |
| - | |
| - | #define BUTTON_LABEL_INACTIVE_FG COLOR_BLACK |
| - | #define BUTTON_LABEL_INACTIVE_BG COLOR_WHITE |
| - | #define BUTTON_LABEL_INACTIVE_HL TRUE |
| - | |
| - | #define INPUTBOX_FG COLOR_BLACK |
| - | #define INPUTBOX_BG COLOR_WHITE |
| - | #define INPUTBOX_HL FALSE |
| - | |
| - | #define INPUTBOX_BORDER_FG COLOR_BLACK |
| - | #define INPUTBOX_BORDER_BG COLOR_WHITE |
| - | #define INPUTBOX_BORDER_HL FALSE |
| - | |
| - | #define SEARCHBOX_FG COLOR_BLACK |
| - | #define SEARCHBOX_BG COLOR_WHITE |
| - | #define SEARCHBOX_HL FALSE |
| - | |
| - | #define SEARCHBOX_TITLE_FG COLOR_YELLOW |
| - | #define SEARCHBOX_TITLE_BG COLOR_WHITE |
| - | #define SEARCHBOX_TITLE_HL TRUE |
| - | |
| - | #define SEARCHBOX_BORDER_FG COLOR_WHITE |
| - | #define SEARCHBOX_BORDER_BG COLOR_WHITE |
| - | #define SEARCHBOX_BORDER_HL TRUE |
| - | |
| - | #define POSITION_INDICATOR_FG COLOR_YELLOW |
| - | #define POSITION_INDICATOR_BG COLOR_WHITE |
| - | #define POSITION_INDICATOR_HL TRUE |
| - | |
| - | #define MENUBOX_FG COLOR_BLACK |
| - | #define MENUBOX_BG COLOR_WHITE |
| - | #define MENUBOX_HL FALSE |
| - | |
| - | #define MENUBOX_BORDER_FG COLOR_WHITE |
| - | #define MENUBOX_BORDER_BG COLOR_WHITE |
| - | #define MENUBOX_BORDER_HL TRUE |
| - | |
| - | #define ITEM_FG COLOR_BLACK |
| - | #define ITEM_BG COLOR_WHITE |
| - | #define ITEM_HL FALSE |
| - | |
| - | #define ITEM_SELECTED_FG COLOR_WHITE |
| - | #define ITEM_SELECTED_BG COLOR_BLUE |
| - | #define ITEM_SELECTED_HL TRUE |
| - | |
| - | #define TAG_FG COLOR_YELLOW |
| - | #define TAG_BG COLOR_WHITE |
| - | #define TAG_HL TRUE |
| - | |
| - | #define TAG_SELECTED_FG COLOR_YELLOW |
| - | #define TAG_SELECTED_BG COLOR_BLUE |
| - | #define TAG_SELECTED_HL TRUE |
| - | |
| - | #define TAG_KEY_FG COLOR_YELLOW |
| - | #define TAG_KEY_BG COLOR_WHITE |
| - | #define TAG_KEY_HL TRUE |
| - | |
| - | #define TAG_KEY_SELECTED_FG COLOR_YELLOW |
| - | #define TAG_KEY_SELECTED_BG COLOR_BLUE |
| - | #define TAG_KEY_SELECTED_HL TRUE |
| - | |
| - | #define CHECK_FG COLOR_BLACK |
| - | #define CHECK_BG COLOR_WHITE |
| - | #define CHECK_HL FALSE |
| - | |
| - | #define CHECK_SELECTED_FG COLOR_WHITE |
| - | #define CHECK_SELECTED_BG COLOR_BLUE |
| - | #define CHECK_SELECTED_HL TRUE |
| - | |
| - | #define UARROW_FG COLOR_GREEN |
| - | #define UARROW_BG COLOR_WHITE |
| - | #define UARROW_HL TRUE |
| - | |
| - | #define DARROW_FG COLOR_GREEN |
| - | #define DARROW_BG COLOR_WHITE |
| - | #define DARROW_HL TRUE |
| - | |
| - | /* End of default color definitions */ |
| - | |
| - | #define C_ATTR(x,y) ((x ? A_BOLD : 0) | COLOR_PAIR((y))) |
| - | #define COLOR_NAME_LEN 10 |
| - | #define COLOR_COUNT 8 |
| - | |
| - | /* |
| - | * Global variables |
| - | */ |
| - | |
| - | typedef struct { |
| - | char name[COLOR_NAME_LEN]; |
| - | int value; |
| - | } color_names_st; |
| - | |
| - | extern color_names_st color_names[]; |
| - | extern int color_table[][3]; |
| @@ -1,200 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | |
| - | /* |
| - | * dialog.h -- common declarations for all dialog modules |
| - | * |
| - | * AUTHOR: Savio Lam ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | #include <sys/types.h> |
| - | #include <fcntl.h> |
| - | #include <unistd.h> |
| - | #include <ctype.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | |
| - | #ifdef CURSES_LOC |
| - | #ifdef __sun__ |
| - | #define CURS_MACROS |
| - | #endif |
| - | #include CURSES_LOC |
| - | |
| - | /* |
| - | * Colors in ncurses 1.9.9e do not work properly since foreground and |
| - | * background colors are OR'd rather than separately masked. This version |
| - | * of dialog was hacked to work with ncurses 1.9.9e, making it incompatible |
| - | * with standard curses. The simplest fix (to make this work with standard |
| - | * curses) uses the wbkgdset() function, not used in the original hack. |
| - | * Turn it off if we're building with 1.9.9e, since it just confuses things. |
| - | */ |
| - | #if defined(NCURSES_VERSION) && defined(_NEED_WRAP) && !defined(GCC_PRINTFLIKE) |
| - | #define OLD_NCURSES 1 |
| - | #undef wbkgdset |
| - | #define wbkgdset(w,p) /*nothing*/ |
| - | #else |
| - | #define OLD_NCURSES 0 |
| - | #endif |
| - | |
| - | #define TR(params) _tracef params |
| - | |
| - | #define ESC 27 |
| - | #define TAB 9 |
| - | #define MAX_LEN 2048 |
| - | #define BUF_SIZE (10*1024) |
| - | #define MIN(x,y) (x < y ? x : y) |
| - | #define MAX(x,y) (x > y ? x : y) |
| - | |
| - | |
| - | #ifndef ACS_ULCORNER |
| - | #define ACS_ULCORNER '+' |
| - | #endif |
| - | #ifndef ACS_LLCORNER |
| - | #define ACS_LLCORNER '+' |
| - | #endif |
| - | #ifndef ACS_URCORNER |
| - | #define ACS_URCORNER '+' |
| - | #endif |
| - | #ifndef ACS_LRCORNER |
| - | #define ACS_LRCORNER '+' |
| - | #endif |
| - | #ifndef ACS_HLINE |
| - | #define ACS_HLINE '-' |
| - | #endif |
| - | #ifndef ACS_VLINE |
| - | #define ACS_VLINE '|' |
| - | #endif |
| - | #ifndef ACS_LTEE |
| - | #define ACS_LTEE '+' |
| - | #endif |
| - | #ifndef ACS_RTEE |
| - | #define ACS_RTEE '+' |
| - | #endif |
| - | #ifndef ACS_UARROW |
| - | #define ACS_UARROW '^' |
| - | #endif |
| - | #ifndef ACS_DARROW |
| - | #define ACS_DARROW 'v' |
| - | #endif |
| - | |
| - | /* |
| - | * Attribute names |
| - | */ |
| - | #define screen_attr attributes[0] |
| - | #define shadow_attr attributes[1] |
| - | #define dialog_attr attributes[2] |
| - | #define title_attr attributes[3] |
| - | #define border_attr attributes[4] |
| - | #define button_active_attr attributes[5] |
| - | #define button_inactive_attr attributes[6] |
| - | #define button_key_active_attr attributes[7] |
| - | #define button_key_inactive_attr attributes[8] |
| - | #define button_label_active_attr attributes[9] |
| - | #define button_label_inactive_attr attributes[10] |
| - | #define inputbox_attr attributes[11] |
| - | #define inputbox_border_attr attributes[12] |
| - | #define searchbox_attr attributes[13] |
| - | #define searchbox_title_attr attributes[14] |
| - | #define searchbox_border_attr attributes[15] |
| - | #define position_indicator_attr attributes[16] |
| - | #define menubox_attr attributes[17] |
| - | #define menubox_border_attr attributes[18] |
| - | #define item_attr attributes[19] |
| - | #define item_selected_attr attributes[20] |
| - | #define tag_attr attributes[21] |
| - | #define tag_selected_attr attributes[22] |
| - | #define tag_key_attr attributes[23] |
| - | #define tag_key_selected_attr attributes[24] |
| - | #define check_attr attributes[25] |
| - | #define check_selected_attr attributes[26] |
| - | #define uarrow_attr attributes[27] |
| - | #define darrow_attr attributes[28] |
| - | |
| - | /* number of attributes */ |
| - | #define ATTRIBUTE_COUNT 29 |
| - | |
| - | /* |
| - | * Global variables |
| - | */ |
| - | extern bool use_colors; |
| - | |
| - | extern chtype attributes[]; |
| - | #endif |
| - | |
| - | extern const char *backtitle; |
| - | |
| - | struct dialog_list_item { |
| - | char *name; |
| - | int namelen; |
| - | char *tag; |
| - | int selected; /* Set to 1 by dialog_*() function. */ |
| - | }; |
| - | |
| - | /* |
| - | * Function prototypes |
| - | */ |
| - | |
| - | void init_dialog (void); |
| - | void end_dialog (void); |
| - | void dialog_clear (void); |
| - | #ifdef CURSES_LOC |
| - | void attr_clear (WINDOW * win, int height, int width, chtype attr); |
| - | void color_setup (void); |
| - | void print_autowrap (WINDOW * win, const char *prompt, int width, int y, int x); |
| - | void print_button (WINDOW * win, const char *label, int y, int x, int selected); |
| - | void draw_box (WINDOW * win, int y, int x, int height, int width, chtype box, |
| - | chtype border); |
| - | void draw_shadow (WINDOW * win, int y, int x, int height, int width); |
| - | #endif |
| - | |
| - | int first_alpha (const char *string, const char *exempt); |
| - | int dialog_yesno (const char *title, const char *prompt, int height, int width); |
| - | int dialog_msgbox (const char *title, const char *prompt, int height, |
| - | int width, int pause); |
| - | int dialog_textbox (const char *title, const char *file, int height, int width); |
| - | int dialog_menu (const char *title, const char *prompt, int height, int width, |
| - | int menu_height, const char *choice, int item_no, |
| - | struct dialog_list_item ** items); |
| - | int dialog_checklist (const char *title, const char *prompt, int height, |
| - | int width, int list_height, int item_no, |
| - | struct dialog_list_item ** items, int flag); |
| - | extern char dialog_input_result[]; |
| - | int dialog_inputbox (const char *title, const char *prompt, int height, |
| - | int width, const char *init); |
| - | |
| - | struct dialog_list_item *first_sel_item(int item_no, |
| - | struct dialog_list_item ** items); |
| - | |
| - | /* |
| - | * This is the base for fictitious keys, which activate |
| - | * the buttons. |
| - | * |
| - | * Mouse-generated keys are the following: |
| - | * -- the first 32 are used as numbers, in addition to '0'-'9' |
| - | * -- the lowercase are used to signal mouse-enter events (M_EVENT + 'o') |
| - | * -- uppercase chars are used to invoke the button (M_EVENT + 'O') |
| - | */ |
| - | #ifdef CURSES_LOC |
| - | #define M_EVENT (KEY_MAX+1) |
| - | #endif |
| - | |
| - | |
| - | /* |
| - | * The `flag' parameter in checklist is used to select between |
| - | * radiolist and checklist |
| - | */ |
| - | #define FLAG_CHECK 1 |
| - | #define FLAG_RADIO 0 |
| @@ -1,241 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * inputbox.c -- implements the input box |
| - | * |
| - | * ORIGINAL AUTHOR: Savio Lam ([email protected]) |
| - | * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | #include "dialog.h" |
| - | |
| - | char dialog_input_result[MAX_LEN + 1]; |
| - | |
| - | /* |
| - | * Print the termination buttons |
| - | */ |
| - | static void |
| - | print_buttons(WINDOW *dialog, int height, int width, int selected) |
| - | { |
| - | int x = width / 2 - 11; |
| - | int y = height - 2; |
| - | |
| - | print_button (dialog, " Ok ", y, x, selected==0); |
| - | print_button (dialog, " Help ", y, x + 14, selected==1); |
| - | |
| - | wmove(dialog, y, x+1+14*selected); |
| - | wrefresh(dialog); |
| - | } |
| - | |
| - | /* |
| - | * Display a dialog box for inputing a string |
| - | */ |
| - | int |
| - | dialog_inputbox (const char *title, const char *prompt, int height, int width, |
| - | const char *init) |
| - | { |
| - | int i, x, y, box_y, box_x, box_width; |
| - | int input_x = 0, scroll = 0, key = 0, button = -1; |
| - | char *instr = dialog_input_result; |
| - | WINDOW *dialog; |
| - | |
| - | /* center dialog box on screen */ |
| - | x = (COLS - width) / 2; |
| - | y = (LINES - height) / 2; |
| - | |
| - | |
| - | draw_shadow (stdscr, y, x, height, width); |
| - | |
| - | dialog = newwin (height, width, y, x); |
| - | keypad (dialog, TRUE); |
| - | |
| - | draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); |
| - | wattrset (dialog, border_attr); |
| - | mvwaddch (dialog, height-3, 0, ACS_LTEE); |
| - | for (i = 0; i < width - 2; i++) |
| - | waddch (dialog, ACS_HLINE); |
| - | wattrset (dialog, dialog_attr); |
| - | waddch (dialog, ACS_RTEE); |
| - | |
| - | if (title != NULL && strlen(title) >= width-2 ) { |
| - | /* truncate long title -- mec */ |
| - | char * title2 = malloc(width-2+1); |
| - | memcpy( title2, title, width-2 ); |
| - | title2[width-2] = '\0'; |
| - | title = title2; |
| - | } |
| - | |
| - | if (title != NULL) { |
| - | wattrset (dialog, title_attr); |
| - | mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); |
| - | waddstr (dialog, (char *)title); |
| - | waddch (dialog, ' '); |
| - | } |
| - | |
| - | wattrset (dialog, dialog_attr); |
| - | print_autowrap (dialog, prompt, width - 2, 1, 3); |
| - | |
| - | /* Draw the input field box */ |
| - | box_width = width - 6; |
| - | getyx (dialog, y, x); |
| - | box_y = y + 2; |
| - | box_x = (width - box_width) / 2; |
| - | draw_box (dialog, y + 1, box_x - 1, 3, box_width + 2, |
| - | border_attr, dialog_attr); |
| - | |
| - | print_buttons(dialog, height, width, 0); |
| - | |
| - | /* Set up the initial value */ |
| - | wmove (dialog, box_y, box_x); |
| - | wattrset (dialog, inputbox_attr); |
| - | |
| - | if (!init) |
| - | instr[0] = '\0'; |
| - | else |
| - | strcpy (instr, init); |
| - | |
| - | input_x = strlen (instr); |
| - | |
| - | if (input_x >= box_width) { |
| - | scroll = input_x - box_width + 1; |
| - | input_x = box_width - 1; |
| - | for (i = 0; i < box_width - 1; i++) |
| - | waddch (dialog, instr[scroll + i]); |
| - | } else |
| - | waddstr (dialog, instr); |
| - | |
| - | wmove (dialog, box_y, box_x + input_x); |
| - | |
| - | wrefresh (dialog); |
| - | |
| - | while (key != ESC) { |
| - | key = wgetch (dialog); |
| - | |
| - | if (button == -1) { /* Input box selected */ |
| - | switch (key) { |
| - | case TAB: |
| - | case KEY_UP: |
| - | case KEY_DOWN: |
| - | break; |
| - | case KEY_LEFT: |
| - | continue; |
| - | case KEY_RIGHT: |
| - | continue; |
| - | case KEY_BACKSPACE: |
| - | case 127: |
| - | if (input_x || scroll) { |
| - | wattrset (dialog, inputbox_attr); |
| - | if (!input_x) { |
| - | scroll = scroll < box_width - 1 ? |
| - | 0 : scroll - (box_width - 1); |
| - | wmove (dialog, box_y, box_x); |
| - | for (i = 0; i < box_width; i++) |
| - | waddch (dialog, instr[scroll + input_x + i] ? |
| - | instr[scroll + input_x + i] : ' '); |
| - | input_x = strlen (instr) - scroll; |
| - | } else |
| - | input_x--; |
| - | instr[scroll + input_x] = '\0'; |
| - | mvwaddch (dialog, box_y, input_x + box_x, ' '); |
| - | wmove (dialog, box_y, input_x + box_x); |
| - | wrefresh (dialog); |
| - | } |
| - | continue; |
| - | default: |
| - | if (key < 0x100 && isprint (key)) { |
| - | if (scroll + input_x < MAX_LEN) { |
| - | wattrset (dialog, inputbox_attr); |
| - | instr[scroll + input_x] = key; |
| - | instr[scroll + input_x + 1] = '\0'; |
| - | if (input_x == box_width - 1) { |
| - | scroll++; |
| - | wmove (dialog, box_y, box_x); |
| - | for (i = 0; i < box_width - 1; i++) |
| - | waddch (dialog, instr[scroll + i]); |
| - | } else { |
| - | wmove (dialog, box_y, input_x++ + box_x); |
| - | waddch (dialog, key); |
| - | } |
| - | wrefresh (dialog); |
| - | } else |
| - | flash (); /* Alarm user about overflow */ |
| - | continue; |
| - | } |
| - | } |
| - | } |
| - | switch (key) { |
| - | case 'O': |
| - | case 'o': |
| - | delwin (dialog); |
| - | return 0; |
| - | case 'H': |
| - | case 'h': |
| - | delwin (dialog); |
| - | return 1; |
| - | case KEY_UP: |
| - | case KEY_LEFT: |
| - | switch (button) { |
| - | case -1: |
| - | button = 1; /* Indicates "Cancel" button is selected */ |
| - | print_buttons(dialog, height, width, 1); |
| - | break; |
| - | case 0: |
| - | button = -1; /* Indicates input box is selected */ |
| - | print_buttons(dialog, height, width, 0); |
| - | wmove (dialog, box_y, box_x + input_x); |
| - | wrefresh (dialog); |
| - | break; |
| - | case 1: |
| - | button = 0; /* Indicates "OK" button is selected */ |
| - | print_buttons(dialog, height, width, 0); |
| - | break; |
| - | } |
| - | break; |
| - | case TAB: |
| - | case KEY_DOWN: |
| - | case KEY_RIGHT: |
| - | switch (button) { |
| - | case -1: |
| - | button = 0; /* Indicates "OK" button is selected */ |
| - | print_buttons(dialog, height, width, 0); |
| - | break; |
| - | case 0: |
| - | button = 1; /* Indicates "Cancel" button is selected */ |
| - | print_buttons(dialog, height, width, 1); |
| - | break; |
| - | case 1: |
| - | button = -1; /* Indicates input box is selected */ |
| - | print_buttons(dialog, height, width, 0); |
| - | wmove (dialog, box_y, box_x + input_x); |
| - | wrefresh (dialog); |
| - | break; |
| - | } |
| - | break; |
| - | case ' ': |
| - | case '\n': |
| - | delwin (dialog); |
| - | return (button == -1 ? 0 : button); |
| - | case 'X': |
| - | case 'x': |
| - | key = ESC; |
| - | case ESC: |
| - | break; |
| - | } |
| - | } |
| - | |
| - | delwin (dialog); |
| - | return -1; /* ESC pressed */ |
| - | } |
| @@ -1,439 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * menubox.c -- implements the menu box |
| - | * |
| - | * ORIGINAL AUTHOR: Savio Lam ([email protected]) |
| - | * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | /* |
| - | * Changes by Clifford Wolf ([email protected]) |
| - | * |
| - | * [ 1998-06-13 ] |
| - | * |
| - | * *) A bugfix for the Page-Down problem |
| - | * |
| - | * *) Formerly when I used Page Down and Page Up, the cursor would be set |
| - | * to the first position in the menu box. Now lxdialog is a bit |
| - | * smarter and works more like other menu systems (just have a look at |
| - | * it). |
| - | * |
| - | * *) Formerly if I selected something my scrolling would be broken because |
| - | * lxdialog is re-invoked by the Menuconfig shell script, can't |
| - | * remember the last scrolling position, and just sets it so that the |
| - | * cursor is at the bottom of the box. Now it writes the temporary file |
| - | * lxdialog.scrltmp which contains this information. The file is |
| - | * deleted by lxdialog if the user leaves a submenu or enters a new |
| - | * one, but it would be nice if Menuconfig could make another "rm -f" |
| - | * just to be sure. Just try it out - you will recognise a difference! |
| - | * |
| - | * [ 1998-06-14 ] |
| - | * |
| - | * *) Now lxdialog is crash-safe against broken "lxdialog.scrltmp" files |
| - | * and menus change their size on the fly. |
| - | * |
| - | * *) If for some reason the last scrolling position is not saved by |
| - | * lxdialog, it sets the scrolling so that the selected item is in the |
| - | * middle of the menu box, not at the bottom. |
| - | * |
| - | * 02 January 1999, Michael Elizabeth Chastain ([email protected]) |
| - | * Reset 'scroll' to 0 if the value from lxdialog.scrltmp is bogus. |
| - | * This fixes a bug in Menuconfig where using ' ' to descend into menus |
| - | * would leave mis-synchronized lxdialog.scrltmp files lying around, |
| - | * fscanf would read in 'scroll', and eventually that value would get used. |
| - | */ |
| - | |
| - | #include "dialog.h" |
| - | |
| - | static int menu_width, item_x; |
| - | |
| - | /* |
| - | * Print menu item |
| - | */ |
| - | static void |
| - | print_item (WINDOW * win, const char *item, int choice, int selected, int hotkey) |
| - | { |
| - | int j; |
| - | char menu_item[menu_width+1]; |
| - | |
| - | strncpy(menu_item, item, menu_width); |
| - | menu_item[menu_width] = 0; |
| - | j = first_alpha(menu_item, "YyNnMmHh"); |
| - | |
| - | /* Clear 'residue' of last item */ |
| - | wattrset (win, menubox_attr); |
| - | wmove (win, choice, 0); |
| - | #if OLD_NCURSES |
| - | { |
| - | int i; |
| - | for (i = 0; i < menu_width; i++) |
| - | waddch (win, ' '); |
| - | } |
| - | #else |
| - | wclrtoeol(win); |
| - | #endif |
| - | wattrset (win, selected ? item_selected_attr : item_attr); |
| - | mvwaddstr (win, choice, item_x, menu_item); |
| - | if (hotkey) { |
| - | wattrset (win, selected ? tag_key_selected_attr : tag_key_attr); |
| - | mvwaddch(win, choice, item_x+j, menu_item[j]); |
| - | } |
| - | if (selected) { |
| - | wmove (win, choice, item_x+1); |
| - | wrefresh (win); |
| - | } |
| - | } |
| - | |
| - | /* |
| - | * Print the scroll indicators. |
| - | */ |
| - | static void |
| - | print_arrows (WINDOW * win, int item_no, int scroll, |
| - | int y, int x, int height) |
| - | { |
| - | int cur_y, cur_x; |
| - | |
| - | getyx(win, cur_y, cur_x); |
| - | |
| - | wmove(win, y, x); |
| - | |
| - | if (scroll > 0) { |
| - | wattrset (win, uarrow_attr); |
| - | waddch (win, ACS_UARROW); |
| - | waddstr (win, "(-)"); |
| - | } |
| - | else { |
| - | wattrset (win, menubox_attr); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | } |
| - | |
| - | y = y + height + 1; |
| - | wmove(win, y, x); |
| - | |
| - | if ((height < item_no) && (scroll + height < item_no)) { |
| - | wattrset (win, darrow_attr); |
| - | waddch (win, ACS_DARROW); |
| - | waddstr (win, "(+)"); |
| - | } |
| - | else { |
| - | wattrset (win, menubox_border_attr); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | waddch (win, ACS_HLINE); |
| - | } |
| - | |
| - | wmove(win, cur_y, cur_x); |
| - | } |
| - | |
| - | /* |
| - | * Display the termination buttons. |
| - | */ |
| - | static void |
| - | print_buttons (WINDOW *win, int height, int width, int selected) |
| - | { |
| - | int x = width / 2 - 16; |
| - | int y = height - 2; |
| - | |
| - | print_button (win, "Select", y, x, selected == 0); |
| - | print_button (win, " Exit ", y, x + 12, selected == 1); |
| - | print_button (win, " Help ", y, x + 24, selected == 2); |
| - | |
| - | wmove(win, y, x+1+12*selected); |
| - | wrefresh (win); |
| - | } |
| - | |
| - | /* |
| - | * Display a menu for choosing among a number of options |
| - | */ |
| - | int |
| - | dialog_menu (const char *title, const char *prompt, int height, int width, |
| - | int menu_height, const char *current, int item_no, |
| - | struct dialog_list_item ** items) |
| - | { |
| - | int i, j, x, y, box_x, box_y; |
| - | int key = 0, button = 0, scroll = 0, choice = 0, first_item = 0, max_choice; |
| - | WINDOW *dialog, *menu; |
| - | FILE *f; |
| - | |
| - | max_choice = MIN (menu_height, item_no); |
| - | |
| - | /* center dialog box on screen */ |
| - | x = (COLS - width) / 2; |
| - | y = (LINES - height) / 2; |
| - | |
| - | draw_shadow (stdscr, y, x, height, width); |
| - | |
| - | dialog = newwin (height, width, y, x); |
| - | keypad (dialog, TRUE); |
| - | |
| - | draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); |
| - | wattrset (dialog, border_attr); |
| - | mvwaddch (dialog, height - 3, 0, ACS_LTEE); |
| - | for (i = 0; i < width - 2; i++) |
| - | waddch (dialog, ACS_HLINE); |
| - | wattrset (dialog, dialog_attr); |
| - | wbkgdset (dialog, dialog_attr & A_COLOR); |
| - | waddch (dialog, ACS_RTEE); |
| - | |
| - | if (title != NULL && strlen(title) >= width-2 ) { |
| - | /* truncate long title -- mec */ |
| - | char * title2 = malloc(width-2+1); |
| - | memcpy( title2, title, width-2 ); |
| - | title2[width-2] = '\0'; |
| - | title = title2; |
| - | } |
| - | |
| - | if (title != NULL) { |
| - | wattrset (dialog, title_attr); |
| - | mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); |
| - | waddstr (dialog, (char *)title); |
| - | waddch (dialog, ' '); |
| - | } |
| - | |
| - | wattrset (dialog, dialog_attr); |
| - | print_autowrap (dialog, prompt, width - 2, 1, 3); |
| - | |
| - | menu_width = width - 6; |
| - | box_y = height - menu_height - 5; |
| - | box_x = (width - menu_width) / 2 - 1; |
| - | |
| - | /* create new window for the menu */ |
| - | menu = subwin (dialog, menu_height, menu_width, |
| - | y + box_y + 1, x + box_x + 1); |
| - | keypad (menu, TRUE); |
| - | |
| - | /* draw a box around the menu items */ |
| - | draw_box (dialog, box_y, box_x, menu_height + 2, menu_width + 2, |
| - | menubox_border_attr, menubox_attr); |
| - | |
| - | /* |
| - | * Find length of longest item in order to center menu. |
| - | * Set 'choice' to default item. |
| - | */ |
| - | item_x = 0; |
| - | for (i = 0; i < item_no; i++) { |
| - | item_x = MAX (item_x, MIN(menu_width, strlen (items[i]->name) + 2)); |
| - | if (strcmp(current, items[i]->tag) == 0) choice = i; |
| - | } |
| - | |
| - | item_x = (menu_width - item_x) / 2; |
| - | |
| - | /* get the scroll info from the temp file */ |
| - | if ( (f=fopen("lxdialog.scrltmp","r")) != NULL ) { |
| - | if ( (fscanf(f,"%d\n",&scroll) == 1) && (scroll <= choice) && |
| - | (scroll+max_choice > choice) && (scroll >= 0) && |
| - | (scroll+max_choice <= item_no) ) { |
| - | first_item = scroll; |
| - | choice = choice - scroll; |
| - | fclose(f); |
| - | } else { |
| - | scroll=0; |
| - | remove("lxdialog.scrltmp"); |
| - | fclose(f); |
| - | f=NULL; |
| - | } |
| - | } |
| - | if ( (choice >= max_choice) || (f==NULL && choice >= max_choice/2) ) { |
| - | if (choice >= item_no-max_choice/2) |
| - | scroll = first_item = item_no-max_choice; |
| - | else |
| - | scroll = first_item = choice - max_choice/2; |
| - | choice = choice - scroll; |
| - | } |
| - | |
| - | /* Print the menu */ |
| - | for (i=0; i < max_choice; i++) { |
| - | print_item (menu, items[first_item + i]->name, i, i == choice, |
| - | (items[first_item + i]->tag[0] != ':')); |
| - | } |
| - | |
| - | wnoutrefresh (menu); |
| - | |
| - | print_arrows(dialog, item_no, scroll, |
| - | box_y, box_x+item_x+1, menu_height); |
| - | |
| - | print_buttons (dialog, height, width, 0); |
| - | wmove (menu, choice, item_x+1); |
| - | wrefresh (menu); |
| - | |
| - | while (key != ESC) { |
| - | key = wgetch(menu); |
| - | |
| - | if (key < 256 && isalpha(key)) key = tolower(key); |
| - | |
| - | if (strchr("ynmh", key)) |
| - | i = max_choice; |
| - | else { |
| - | for (i = choice+1; i < max_choice; i++) { |
| - | j = first_alpha(items[scroll + i]->name, "YyNnMmHh"); |
| - | if (key == tolower(items[scroll + i]->name[j])) |
| - | break; |
| - | } |
| - | if (i == max_choice) |
| - | for (i = 0; i < max_choice; i++) { |
| - | j = first_alpha(items[scroll + i]->name, "YyNnMmHh"); |
| - | if (key == tolower(items[scroll + i]->name[j])) |
| - | break; |
| - | } |
| - | } |
| - | |
| - | if (i < max_choice || |
| - | key == KEY_UP || key == KEY_DOWN || |
| - | key == '-' || key == '+' || |
| - | key == KEY_PPAGE || key == KEY_NPAGE) { |
| - | |
| - | print_item (menu, items[scroll + choice]->name, choice, FALSE, |
| - | (items[scroll + choice]->tag[0] != ':')); |
| - | |
| - | if (key == KEY_UP || key == '-') { |
| - | if (choice < 2 && scroll) { |
| - | /* Scroll menu down */ |
| - | scrollok (menu, TRUE); |
| - | wscrl (menu, -1); |
| - | scrollok (menu, FALSE); |
| - | |
| - | scroll--; |
| - | |
| - | print_item (menu, items[scroll]->name, 0, FALSE, |
| - | (items[scroll]->tag[0] != ':')); |
| - | } else |
| - | choice = MAX(choice - 1, 0); |
| - | |
| - | } else if (key == KEY_DOWN || key == '+') { |
| - | |
| - | print_item (menu, items[scroll + choice]->name, choice, FALSE, |
| - | (items[scroll + choice]->tag[0] != ':')); |
| - | |
| - | if ((choice > max_choice-3) && |
| - | (scroll + max_choice < item_no) |
| - | ) { |
| - | /* Scroll menu up */ |
| - | scrollok (menu, TRUE); |
| - | scroll (menu); |
| - | scrollok (menu, FALSE); |
| - | |
| - | scroll++; |
| - | |
| - | print_item (menu, items[scroll + max_choice - 1]->name, |
| - | max_choice-1, FALSE, |
| - | (items[scroll + max_choice - 1]->tag[0] != ':')); |
| - | } else |
| - | choice = MIN(choice+1, max_choice-1); |
| - | |
| - | } else if (key == KEY_PPAGE) { |
| - | scrollok (menu, TRUE); |
| - | for (i=0; (i < max_choice); i++) { |
| - | if (scroll > 0) { |
| - | wscrl (menu, -1); |
| - | scroll--; |
| - | print_item (menu, items[scroll]->name, 0, FALSE, |
| - | (items[scroll]->tag[0] != ':')); |
| - | } else { |
| - | if (choice > 0) |
| - | choice--; |
| - | } |
| - | } |
| - | scrollok (menu, FALSE); |
| - | |
| - | } else if (key == KEY_NPAGE) { |
| - | for (i=0; (i < max_choice); i++) { |
| - | if (scroll+max_choice < item_no) { |
| - | scrollok (menu, TRUE); |
| - | scroll(menu); |
| - | scrollok (menu, FALSE); |
| - | scroll++; |
| - | print_item (menu, items[scroll + max_choice - 1]->name, |
| - | max_choice-1, FALSE, |
| - | (items[scroll + max_choice - 1]->tag[0] != ':')); |
| - | } else { |
| - | if (choice+1 < max_choice) |
| - | choice++; |
| - | } |
| - | } |
| - | |
| - | } else |
| - | choice = i; |
| - | |
| - | print_item (menu, items[scroll + choice]->name, choice, TRUE, |
| - | (items[scroll + choice]->tag[0] != ':')); |
| - | |
| - | print_arrows(dialog, item_no, scroll, |
| - | box_y, box_x+item_x+1, menu_height); |
| - | |
| - | wnoutrefresh (dialog); |
| - | wrefresh (menu); |
| - | |
| - | continue; /* wait for another key press */ |
| - | } |
| - | |
| - | switch (key) { |
| - | case KEY_LEFT: |
| - | case TAB: |
| - | case KEY_RIGHT: |
| - | button = ((key == KEY_LEFT ? --button : ++button) < 0) |
| - | ? 2 : (button > 2 ? 0 : button); |
| - | |
| - | print_buttons(dialog, height, width, button); |
| - | wrefresh (menu); |
| - | break; |
| - | case ' ': |
| - | case 's': |
| - | case 'y': |
| - | case 'n': |
| - | case 'm': |
| - | case '/': |
| - | /* save scroll info */ |
| - | if ( (f=fopen("lxdialog.scrltmp","w")) != NULL ) { |
| - | fprintf(f,"%d\n",scroll); |
| - | fclose(f); |
| - | } |
| - | delwin (dialog); |
| - | items[scroll + choice]->selected = 1; |
| - | switch (key) { |
| - | case 's': return 3; |
| - | case 'y': return 3; |
| - | case 'n': return 4; |
| - | case 'm': return 5; |
| - | case ' ': return 6; |
| - | case '/': return 7; |
| - | } |
| - | return 0; |
| - | case 'h': |
| - | case '?': |
| - | button = 2; |
| - | case '\n': |
| - | delwin (dialog); |
| - | items[scroll + choice]->selected = 1; |
| - | |
| - | remove("lxdialog.scrltmp"); |
| - | return button; |
| - | case 'e': |
| - | case 'x': |
| - | key = ESC; |
| - | case ESC: |
| - | break; |
| - | } |
| - | } |
| - | |
| - | delwin (dialog); |
| - | remove("lxdialog.scrltmp"); |
| - | return -1; /* ESC pressed */ |
| - | } |
| @@ -1,86 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * msgbox.c -- implements the message box and info box |
| - | * |
| - | * ORIGINAL AUTHOR: Savio Lam ([email protected]) |
| - | * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | #include "dialog.h" |
| - | |
| - | /* |
| - | * Display a message box. Program will pause and display an "OK" button |
| - | * if the parameter 'pause' is non-zero. |
| - | */ |
| - | int |
| - | dialog_msgbox (const char *title, const char *prompt, int height, int width, |
| - | int pause) |
| - | { |
| - | int i, x, y, key = 0; |
| - | WINDOW *dialog; |
| - | |
| - | /* center dialog box on screen */ |
| - | x = (COLS - width) / 2; |
| - | y = (LINES - height) / 2; |
| - | |
| - | draw_shadow (stdscr, y, x, height, width); |
| - | |
| - | dialog = newwin (height, width, y, x); |
| - | keypad (dialog, TRUE); |
| - | |
| - | draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); |
| - | |
| - | if (title != NULL && strlen(title) >= width-2 ) { |
| - | /* truncate long title -- mec */ |
| - | char * title2 = malloc(width-2+1); |
| - | memcpy( title2, title, width-2 ); |
| - | title2[width-2] = '\0'; |
| - | title = title2; |
| - | } |
| - | |
| - | if (title != NULL) { |
| - | wattrset (dialog, title_attr); |
| - | mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); |
| - | waddstr (dialog, (char *)title); |
| - | waddch (dialog, ' '); |
| - | } |
| - | wattrset (dialog, dialog_attr); |
| - | print_autowrap (dialog, prompt, width - 2, 1, 2); |
| - | |
| - | if (pause) { |
| - | wattrset (dialog, border_attr); |
| - | mvwaddch (dialog, height - 3, 0, ACS_LTEE); |
| - | for (i = 0; i < width - 2; i++) |
| - | waddch (dialog, ACS_HLINE); |
| - | wattrset (dialog, dialog_attr); |
| - | waddch (dialog, ACS_RTEE); |
| - | |
| - | print_button (dialog, " Ok ", |
| - | height - 2, width / 2 - 4, TRUE); |
| - | |
| - | wrefresh (dialog); |
| - | while (key != ESC && key != '\n' && key != ' ' && |
| - | key != 'O' && key != 'o' && key != 'X' && key != 'x') |
| - | key = wgetch (dialog); |
| - | } else { |
| - | key = '\n'; |
| - | wrefresh (dialog); |
| - | } |
| - | |
| - | delwin (dialog); |
| - | return key == ESC ? -1 : 0; |
| - | } |
| @@ -1,557 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * textbox.c -- implements the text box |
| - | * |
| - | * ORIGINAL AUTHOR: Savio Lam ([email protected]) |
| - | * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | #include "dialog.h" |
| - | |
| - | static void back_lines (int n); |
| - | static void print_page (WINDOW * win, int height, int width); |
| - | static void print_line (WINDOW * win, int row, int width); |
| - | static char *get_line (void); |
| - | static void print_position (WINDOW * win, int height, int width); |
| - | |
| - | static int hscroll, fd, file_size, bytes_read; |
| - | static int begin_reached = 1, end_reached, page_length; |
| - | static char *buf, *page; |
| - | |
| - | /* |
| - | * Display text from a file in a dialog box. |
| - | */ |
| - | int |
| - | dialog_textbox (const char *title, const char *file, int height, int width) |
| - | { |
| - | int i, x, y, cur_x, cur_y, fpos, key = 0; |
| - | int passed_end; |
| - | char search_term[MAX_LEN + 1]; |
| - | WINDOW *dialog, *text; |
| - | |
| - | search_term[0] = '\0'; /* no search term entered yet */ |
| - | |
| - | /* Open input file for reading */ |
| - | if ((fd = open (file, O_RDONLY)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nCan't open input file in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | /* Get file size. Actually, 'file_size' is the real file size - 1, |
| - | since it's only the last byte offset from the beginning */ |
| - | if ((file_size = lseek (fd, 0, SEEK_END)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError getting file size in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | /* Restore file pointer to beginning of file after getting file size */ |
| - | if (lseek (fd, 0, SEEK_SET) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | /* Allocate space for read buffer */ |
| - | if ((buf = malloc (BUF_SIZE + 1)) == NULL) { |
| - | endwin (); |
| - | fprintf (stderr, "\nCan't allocate memory in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError reading file in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | buf[bytes_read] = '\0'; /* mark end of valid data */ |
| - | page = buf; /* page is pointer to start of page to be displayed */ |
| - | |
| - | /* center dialog box on screen */ |
| - | x = (COLS - width) / 2; |
| - | y = (LINES - height) / 2; |
| - | |
| - | |
| - | draw_shadow (stdscr, y, x, height, width); |
| - | |
| - | dialog = newwin (height, width, y, x); |
| - | keypad (dialog, TRUE); |
| - | |
| - | /* Create window for text region, used for scrolling text */ |
| - | text = subwin (dialog, height - 4, width - 2, y + 1, x + 1); |
| - | wattrset (text, dialog_attr); |
| - | wbkgdset (text, dialog_attr & A_COLOR); |
| - | |
| - | keypad (text, TRUE); |
| - | |
| - | /* register the new window, along with its borders */ |
| - | draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); |
| - | |
| - | wattrset (dialog, border_attr); |
| - | mvwaddch (dialog, height-3, 0, ACS_LTEE); |
| - | for (i = 0; i < width - 2; i++) |
| - | waddch (dialog, ACS_HLINE); |
| - | wattrset (dialog, dialog_attr); |
| - | wbkgdset (dialog, dialog_attr & A_COLOR); |
| - | waddch (dialog, ACS_RTEE); |
| - | |
| - | if (title != NULL && strlen(title) >= width-2 ) { |
| - | /* truncate long title -- mec */ |
| - | char * title2 = malloc(width-2+1); |
| - | memcpy( title2, title, width-2 ); |
| - | title2[width-2] = '\0'; |
| - | title = title2; |
| - | } |
| - | |
| - | if (title != NULL) { |
| - | wattrset (dialog, title_attr); |
| - | mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); |
| - | waddstr (dialog, (char *)title); |
| - | waddch (dialog, ' '); |
| - | } |
| - | print_button (dialog, " Exit ", height - 2, width / 2 - 4, TRUE); |
| - | wnoutrefresh (dialog); |
| - | getyx (dialog, cur_y, cur_x); /* Save cursor position */ |
| - | |
| - | /* Print first page of text */ |
| - | attr_clear (text, height - 4, width - 2, dialog_attr); |
| - | print_page (text, height - 4, width - 2); |
| - | print_position (dialog, height, width); |
| - | wmove (dialog, cur_y, cur_x); /* Restore cursor position */ |
| - | wrefresh (dialog); |
| - | |
| - | while ((key != ESC) && (key != '\n')) { |
| - | key = wgetch (dialog); |
| - | switch (key) { |
| - | case 'E': /* Exit */ |
| - | case 'e': |
| - | case 'X': |
| - | case 'x': |
| - | delwin (dialog); |
| - | free (buf); |
| - | close (fd); |
| - | return 0; |
| - | case 'g': /* First page */ |
| - | case KEY_HOME: |
| - | if (!begin_reached) { |
| - | begin_reached = 1; |
| - | /* First page not in buffer? */ |
| - | if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nError moving file pointer in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | if (fpos > bytes_read) { /* Yes, we have to read it in */ |
| - | if (lseek (fd, 0, SEEK_SET) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer in " |
| - | "dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nError reading file in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | buf[bytes_read] = '\0'; |
| - | } |
| - | page = buf; |
| - | print_page (text, height - 4, width - 2); |
| - | print_position (dialog, height, width); |
| - | wmove (dialog, cur_y, cur_x); /* Restore cursor position */ |
| - | wrefresh (dialog); |
| - | } |
| - | break; |
| - | case 'G': /* Last page */ |
| - | case KEY_END: |
| - | |
| - | end_reached = 1; |
| - | /* Last page not in buffer? */ |
| - | if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nError moving file pointer in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | if (fpos < file_size) { /* Yes, we have to read it in */ |
| - | if (lseek (fd, -BUF_SIZE, SEEK_END) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nError moving file pointer in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nError reading file in dialog_textbox().\n"); |
| - | exit (-1); |
| - | } |
| - | buf[bytes_read] = '\0'; |
| - | } |
| - | page = buf + bytes_read; |
| - | back_lines (height - 4); |
| - | print_page (text, height - 4, width - 2); |
| - | print_position (dialog, height, width); |
| - | wmove (dialog, cur_y, cur_x); /* Restore cursor position */ |
| - | wrefresh (dialog); |
| - | break; |
| - | case 'K': /* Previous line */ |
| - | case 'k': |
| - | case KEY_UP: |
| - | if (!begin_reached) { |
| - | back_lines (page_length + 1); |
| - | |
| - | /* We don't call print_page() here but use scrolling to ensure |
| - | faster screen update. However, 'end_reached' and |
| - | 'page_length' should still be updated, and 'page' should |
| - | point to start of next page. This is done by calling |
| - | get_line() in the following 'for' loop. */ |
| - | scrollok (text, TRUE); |
| - | wscrl (text, -1); /* Scroll text region down one line */ |
| - | scrollok (text, FALSE); |
| - | page_length = 0; |
| - | passed_end = 0; |
| - | for (i = 0; i < height - 4; i++) { |
| - | if (!i) { |
| - | /* print first line of page */ |
| - | print_line (text, 0, width - 2); |
| - | wnoutrefresh (text); |
| - | } else |
| - | /* Called to update 'end_reached' and 'page' */ |
| - | get_line (); |
| - | if (!passed_end) |
| - | page_length++; |
| - | if (end_reached && !passed_end) |
| - | passed_end = 1; |
| - | } |
| - | |
| - | print_position (dialog, height, width); |
| - | wmove (dialog, cur_y, cur_x); /* Restore cursor position */ |
| - | wrefresh (dialog); |
| - | } |
| - | break; |
| - | case 'B': /* Previous page */ |
| - | case 'b': |
| - | case KEY_PPAGE: |
| - | if (begin_reached) |
| - | break; |
| - | back_lines (page_length + height - 4); |
| - | print_page (text, height - 4, width - 2); |
| - | print_position (dialog, height, width); |
| - | wmove (dialog, cur_y, cur_x); |
| - | wrefresh (dialog); |
| - | break; |
| - | case 'J': /* Next line */ |
| - | case 'j': |
| - | case KEY_DOWN: |
| - | if (!end_reached) { |
| - | begin_reached = 0; |
| - | scrollok (text, TRUE); |
| - | scroll (text); /* Scroll text region up one line */ |
| - | scrollok (text, FALSE); |
| - | print_line (text, height - 5, width - 2); |
| - | wnoutrefresh (text); |
| - | print_position (dialog, height, width); |
| - | wmove (dialog, cur_y, cur_x); /* Restore cursor position */ |
| - | wrefresh (dialog); |
| - | } |
| - | break; |
| - | case KEY_NPAGE: /* Next page */ |
| - | case ' ': |
| - | if (end_reached) |
| - | break; |
| - | |
| - | begin_reached = 0; |
| - | print_page (text, height - 4, width - 2); |
| - | print_position (dialog, height, width); |
| - | wmove (dialog, cur_y, cur_x); |
| - | wrefresh (dialog); |
| - | break; |
| - | case '0': /* Beginning of line */ |
| - | case 'H': /* Scroll left */ |
| - | case 'h': |
| - | case KEY_LEFT: |
| - | if (hscroll <= 0) |
| - | break; |
| - | |
| - | if (key == '0') |
| - | hscroll = 0; |
| - | else |
| - | hscroll--; |
| - | /* Reprint current page to scroll horizontally */ |
| - | back_lines (page_length); |
| - | print_page (text, height - 4, width - 2); |
| - | wmove (dialog, cur_y, cur_x); |
| - | wrefresh (dialog); |
| - | break; |
| - | case 'L': /* Scroll right */ |
| - | case 'l': |
| - | case KEY_RIGHT: |
| - | if (hscroll >= MAX_LEN) |
| - | break; |
| - | hscroll++; |
| - | /* Reprint current page to scroll horizontally */ |
| - | back_lines (page_length); |
| - | print_page (text, height - 4, width - 2); |
| - | wmove (dialog, cur_y, cur_x); |
| - | wrefresh (dialog); |
| - | break; |
| - | case ESC: |
| - | break; |
| - | } |
| - | } |
| - | |
| - | delwin (dialog); |
| - | free (buf); |
| - | close (fd); |
| - | return 1; /* ESC pressed */ |
| - | } |
| - | |
| - | /* |
| - | * Go back 'n' lines in text file. Called by dialog_textbox(). |
| - | * 'page' will be updated to point to the desired line in 'buf'. |
| - | */ |
| - | static void |
| - | back_lines (int n) |
| - | { |
| - | int i, fpos; |
| - | |
| - | begin_reached = 0; |
| - | /* We have to distinguish between end_reached and !end_reached |
| - | since at end of file, the line is not ended by a '\n'. |
| - | The code inside 'if' basically does a '--page' to move one |
| - | character backward so as to skip '\n' of the previous line */ |
| - | if (!end_reached) { |
| - | /* Either beginning of buffer or beginning of file reached? */ |
| - | if (page == buf) { |
| - | if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer in " |
| - | "back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | if (fpos > bytes_read) { /* Not beginning of file yet */ |
| - | /* We've reached beginning of buffer, but not beginning of |
| - | file yet, so read previous part of file into buffer. |
| - | Note that we only move backward for BUF_SIZE/2 bytes, |
| - | but not BUF_SIZE bytes to avoid re-reading again in |
| - | print_page() later */ |
| - | /* Really possible to move backward BUF_SIZE/2 bytes? */ |
| - | if (fpos < BUF_SIZE / 2 + bytes_read) { |
| - | /* No, move less then */ |
| - | if (lseek (fd, 0, SEEK_SET) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer in " |
| - | "back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | page = buf + fpos - bytes_read; |
| - | } else { /* Move backward BUF_SIZE/2 bytes */ |
| - | if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), SEEK_CUR) |
| - | == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer " |
| - | "in back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | page = buf + BUF_SIZE / 2; |
| - | } |
| - | if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError reading file in back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | buf[bytes_read] = '\0'; |
| - | } else { /* Beginning of file reached */ |
| - | begin_reached = 1; |
| - | return; |
| - | } |
| - | } |
| - | if (*(--page) != '\n') { /* '--page' here */ |
| - | /* Something's wrong... */ |
| - | endwin (); |
| - | fprintf (stderr, "\nInternal error in back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | } |
| - | /* Go back 'n' lines */ |
| - | for (i = 0; i < n; i++) |
| - | do { |
| - | if (page == buf) { |
| - | if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, |
| - | "\nError moving file pointer in back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | if (fpos > bytes_read) { |
| - | /* Really possible to move backward BUF_SIZE/2 bytes? */ |
| - | if (fpos < BUF_SIZE / 2 + bytes_read) { |
| - | /* No, move less then */ |
| - | if (lseek (fd, 0, SEEK_SET) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer " |
| - | "in back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | page = buf + fpos - bytes_read; |
| - | } else { /* Move backward BUF_SIZE/2 bytes */ |
| - | if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), |
| - | SEEK_CUR) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer" |
| - | " in back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | page = buf + BUF_SIZE / 2; |
| - | } |
| - | if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError reading file in " |
| - | "back_lines().\n"); |
| - | exit (-1); |
| - | } |
| - | buf[bytes_read] = '\0'; |
| - | } else { /* Beginning of file reached */ |
| - | begin_reached = 1; |
| - | return; |
| - | } |
| - | } |
| - | } while (*(--page) != '\n'); |
| - | page++; |
| - | } |
| - | |
| - | /* |
| - | * Print a new page of text. Called by dialog_textbox(). |
| - | */ |
| - | static void |
| - | print_page (WINDOW * win, int height, int width) |
| - | { |
| - | int i, passed_end = 0; |
| - | |
| - | page_length = 0; |
| - | for (i = 0; i < height; i++) { |
| - | print_line (win, i, width); |
| - | if (!passed_end) |
| - | page_length++; |
| - | if (end_reached && !passed_end) |
| - | passed_end = 1; |
| - | } |
| - | wnoutrefresh (win); |
| - | } |
| - | |
| - | /* |
| - | * Print a new line of text. Called by dialog_textbox() and print_page(). |
| - | */ |
| - | static void |
| - | print_line (WINDOW * win, int row, int width) |
| - | { |
| - | int y, x; |
| - | char *line; |
| - | |
| - | line = get_line (); |
| - | line += MIN (strlen (line), hscroll); /* Scroll horizontally */ |
| - | wmove (win, row, 0); /* move cursor to correct line */ |
| - | waddch (win, ' '); |
| - | waddnstr (win, line, MIN (strlen (line), width - 2)); |
| - | |
| - | getyx (win, y, x); |
| - | /* Clear 'residue' of previous line */ |
| - | #if OLD_NCURSES |
| - | { |
| - | int i; |
| - | for (i = 0; i < width - x; i++) |
| - | waddch (win, ' '); |
| - | } |
| - | #else |
| - | wclrtoeol(win); |
| - | #endif |
| - | } |
| - | |
| - | /* |
| - | * Return current line of text. Called by dialog_textbox() and print_line(). |
| - | * 'page' should point to start of current line before calling, and will be |
| - | * updated to point to start of next line. |
| - | */ |
| - | static char * |
| - | get_line (void) |
| - | { |
| - | int i = 0, fpos; |
| - | static char line[MAX_LEN + 1]; |
| - | |
| - | end_reached = 0; |
| - | while (*page != '\n') { |
| - | if (*page == '\0') { |
| - | /* Either end of file or end of buffer reached */ |
| - | if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer in " |
| - | "get_line().\n"); |
| - | exit (-1); |
| - | } |
| - | if (fpos < file_size) { /* Not end of file yet */ |
| - | /* We've reached end of buffer, but not end of file yet, |
| - | so read next part of file into buffer */ |
| - | if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError reading file in get_line().\n"); |
| - | exit (-1); |
| - | } |
| - | buf[bytes_read] = '\0'; |
| - | page = buf; |
| - | } else { |
| - | if (!end_reached) |
| - | end_reached = 1; |
| - | break; |
| - | } |
| - | } else if (i < MAX_LEN) |
| - | line[i++] = *(page++); |
| - | else { |
| - | /* Truncate lines longer than MAX_LEN characters */ |
| - | if (i == MAX_LEN) |
| - | line[i++] = '\0'; |
| - | page++; |
| - | } |
| - | } |
| - | if (i <= MAX_LEN) |
| - | line[i] = '\0'; |
| - | if (!end_reached) |
| - | page++; /* move pass '\n' */ |
| - | |
| - | return line; |
| - | } |
| - | |
| - | /* |
| - | * Print current position |
| - | */ |
| - | static void |
| - | print_position (WINDOW * win, int height, int width) |
| - | { |
| - | int fpos, percent; |
| - | |
| - | if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { |
| - | endwin (); |
| - | fprintf (stderr, "\nError moving file pointer in print_position().\n"); |
| - | exit (-1); |
| - | } |
| - | wattrset (win, position_indicator_attr); |
| - | wbkgdset (win, position_indicator_attr & A_COLOR); |
| - | percent = !file_size ? |
| - | 100 : ((fpos - bytes_read + page - buf) * 100) / file_size; |
| - | wmove (win, height - 3, width - 9); |
| - | wprintw (win, "(%3d%%)", percent); |
| - | } |
| @@ -1,376 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * util.c |
| - | * |
| - | * ORIGINAL AUTHOR: Savio Lam ([email protected]) |
| - | * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | #include "dialog.h" |
| - | |
| - | |
| - | /* use colors by default? */ |
| - | bool use_colors = 1; |
| - | |
| - | const char *backtitle = NULL; |
| - | |
| - | const char *dialog_result; |
| - | |
| - | /* |
| - | * Attribute values, default is for mono display |
| - | */ |
| - | chtype attributes[] = |
| - | { |
| - | A_NORMAL, /* screen_attr */ |
| - | A_NORMAL, /* shadow_attr */ |
| - | A_NORMAL, /* dialog_attr */ |
| - | A_BOLD, /* title_attr */ |
| - | A_NORMAL, /* border_attr */ |
| - | A_REVERSE, /* button_active_attr */ |
| - | A_DIM, /* button_inactive_attr */ |
| - | A_REVERSE, /* button_key_active_attr */ |
| - | A_BOLD, /* button_key_inactive_attr */ |
| - | A_REVERSE, /* button_label_active_attr */ |
| - | A_NORMAL, /* button_label_inactive_attr */ |
| - | A_NORMAL, /* inputbox_attr */ |
| - | A_NORMAL, /* inputbox_border_attr */ |
| - | A_NORMAL, /* searchbox_attr */ |
| - | A_BOLD, /* searchbox_title_attr */ |
| - | A_NORMAL, /* searchbox_border_attr */ |
| - | A_BOLD, /* position_indicator_attr */ |
| - | A_NORMAL, /* menubox_attr */ |
| - | A_NORMAL, /* menubox_border_attr */ |
| - | A_NORMAL, /* item_attr */ |
| - | A_REVERSE, /* item_selected_attr */ |
| - | A_BOLD, /* tag_attr */ |
| - | A_REVERSE, /* tag_selected_attr */ |
| - | A_BOLD, /* tag_key_attr */ |
| - | A_REVERSE, /* tag_key_selected_attr */ |
| - | A_BOLD, /* check_attr */ |
| - | A_REVERSE, /* check_selected_attr */ |
| - | A_BOLD, /* uarrow_attr */ |
| - | A_BOLD /* darrow_attr */ |
| - | }; |
| - | |
| - | |
| - | #include "colors.h" |
| - | |
| - | /* |
| - | * Table of color values |
| - | */ |
| - | int color_table[][3] = |
| - | { |
| - | {SCREEN_FG, SCREEN_BG, SCREEN_HL}, |
| - | {SHADOW_FG, SHADOW_BG, SHADOW_HL}, |
| - | {DIALOG_FG, DIALOG_BG, DIALOG_HL}, |
| - | {TITLE_FG, TITLE_BG, TITLE_HL}, |
| - | {BORDER_FG, BORDER_BG, BORDER_HL}, |
| - | {BUTTON_ACTIVE_FG, BUTTON_ACTIVE_BG, BUTTON_ACTIVE_HL}, |
| - | {BUTTON_INACTIVE_FG, BUTTON_INACTIVE_BG, BUTTON_INACTIVE_HL}, |
| - | {BUTTON_KEY_ACTIVE_FG, BUTTON_KEY_ACTIVE_BG, BUTTON_KEY_ACTIVE_HL}, |
| - | {BUTTON_KEY_INACTIVE_FG, BUTTON_KEY_INACTIVE_BG, BUTTON_KEY_INACTIVE_HL}, |
| - | {BUTTON_LABEL_ACTIVE_FG, BUTTON_LABEL_ACTIVE_BG, BUTTON_LABEL_ACTIVE_HL}, |
| - | {BUTTON_LABEL_INACTIVE_FG, BUTTON_LABEL_INACTIVE_BG, |
| - | BUTTON_LABEL_INACTIVE_HL}, |
| - | {INPUTBOX_FG, INPUTBOX_BG, INPUTBOX_HL}, |
| - | {INPUTBOX_BORDER_FG, INPUTBOX_BORDER_BG, INPUTBOX_BORDER_HL}, |
| - | {SEARCHBOX_FG, SEARCHBOX_BG, SEARCHBOX_HL}, |
| - | {SEARCHBOX_TITLE_FG, SEARCHBOX_TITLE_BG, SEARCHBOX_TITLE_HL}, |
| - | {SEARCHBOX_BORDER_FG, SEARCHBOX_BORDER_BG, SEARCHBOX_BORDER_HL}, |
| - | {POSITION_INDICATOR_FG, POSITION_INDICATOR_BG, POSITION_INDICATOR_HL}, |
| - | {MENUBOX_FG, MENUBOX_BG, MENUBOX_HL}, |
| - | {MENUBOX_BORDER_FG, MENUBOX_BORDER_BG, MENUBOX_BORDER_HL}, |
| - | {ITEM_FG, ITEM_BG, ITEM_HL}, |
| - | {ITEM_SELECTED_FG, ITEM_SELECTED_BG, ITEM_SELECTED_HL}, |
| - | {TAG_FG, TAG_BG, TAG_HL}, |
| - | {TAG_SELECTED_FG, TAG_SELECTED_BG, TAG_SELECTED_HL}, |
| - | {TAG_KEY_FG, TAG_KEY_BG, TAG_KEY_HL}, |
| - | {TAG_KEY_SELECTED_FG, TAG_KEY_SELECTED_BG, TAG_KEY_SELECTED_HL}, |
| - | {CHECK_FG, CHECK_BG, CHECK_HL}, |
| - | {CHECK_SELECTED_FG, CHECK_SELECTED_BG, CHECK_SELECTED_HL}, |
| - | {UARROW_FG, UARROW_BG, UARROW_HL}, |
| - | {DARROW_FG, DARROW_BG, DARROW_HL}, |
| - | }; /* color_table */ |
| - | |
| - | /* |
| - | * Set window to attribute 'attr' |
| - | */ |
| - | void |
| - | attr_clear (WINDOW * win, int height, int width, chtype attr) |
| - | { |
| - | int i, j; |
| - | |
| - | wattrset (win, attr); |
| - | for (i = 0; i < height; i++) { |
| - | wmove (win, i, 0); |
| - | for (j = 0; j < width; j++) |
| - | waddch (win, ' '); |
| - | } |
| - | touchwin (win); |
| - | } |
| - | |
| - | void dialog_clear (void) |
| - | { |
| - | attr_clear (stdscr, LINES, COLS, screen_attr); |
| - | /* Display background title if it exists ... - SLH */ |
| - | if (backtitle != NULL) { |
| - | int i; |
| - | |
| - | wattrset (stdscr, screen_attr); |
| - | mvwaddstr (stdscr, 0, 1, (char *)backtitle); |
| - | wmove (stdscr, 1, 1); |
| - | for (i = 1; i < COLS - 1; i++) |
| - | waddch (stdscr, ACS_HLINE); |
| - | } |
| - | wnoutrefresh (stdscr); |
| - | } |
| - | |
| - | /* |
| - | * Do some initialization for dialog |
| - | */ |
| - | void |
| - | init_dialog (void) |
| - | { |
| - | initscr (); /* Init curses */ |
| - | keypad (stdscr, TRUE); |
| - | cbreak (); |
| - | noecho (); |
| - | |
| - | |
| - | if (use_colors) /* Set up colors */ |
| - | color_setup (); |
| - | |
| - | |
| - | dialog_clear (); |
| - | } |
| - | |
| - | /* |
| - | * Setup for color display |
| - | */ |
| - | void |
| - | color_setup (void) |
| - | { |
| - | int i; |
| - | |
| - | if (has_colors ()) { /* Terminal supports color? */ |
| - | start_color (); |
| - | |
| - | /* Initialize color pairs */ |
| - | for (i = 0; i < ATTRIBUTE_COUNT; i++) |
| - | init_pair (i + 1, color_table[i][0], color_table[i][1]); |
| - | |
| - | /* Setup color attributes */ |
| - | for (i = 0; i < ATTRIBUTE_COUNT; i++) |
| - | attributes[i] = C_ATTR (color_table[i][2], i + 1); |
| - | } |
| - | } |
| - | |
| - | /* |
| - | * End using dialog functions. |
| - | */ |
| - | void |
| - | end_dialog (void) |
| - | { |
| - | endwin (); |
| - | } |
| - | |
| - | |
| - | /* |
| - | * Print a string of text in a window, automatically wrap around to the |
| - | * next line if the string is too long to fit on one line. Newline |
| - | * characters '\n' are replaced by spaces. We start on a new line |
| - | * if there is no room for at least 4 nonblanks following a double-space. |
| - | */ |
| - | void |
| - | print_autowrap (WINDOW * win, const char *prompt, int width, int y, int x) |
| - | { |
| - | int newl, cur_x, cur_y; |
| - | int i, prompt_len, room, wlen; |
| - | char tempstr[MAX_LEN + 1], *word, *sp, *sp2; |
| - | |
| - | strcpy (tempstr, prompt); |
| - | |
| - | prompt_len = strlen(tempstr); |
| - | |
| - | /* |
| - | * Remove newlines |
| - | */ |
| - | for(i=0; i<prompt_len; i++) { |
| - | if(tempstr[i] == '\n') tempstr[i] = ' '; |
| - | } |
| - | |
| - | if (prompt_len <= width - x * 2) { /* If prompt is short */ |
| - | wmove (win, y, (width - prompt_len) / 2); |
| - | waddstr (win, tempstr); |
| - | } else { |
| - | cur_x = x; |
| - | cur_y = y; |
| - | newl = 1; |
| - | word = tempstr; |
| - | while (word && *word) { |
| - | sp = strchr(word, ' '); |
| - | if (sp) |
| - | *sp++ = 0; |
| - | |
| - | /* Wrap to next line if either the word does not fit, |
| - | or it is the first word of a new sentence, and it is |
| - | short, and the next word does not fit. */ |
| - | room = width - cur_x; |
| - | wlen = strlen(word); |
| - | if (wlen > room || |
| - | (newl && wlen < 4 && sp && wlen+1+strlen(sp) > room |
| - | && (!(sp2 = strchr(sp, ' ')) || wlen+1+(sp2-sp) > room))) { |
| - | cur_y++; |
| - | cur_x = x; |
| - | } |
| - | wmove (win, cur_y, cur_x); |
| - | waddstr (win, word); |
| - | getyx (win, cur_y, cur_x); |
| - | cur_x++; |
| - | if (sp && *sp == ' ') { |
| - | cur_x++; /* double space */ |
| - | while (*++sp == ' '); |
| - | newl = 1; |
| - | } else |
| - | newl = 0; |
| - | word = sp; |
| - | } |
| - | } |
| - | } |
| - | |
| - | /* |
| - | * Print a button |
| - | */ |
| - | void |
| - | print_button (WINDOW * win, const char *label, int y, int x, int selected) |
| - | { |
| - | int i, temp; |
| - | |
| - | wmove (win, y, x); |
| - | wattrset (win, selected ? button_active_attr : button_inactive_attr); |
| - | waddstr (win, "<"); |
| - | temp = strspn (label, " "); |
| - | label += temp; |
| - | wattrset (win, selected ? button_label_active_attr |
| - | : button_label_inactive_attr); |
| - | for (i = 0; i < temp; i++) |
| - | waddch (win, ' '); |
| - | wattrset (win, selected ? button_key_active_attr |
| - | : button_key_inactive_attr); |
| - | waddch (win, label[0]); |
| - | wattrset (win, selected ? button_label_active_attr |
| - | : button_label_inactive_attr); |
| - | waddstr (win, (char *)label + 1); |
| - | wattrset (win, selected ? button_active_attr : button_inactive_attr); |
| - | waddstr (win, ">"); |
| - | wmove (win, y, x + temp + 1); |
| - | } |
| - | |
| - | /* |
| - | * Draw a rectangular box with line drawing characters |
| - | */ |
| - | void |
| - | draw_box (WINDOW * win, int y, int x, int height, int width, |
| - | chtype box, chtype border) |
| - | { |
| - | int i, j; |
| - | |
| - | wattrset (win, 0); |
| - | for (i = 0; i < height; i++) { |
| - | wmove (win, y + i, x); |
| - | for (j = 0; j < width; j++) |
| - | if (!i && !j) |
| - | waddch (win, border | ACS_ULCORNER); |
| - | else if (i == height - 1 && !j) |
| - | waddch (win, border | ACS_LLCORNER); |
| - | else if (!i && j == width - 1) |
| - | waddch (win, box | ACS_URCORNER); |
| - | else if (i == height - 1 && j == width - 1) |
| - | waddch (win, box | ACS_LRCORNER); |
| - | else if (!i) |
| - | waddch (win, border | ACS_HLINE); |
| - | else if (i == height - 1) |
| - | waddch (win, box | ACS_HLINE); |
| - | else if (!j) |
| - | waddch (win, border | ACS_VLINE); |
| - | else if (j == width - 1) |
| - | waddch (win, box | ACS_VLINE); |
| - | else |
| - | waddch (win, box | ' '); |
| - | } |
| - | } |
| - | |
| - | /* |
| - | * Draw shadows along the right and bottom edge to give a more 3D look |
| - | * to the boxes |
| - | */ |
| - | void |
| - | draw_shadow (WINDOW * win, int y, int x, int height, int width) |
| - | { |
| - | int i; |
| - | |
| - | if (has_colors ()) { /* Whether terminal supports color? */ |
| - | wattrset (win, shadow_attr); |
| - | wmove (win, y + height, x + 2); |
| - | for (i = 0; i < width; i++) |
| - | waddch (win, winch (win) & A_CHARTEXT); |
| - | for (i = y + 1; i < y + height + 1; i++) { |
| - | wmove (win, i, x + width); |
| - | waddch (win, winch (win) & A_CHARTEXT); |
| - | waddch (win, winch (win) & A_CHARTEXT); |
| - | } |
| - | wnoutrefresh (win); |
| - | } |
| - | } |
| - | |
| - | /* |
| - | * Return the position of the first alphabetic character in a string. |
| - | */ |
| - | int |
| - | first_alpha(const char *string, const char *exempt) |
| - | { |
| - | int i, in_paren=0, c; |
| - | |
| - | for (i = 0; i < strlen(string); i++) { |
| - | c = tolower(string[i]); |
| - | |
| - | if (strchr("<[(", c)) ++in_paren; |
| - | if (strchr(">])", c) && in_paren > 0) --in_paren; |
| - | |
| - | if ((! in_paren) && isalpha(c) && |
| - | strchr(exempt, c) == 0) |
| - | return i; |
| - | } |
| - | |
| - | return 0; |
| - | } |
| - | |
| - | /* |
| - | * Get the first selected item in the dialog_list_item list. |
| - | */ |
| - | struct dialog_list_item * |
| - | first_sel_item(int item_no, struct dialog_list_item ** items) |
| - | { |
| - | int i; |
| - | |
| - | for (i = 0; i < item_no; i++) { |
| - | if (items[i]->selected) |
| - | return items[i]; |
| - | } |
| - | |
| - | return NULL; |
| - | } |
| @@ -1,119 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * yesno.c -- implements the yes/no box |
| - | * |
| - | * ORIGINAL AUTHOR: Savio Lam ([email protected]) |
| - | * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap ([email protected]) |
| - | * |
| - | * 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | */ |
| - | |
| - | #include "dialog.h" |
| - | |
| - | /* |
| - | * Display termination buttons |
| - | */ |
| - | static void |
| - | print_buttons(WINDOW *dialog, int height, int width, int selected) |
| - | { |
| - | int x = width / 2 - 10; |
| - | int y = height - 2; |
| - | |
| - | print_button (dialog, " Yes ", y, x, selected == 0); |
| - | print_button (dialog, " No ", y, x + 13, selected == 1); |
| - | |
| - | wmove(dialog, y, x+1 + 13*selected ); |
| - | wrefresh (dialog); |
| - | } |
| - | |
| - | /* |
| - | * Display a dialog box with two buttons - Yes and No |
| - | */ |
| - | int |
| - | dialog_yesno (const char *title, const char *prompt, int height, int width) |
| - | { |
| - | int i, x, y, key = 0, button = 0; |
| - | WINDOW *dialog; |
| - | |
| - | /* center dialog box on screen */ |
| - | x = (COLS - width) / 2; |
| - | y = (LINES - height) / 2; |
| - | |
| - | draw_shadow (stdscr, y, x, height, width); |
| - | |
| - | dialog = newwin (height, width, y, x); |
| - | keypad (dialog, TRUE); |
| - | |
| - | draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); |
| - | wattrset (dialog, border_attr); |
| - | mvwaddch (dialog, height-3, 0, ACS_LTEE); |
| - | for (i = 0; i < width - 2; i++) |
| - | waddch (dialog, ACS_HLINE); |
| - | wattrset (dialog, dialog_attr); |
| - | waddch (dialog, ACS_RTEE); |
| - | |
| - | if (title != NULL && strlen(title) >= width-2 ) { |
| - | /* truncate long title -- mec */ |
| - | char * title2 = malloc(width-2+1); |
| - | memcpy( title2, title, width-2 ); |
| - | title2[width-2] = '\0'; |
| - | title = title2; |
| - | } |
| - | |
| - | if (title != NULL) { |
| - | wattrset (dialog, title_attr); |
| - | mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); |
| - | waddstr (dialog, (char *)title); |
| - | waddch (dialog, ' '); |
| - | } |
| - | |
| - | wattrset (dialog, dialog_attr); |
| - | print_autowrap (dialog, prompt, width - 2, 1, 3); |
| - | |
| - | print_buttons(dialog, height, width, 0); |
| - | |
| - | while (key != ESC) { |
| - | key = wgetch (dialog); |
| - | switch (key) { |
| - | case 'Y': |
| - | case 'y': |
| - | delwin (dialog); |
| - | return 0; |
| - | case 'N': |
| - | case 'n': |
| - | delwin (dialog); |
| - | return 1; |
| - | |
| - | case TAB: |
| - | case KEY_LEFT: |
| - | case KEY_RIGHT: |
| - | button = ((key == KEY_LEFT ? --button : ++button) < 0) |
| - | ? 1 : (button > 1 ? 0 : button); |
| - | |
| - | print_buttons(dialog, height, width, button); |
| - | wrefresh (dialog); |
| - | break; |
| - | case ' ': |
| - | case '\n': |
| - | delwin (dialog); |
| - | return button; |
| - | case ESC: |
| - | break; |
| - | } |
| - | } |
| - | |
| - | delwin (dialog); |
| - | return -1; /* ESC pressed */ |
| - | } |
| @@ -1,976 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | * |
| - | * Introduced single menu mode (show all sub-menus in one large tree). |
| - | * 2002-11-06 Petr Baudis <[email protected]> |
| - | * |
| - | * Directly use liblxdialog library routines. |
| - | * 2002-11-14 Petr Baudis <[email protected]> |
| - | */ |
| - | |
| - | #include <sys/ioctl.h> |
| - | #include <sys/wait.h> |
| - | #include <ctype.h> |
| - | #include <errno.h> |
| - | #include <fcntl.h> |
| - | #include <limits.h> |
| - | #include <signal.h> |
| - | #include <stdarg.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <termios.h> |
| - | #include <unistd.h> |
| - | |
| - | #include "lxdialog/dialog.h" |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | static char menu_backtitle[128]; |
| - | static const char mconf_readme[] = |
| - | "Overview\n" |
| - | "--------\n" |
| - | "Some features may be built directly into BusyBox. Some features\n" |
| - | "may be completely removed altogether. There are also certain\n" |
| - | "parameters which are not really features, but must be\n" |
| - | "entered in as decimal or hexadecimal numbers or possibly text.\n" |
| - | "\n" |
| - | "Menu items beginning with [*] or [ ] represent features\n" |
| - | "configured to be built in or removed respectively.\n" |
| - | "\n" |
| - | "To change any of these features, highlight it with the cursor\n" |
| - | "keys and press <Y> to build it in or <N> to removed it.\n" |
| - | "You may also press the <Space Bar> to cycle\n" |
| - | "through the available options (ie. Y->N->Y).\n" |
| - | "\n" |
| - | "Some additional keyboard hints:\n" |
| - | "\n" |
| - | "Menus\n" |
| - | "----------\n" |
| - | "o Use the Up/Down arrow keys (cursor keys) to highlight the item\n" |
| - | " you wish to change or submenu wish to select and press <Enter>.\n" |
| - | " Submenus are designated by \"--->\".\n" |
| - | "\n" |
| - | " Shortcut: Press the option's highlighted letter (hotkey).\n" |
| - | " Pressing a hotkey more than once will sequence\n" |
| - | " through all visible items which use that hotkey.\n" |
| - | "\n" |
| - | " You may also use the <PAGE UP> and <PAGE DOWN> keys to scroll\n" |
| - | " unseen options into view.\n" |
| - | "\n" |
| - | "o To exit a menu use the cursor keys to highlight the <Exit> button\n" |
| - | " and press <ENTER>.\n" |
| - | "\n" |
| - | " Shortcut: Press <ESC><ESC> or <E> or <X> if there is no hotkey\n" |
| - | " using those letters. You may press a single <ESC>, but\n" |
| - | " there is a delayed response which you may find annoying.\n" |
| - | "\n" |
| - | " Also, the <TAB> and cursor keys will cycle between <Select>,\n" |
| - | " <Exit> and <Help>\n" |
| - | "\n" |
| - | "o To get help with an item, use the cursor keys to highlight <Help>\n" |
| - | " and Press <ENTER>.\n" |
| - | "\n" |
| - | " Shortcut: Press <H> or <?>.\n" |
| - | "\n" |
| - | "\n" |
| - | "Radiolists (Choice lists)\n" |
| - | "-----------\n" |
| - | "o Use the cursor keys to select the option you wish to set and press\n" |
| - | " <S> or the <SPACE BAR>.\n" |
| - | "\n" |
| - | " Shortcut: Press the first letter of the option you wish to set then\n" |
| - | " press <S> or <SPACE BAR>.\n" |
| - | "\n" |
| - | "o To see available help for the item, use the cursor keys to highlight\n" |
| - | " <Help> and Press <ENTER>.\n" |
| - | "\n" |
| - | " Shortcut: Press <H> or <?>.\n" |
| - | "\n" |
| - | " Also, the <TAB> and cursor keys will cycle between <Select> and\n" |
| - | " <Help>\n" |
| - | "\n" |
| - | "\n" |
| - | "Data Entry\n" |
| - | "-----------\n" |
| - | "o Enter the requested information and press <ENTER>\n" |
| - | " If you are entering hexadecimal values, it is not necessary to\n" |
| - | " add the '0x' prefix to the entry.\n" |
| - | "\n" |
| - | "o For help, use the <TAB> or cursor keys to highlight the help option\n" |
| - | " and press <ENTER>. You can try <TAB><H> as well.\n" |
| - | "\n" |
| - | "\n" |
| - | "Text Box (Help Window)\n" |
| - | "--------\n" |
| - | "o Use the cursor keys to scroll up/down/left/right. The VI editor\n" |
| - | " keys h,j,k,l function here as do <SPACE BAR> and <B> for those\n" |
| - | " who are familiar with less and lynx.\n" |
| - | "\n" |
| - | "o Press <E>, <X>, <Enter> or <Esc><Esc> to exit.\n" |
| - | "\n" |
| - | "\n" |
| - | "Alternate Configuration Files\n" |
| - | "-----------------------------\n" |
| - | "Menuconfig supports the use of alternate configuration files for\n" |
| - | "those who, for various reasons, find it necessary to switch\n" |
| - | "between different configurations.\n" |
| - | "\n" |
| - | "At the end of the main menu you will find two options. One is\n" |
| - | "for saving the current configuration to a file of your choosing.\n" |
| - | "The other option is for loading a previously saved alternate\n" |
| - | "configuration.\n" |
| - | "\n" |
| - | "Even if you don't use alternate configuration files, but you\n" |
| - | "find during a Menuconfig session that you have completely messed\n" |
| - | "up your settings, you may use the \"Load Alternate...\" option to\n" |
| - | "restore your previously saved settings from \".config\" without\n" |
| - | "restarting Menuconfig.\n" |
| - | "\n" |
| - | "Other information\n" |
| - | "-----------------\n" |
| - | "If you use Menuconfig in an XTERM window make sure you have your\n" |
| - | "$TERM variable set to point to a xterm definition which supports color.\n" |
| - | "Otherwise, Menuconfig will look rather bad. Menuconfig will not\n" |
| - | "display correctly in a RXVT window because rxvt displays only one\n" |
| - | "intensity of color, bright.\n" |
| - | "\n" |
| - | "Menuconfig will display larger menus on screens or xterms which are\n" |
| - | "set to display more than the standard 25 row by 80 column geometry.\n" |
| - | "In order for this to work, the \"stty size\" command must be able to\n" |
| - | "display the screen's current row and column geometry. I STRONGLY\n" |
| - | "RECOMMEND that you make sure you do NOT have the shell variables\n" |
| - | "LINES and COLUMNS exported into your environment. Some distributions\n" |
| - | "export those variables via /etc/profile. Some ncurses programs can\n" |
| - | "become confused when those variables (LINES & COLUMNS) don't reflect\n" |
| - | "the true screen size.\n" |
| - | "\n" |
| - | "Optional personality available\n" |
| - | "------------------------------\n" |
| - | "If you prefer to have all of the options listed in a single\n" |
| - | "menu, rather than the default multimenu hierarchy, run the menuconfig\n" |
| - | "with MENUCONFIG_MODE environment variable set to single_menu. Example:\n" |
| - | "\n" |
| - | "make MENUCONFIG_MODE=single_menu menuconfig\n" |
| - | "\n" |
| - | "<Enter> will then unroll the appropriate category, or enfold it if it\n" |
| - | "is already unrolled.\n" |
| - | "\n" |
| - | "Note that this mode can eventually be a little more CPU expensive\n" |
| - | "(especially with a larger number of unrolled categories) than the\n" |
| - | "default mode.\n", |
| - | menu_instructions[] = |
| - | "Arrow keys navigate the menu. " |
| - | "<Enter> selects submenus --->. " |
| - | "Highlighted letters are hotkeys. " |
| - | "Pressing <Y> selectes a feature, while <N> will exclude a feature. " |
| - | "Press <Esc><Esc> to exit, <?> for Help, </> for Search. " |
| - | "Legend: [*] feature is selected [ ] feature is excluded", |
| - | radiolist_instructions[] = |
| - | "Use the arrow keys to navigate this window or " |
| - | "press the hotkey of the item you wish to select " |
| - | "followed by the <SPACE BAR>. " |
| - | "Press <?> for additional information about this option.", |
| - | inputbox_instructions_int[] = |
| - | "Please enter a decimal value. " |
| - | "Fractions will not be accepted. " |
| - | "Use the <TAB> key to move from the input field to the buttons below it.", |
| - | inputbox_instructions_hex[] = |
| - | "Please enter a hexadecimal value. " |
| - | "Use the <TAB> key to move from the input field to the buttons below it.", |
| - | inputbox_instructions_string[] = |
| - | "Please enter a string value. " |
| - | "Use the <TAB> key to move from the input field to the buttons below it.", |
| - | setmod_text[] = |
| - | "This feature depends on another which has been configured as a module.\n" |
| - | "As a result, this feature will be built as a module.", |
| - | nohelp_text[] = |
| - | "There is no help available for this option.\n", |
| - | load_config_text[] = |
| - | "Enter the name of the configuration file you wish to load. " |
| - | "Accept the name shown to restore the configuration you " |
| - | "last retrieved. Leave blank to abort.", |
| - | load_config_help[] = |
| - | "\n" |
| - | "For various reasons, one may wish to keep several different BusyBox\n" |
| - | "configurations available on a single machine.\n" |
| - | "\n" |
| - | "If you have saved a previous configuration in a file other than the\n" |
| - | "BusyBox's default, entering the name of the file here will allow you\n" |
| - | "to modify that configuration.\n" |
| - | "\n" |
| - | "If you are uncertain, then you have probably never used alternate\n" |
| - | "configuration files. You should therefor leave this blank to abort.\n", |
| - | save_config_text[] = |
| - | "Enter a filename to which this configuration should be saved " |
| - | "as an alternate. Leave blank to abort.", |
| - | save_config_help[] = |
| - | "\n" |
| - | "For various reasons, one may wish to keep different BusyBox\n" |
| - | "configurations available on a single machine.\n" |
| - | "\n" |
| - | "Entering a file name here will allow you to later retrieve, modify\n" |
| - | "and use the current configuration as an alternate to whatever\n" |
| - | "configuration options you have selected at that time.\n" |
| - | "\n" |
| - | "If you are uncertain what all this means then you should probably\n" |
| - | "leave this blank.\n", |
| - | search_help[] = |
| - | "\n" |
| - | "Search for CONFIG_ symbols and display their relations.\n" |
| - | "Example: search for \"^FOO\"\n" |
| - | "Result:\n" |
| - | "-----------------------------------------------------------------\n" |
| - | "Symbol: FOO [=m]\n" |
| - | "Prompt: Foo bus is used to drive the bar HW\n" |
| - | "Defined at drivers/pci/Kconfig:47\n" |
| - | "Depends on: X86_LOCAL_APIC && X86_IO_APIC || IA64\n" |
| - | "Location:\n" |
| - | " -> Bus options (PCI, PCMCIA, EISA, MCA, ISA)\n" |
| - | " -> PCI support (PCI [=y])\n" |
| - | " -> PCI access mode (<choice> [=y])\n" |
| - | "Selects: LIBCRC32\n" |
| - | "Selected by: BAR\n" |
| - | "-----------------------------------------------------------------\n" |
| - | "o The line 'Prompt:' shows the text used in the menu structure for\n" |
| - | " this CONFIG_ symbol\n" |
| - | "o The 'Defined at' line tell at what file / line number the symbol\n" |
| - | " is defined\n" |
| - | "o The 'Depends on:' line tell what symbols needs to be defined for\n" |
| - | " this symbol to be visible in the menu (selectable)\n" |
| - | "o The 'Location:' lines tell where in the menu structure this symbol\n" |
| - | " is located\n" |
| - | " A location followed by a [=y] indicate that this is a selectable\n" |
| - | " menu item - and current value is displayed inside brackets.\n" |
| - | "o The 'Selects:' line tell what symbol will be automatically\n" |
| - | " selected if this symbol is selected (y or m)\n" |
| - | "o The 'Selected by' line tell what symbol has selected this symbol\n" |
| - | "\n" |
| - | "Only relevant lines are shown.\n" |
| - | "\n\n" |
| - | "Search examples:\n" |
| - | "Examples: USB => find all CONFIG_ symbols containing USB\n" |
| - | " ^USB => find all CONFIG_ symbols starting with USB\n" |
| - | " USB$ => find all CONFIG_ symbols ending with USB\n" |
| - | "\n"; |
| - | |
| - | static char filename[PATH_MAX+1] = ".config"; |
| - | static int indent; |
| - | static struct termios ios_org; |
| - | static int rows = 0, cols = 0; |
| - | static struct menu *current_menu; |
| - | static int child_count; |
| - | static int single_menu_mode; |
| - | |
| - | static struct dialog_list_item *items[16384]; /* FIXME: This ought to be dynamic. */ |
| - | static int item_no; |
| - | |
| - | static void conf(struct menu *menu); |
| - | static void conf_choice(struct menu *menu); |
| - | static void conf_string(struct menu *menu); |
| - | static void conf_load(void); |
| - | static void conf_save(void); |
| - | static void show_textbox(const char *title, const char *text, int r, int c); |
| - | static void show_helptext(const char *title, const char *text); |
| - | static void show_help(struct menu *menu); |
| - | static void show_file(const char *filename, const char *title, int r, int c); |
| - | |
| - | static void init_wsize(void) |
| - | { |
| - | struct winsize ws; |
| - | char *env; |
| - | |
| - | if (!ioctl(STDIN_FILENO, TIOCGWINSZ, &ws)) { |
| - | rows = ws.ws_row; |
| - | cols = ws.ws_col; |
| - | } |
| - | |
| - | if (!rows) { |
| - | env = getenv("LINES"); |
| - | if (env) |
| - | rows = atoi(env); |
| - | if (!rows) |
| - | rows = 24; |
| - | } |
| - | if (!cols) { |
| - | env = getenv("COLUMNS"); |
| - | if (env) |
| - | cols = atoi(env); |
| - | if (!cols) |
| - | cols = 80; |
| - | } |
| - | |
| - | if (rows < 19 || cols < 80) { |
| - | fprintf(stderr, "Your display is too small to run Menuconfig!\n"); |
| - | fprintf(stderr, "It must be at least 19 lines by 80 columns.\n"); |
| - | exit(1); |
| - | } |
| - | |
| - | rows -= 4; |
| - | cols -= 5; |
| - | } |
| - | |
| - | static void cinit(void) |
| - | { |
| - | item_no = 0; |
| - | } |
| - | |
| - | static void cmake(void) |
| - | { |
| - | items[item_no] = malloc(sizeof(struct dialog_list_item)); |
| - | memset(items[item_no], 0, sizeof(struct dialog_list_item)); |
| - | items[item_no]->tag = malloc(32); items[item_no]->tag[0] = 0; |
| - | items[item_no]->name = malloc(512); items[item_no]->name[0] = 0; |
| - | items[item_no]->namelen = 0; |
| - | item_no++; |
| - | } |
| - | |
| - | static int cprint_name(const char *fmt, ...) |
| - | { |
| - | va_list ap; |
| - | int res; |
| - | |
| - | if (!item_no) |
| - | cmake(); |
| - | va_start(ap, fmt); |
| - | res = vsnprintf(items[item_no - 1]->name + items[item_no - 1]->namelen, |
| - | 512 - items[item_no - 1]->namelen, fmt, ap); |
| - | if (res > 0) |
| - | items[item_no - 1]->namelen += res; |
| - | va_end(ap); |
| - | |
| - | return res; |
| - | } |
| - | |
| - | static int cprint_tag(const char *fmt, ...) |
| - | { |
| - | va_list ap; |
| - | int res; |
| - | |
| - | if (!item_no) |
| - | cmake(); |
| - | va_start(ap, fmt); |
| - | res = vsnprintf(items[item_no - 1]->tag, 32, fmt, ap); |
| - | va_end(ap); |
| - | |
| - | return res; |
| - | } |
| - | |
| - | static void cdone(void) |
| - | { |
| - | int i; |
| - | |
| - | for (i = 0; i < item_no; i++) { |
| - | free(items[i]->tag); |
| - | free(items[i]->name); |
| - | free(items[i]); |
| - | } |
| - | |
| - | item_no = 0; |
| - | } |
| - | |
| - | static void get_prompt_str(struct gstr *r, struct property *prop) |
| - | { |
| - | int i, j; |
| - | struct menu *submenu[8], *menu; |
| - | |
| - | str_printf(r, "Prompt: %s\n", prop->text); |
| - | str_printf(r, " Defined at %s:%d\n", prop->menu->file->name, |
| - | prop->menu->lineno); |
| - | if (!expr_is_yes(prop->visible.expr)) { |
| - | str_append(r, " Depends on: "); |
| - | expr_gstr_print(prop->visible.expr, r); |
| - | str_append(r, "\n"); |
| - | } |
| - | menu = prop->menu->parent; |
| - | for (i = 0; menu != &rootmenu && i < 8; menu = menu->parent) |
| - | submenu[i++] = menu; |
| - | if (i > 0) { |
| - | str_printf(r, " Location:\n"); |
| - | for (j = 4; --i >= 0; j += 2) { |
| - | menu = submenu[i]; |
| - | str_printf(r, "%*c-> %s", j, ' ', menu_get_prompt(menu)); |
| - | if (menu->sym) { |
| - | str_printf(r, " (%s [=%s])", menu->sym->name ? |
| - | menu->sym->name : "<choice>", |
| - | sym_get_string_value(menu->sym)); |
| - | } |
| - | str_append(r, "\n"); |
| - | } |
| - | } |
| - | } |
| - | |
| - | static void get_symbol_str(struct gstr *r, struct symbol *sym) |
| - | { |
| - | bool hit; |
| - | struct property *prop; |
| - | |
| - | str_printf(r, "Symbol: %s [=%s]\n", sym->name, |
| - | sym_get_string_value(sym)); |
| - | for_all_prompts(sym, prop) |
| - | get_prompt_str(r, prop); |
| - | hit = false; |
| - | for_all_properties(sym, prop, P_SELECT) { |
| - | if (!hit) { |
| - | str_append(r, " Selects: "); |
| - | hit = true; |
| - | } else |
| - | str_printf(r, " && "); |
| - | expr_gstr_print(prop->expr, r); |
| - | } |
| - | if (hit) |
| - | str_append(r, "\n"); |
| - | if (sym->rev_dep.expr) { |
| - | str_append(r, " Selected by: "); |
| - | expr_gstr_print(sym->rev_dep.expr, r); |
| - | str_append(r, "\n"); |
| - | } |
| - | str_append(r, "\n\n"); |
| - | } |
| - | |
| - | static struct gstr get_relations_str(struct symbol **sym_arr) |
| - | { |
| - | struct symbol *sym; |
| - | struct gstr res = str_new(); |
| - | int i; |
| - | |
| - | for (i = 0; sym_arr && (sym = sym_arr[i]); i++) |
| - | get_symbol_str(&res, sym); |
| - | if (!i) |
| - | str_append(&res, "No matches found.\n"); |
| - | return res; |
| - | } |
| - | |
| - | static void search_conf(void) |
| - | { |
| - | struct symbol **sym_arr; |
| - | struct gstr res; |
| - | |
| - | again: |
| - | switch (dialog_inputbox("Search Configuration Parameter", |
| - | "Enter Keyword", 10, 75, |
| - | NULL)) { |
| - | case 0: |
| - | break; |
| - | case 1: |
| - | show_helptext("Search Configuration", search_help); |
| - | goto again; |
| - | default: |
| - | return; |
| - | } |
| - | |
| - | sym_arr = sym_re_search(dialog_input_result); |
| - | res = get_relations_str(sym_arr); |
| - | free(sym_arr); |
| - | show_textbox("Search Results", str_get(&res), 0, 0); |
| - | str_free(&res); |
| - | } |
| - | |
| - | static void build_conf(struct menu *menu) |
| - | { |
| - | struct symbol *sym; |
| - | struct property *prop; |
| - | struct menu *child; |
| - | int type, tmp, doint = 2; |
| - | tristate val; |
| - | char ch; |
| - | |
| - | if (!menu_is_visible(menu)) |
| - | return; |
| - | |
| - | sym = menu->sym; |
| - | prop = menu->prompt; |
| - | if (!sym) { |
| - | if (prop && menu != current_menu) { |
| - | const char *prompt = menu_get_prompt(menu); |
| - | switch (prop->type) { |
| - | case P_MENU: |
| - | child_count++; |
| - | cmake(); |
| - | cprint_tag("m%p", menu); |
| - | |
| - | if (single_menu_mode) { |
| - | cprint_name("%s%*c%s", |
| - | menu->data ? "-->" : "++>", |
| - | indent + 1, ' ', prompt); |
| - | } else { |
| - | cprint_name(" %*c%s --->", indent + 1, ' ', prompt); |
| - | } |
| - | |
| - | if (single_menu_mode && menu->data) |
| - | goto conf_childs; |
| - | return; |
| - | default: |
| - | if (prompt) { |
| - | child_count++; |
| - | cmake(); |
| - | cprint_tag(":%p", menu); |
| - | cprint_name("---%*c%s", indent + 1, ' ', prompt); |
| - | } |
| - | } |
| - | } else |
| - | doint = 0; |
| - | goto conf_childs; |
| - | } |
| - | |
| - | cmake(); |
| - | type = sym_get_type(sym); |
| - | if (sym_is_choice(sym)) { |
| - | struct symbol *def_sym = sym_get_choice_value(sym); |
| - | struct menu *def_menu = NULL; |
| - | |
| - | child_count++; |
| - | for (child = menu->list; child; child = child->next) { |
| - | if (menu_is_visible(child) && child->sym == def_sym) |
| - | def_menu = child; |
| - | } |
| - | |
| - | val = sym_get_tristate_value(sym); |
| - | if (sym_is_changable(sym)) { |
| - | cprint_tag("t%p", menu); |
| - | switch (type) { |
| - | case S_BOOLEAN: |
| - | cprint_name("[%c]", val == no ? ' ' : '*'); |
| - | break; |
| - | case S_TRISTATE: |
| - | switch (val) { |
| - | case yes: ch = '*'; break; |
| - | case mod: ch = 'M'; break; |
| - | default: ch = ' '; break; |
| - | } |
| - | cprint_name("<%c>", ch); |
| - | break; |
| - | } |
| - | } else { |
| - | cprint_tag("%c%p", def_menu ? 't' : ':', menu); |
| - | cprint_name(" "); |
| - | } |
| - | |
| - | cprint_name("%*c%s", indent + 1, ' ', menu_get_prompt(menu)); |
| - | if (val == yes) { |
| - | if (def_menu) { |
| - | cprint_name(" (%s)", menu_get_prompt(def_menu)); |
| - | cprint_name(" --->"); |
| - | if (def_menu->list) { |
| - | indent += 2; |
| - | build_conf(def_menu); |
| - | indent -= 2; |
| - | } |
| - | } |
| - | return; |
| - | } |
| - | } else { |
| - | if (menu == current_menu) { |
| - | cprint_tag(":%p", menu); |
| - | cprint_name("---%*c%s", indent + 1, ' ', menu_get_prompt(menu)); |
| - | goto conf_childs; |
| - | } |
| - | child_count++; |
| - | val = sym_get_tristate_value(sym); |
| - | if (sym_is_choice_value(sym) && val == yes) { |
| - | cprint_tag(":%p", menu); |
| - | cprint_name(" "); |
| - | } else { |
| - | switch (type) { |
| - | case S_BOOLEAN: |
| - | cprint_tag("t%p", menu); |
| - | if (sym_is_changable(sym)) |
| - | cprint_name("[%c]", val == no ? ' ' : '*'); |
| - | else |
| - | cprint_name("---"); |
| - | break; |
| - | case S_TRISTATE: |
| - | cprint_tag("t%p", menu); |
| - | switch (val) { |
| - | case yes: ch = '*'; break; |
| - | case mod: ch = 'M'; break; |
| - | default: ch = ' '; break; |
| - | } |
| - | if (sym_is_changable(sym)) |
| - | cprint_name("<%c>", ch); |
| - | else |
| - | cprint_name("---"); |
| - | break; |
| - | default: |
| - | cprint_tag("s%p", menu); |
| - | tmp = cprint_name("(%s)", sym_get_string_value(sym)); |
| - | tmp = indent - tmp + 4; |
| - | if (tmp < 0) |
| - | tmp = 0; |
| - | cprint_name("%*c%s%s", tmp, ' ', menu_get_prompt(menu), |
| - | (sym_has_value(sym) || !sym_is_changable(sym)) ? |
| - | "" : " (NEW)"); |
| - | goto conf_childs; |
| - | } |
| - | } |
| - | cprint_name("%*c%s%s", indent + 1, ' ', menu_get_prompt(menu), |
| - | (sym_has_value(sym) || !sym_is_changable(sym)) ? |
| - | "" : " (NEW)"); |
| - | if (menu->prompt->type == P_MENU) { |
| - | cprint_name(" --->"); |
| - | return; |
| - | } |
| - | } |
| - | |
| - | conf_childs: |
| - | indent += doint; |
| - | for (child = menu->list; child; child = child->next) |
| - | build_conf(child); |
| - | indent -= doint; |
| - | } |
| - | |
| - | static void conf(struct menu *menu) |
| - | { |
| - | struct dialog_list_item *active_item = NULL; |
| - | struct menu *submenu; |
| - | const char *prompt = menu_get_prompt(menu); |
| - | struct symbol *sym; |
| - | char active_entry[40]; |
| - | int stat, type; |
| - | |
| - | unlink("lxdialog.scrltmp"); |
| - | active_entry[0] = 0; |
| - | while (1) { |
| - | indent = 0; |
| - | child_count = 0; |
| - | current_menu = menu; |
| - | cdone(); cinit(); |
| - | build_conf(menu); |
| - | if (!child_count) |
| - | break; |
| - | if (menu == &rootmenu) { |
| - | cmake(); cprint_tag(":"); cprint_name("--- "); |
| - | cmake(); cprint_tag("L"); cprint_name("Load an Alternate Configuration File"); |
| - | cmake(); cprint_tag("S"); cprint_name("Save Configuration to an Alternate File"); |
| - | } |
| - | dialog_clear(); |
| - | stat = dialog_menu(prompt ? prompt : "Main Menu", |
| - | menu_instructions, rows, cols, rows - 10, |
| - | active_entry, item_no, items); |
| - | if (stat < 0) |
| - | return; |
| - | |
| - | if (stat == 1 || stat == 255) |
| - | break; |
| - | |
| - | active_item = first_sel_item(item_no, items); |
| - | if (!active_item) |
| - | continue; |
| - | active_item->selected = 0; |
| - | strncpy(active_entry, active_item->tag, sizeof(active_entry)); |
| - | active_entry[sizeof(active_entry)-1] = 0; |
| - | type = active_entry[0]; |
| - | if (!type) |
| - | continue; |
| - | |
| - | sym = NULL; |
| - | submenu = NULL; |
| - | if (sscanf(active_entry + 1, "%p", &submenu) == 1) |
| - | sym = submenu->sym; |
| - | |
| - | switch (stat) { |
| - | case 0: |
| - | switch (type) { |
| - | case 'm': |
| - | if (single_menu_mode) |
| - | submenu->data = (void *) (long) !submenu->data; |
| - | else |
| - | conf(submenu); |
| - | break; |
| - | case 't': |
| - | if (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes) |
| - | conf_choice(submenu); |
| - | else if (submenu->prompt->type == P_MENU) |
| - | conf(submenu); |
| - | break; |
| - | case 's': |
| - | conf_string(submenu); |
| - | break; |
| - | case 'L': |
| - | conf_load(); |
| - | break; |
| - | case 'S': |
| - | conf_save(); |
| - | break; |
| - | } |
| - | break; |
| - | case 2: |
| - | if (sym) |
| - | show_help(submenu); |
| - | else |
| - | show_helptext("README", mconf_readme); |
| - | break; |
| - | case 3: |
| - | if (type == 't') { |
| - | if (sym_set_tristate_value(sym, yes)) |
| - | break; |
| - | if (sym_set_tristate_value(sym, mod)) |
| - | show_textbox(NULL, setmod_text, 6, 74); |
| - | } |
| - | break; |
| - | case 4: |
| - | if (type == 't') |
| - | sym_set_tristate_value(sym, no); |
| - | break; |
| - | case 5: |
| - | if (type == 't') |
| - | sym_set_tristate_value(sym, mod); |
| - | break; |
| - | case 6: |
| - | if (type == 't') |
| - | sym_toggle_tristate_value(sym); |
| - | else if (type == 'm') |
| - | conf(submenu); |
| - | break; |
| - | case 7: |
| - | search_conf(); |
| - | break; |
| - | } |
| - | } |
| - | } |
| - | |
| - | static void show_textbox(const char *title, const char *text, int r, int c) |
| - | { |
| - | int fd; |
| - | |
| - | fd = creat(".help.tmp", 0777); |
| - | write(fd, text, strlen(text)); |
| - | close(fd); |
| - | show_file(".help.tmp", title, r, c); |
| - | unlink(".help.tmp"); |
| - | } |
| - | |
| - | static void show_helptext(const char *title, const char *text) |
| - | { |
| - | show_textbox(title, text, 0, 0); |
| - | } |
| - | |
| - | static void show_help(struct menu *menu) |
| - | { |
| - | struct gstr help = str_new(); |
| - | struct symbol *sym = menu->sym; |
| - | |
| - | if (sym->help) |
| - | { |
| - | if (sym->name) { |
| - | str_printf(&help, "%s:\n\n", sym->name); |
| - | str_append(&help, sym->help); |
| - | str_append(&help, "\n"); |
| - | } |
| - | } else { |
| - | str_append(&help, nohelp_text); |
| - | } |
| - | get_symbol_str(&help, sym); |
| - | show_helptext(menu_get_prompt(menu), str_get(&help)); |
| - | str_free(&help); |
| - | } |
| - | |
| - | static void show_file(const char *filename, const char *title, int r, int c) |
| - | { |
| - | while (dialog_textbox(title, filename, r ? r : rows, c ? c : cols) < 0) |
| - | ; |
| - | } |
| - | |
| - | static void conf_choice(struct menu *menu) |
| - | { |
| - | const char *prompt = menu_get_prompt(menu); |
| - | struct menu *child; |
| - | struct symbol *active; |
| - | |
| - | active = sym_get_choice_value(menu->sym); |
| - | while (1) { |
| - | current_menu = menu; |
| - | cdone(); cinit(); |
| - | for (child = menu->list; child; child = child->next) { |
| - | if (!menu_is_visible(child)) |
| - | continue; |
| - | cmake(); |
| - | cprint_tag("%p", child); |
| - | cprint_name("%s", menu_get_prompt(child)); |
| - | if (child->sym == sym_get_choice_value(menu->sym)) |
| - | items[item_no - 1]->selected = 1; /* ON */ |
| - | else if (child->sym == active) |
| - | items[item_no - 1]->selected = 2; /* SELECTED */ |
| - | else |
| - | items[item_no - 1]->selected = 0; /* OFF */ |
| - | } |
| - | |
| - | switch (dialog_checklist(prompt ? prompt : "Main Menu", |
| - | radiolist_instructions, 15, 70, 6, |
| - | item_no, items, FLAG_RADIO)) { |
| - | case 0: |
| - | if (sscanf(first_sel_item(item_no, items)->tag, "%p", &child) != 1) |
| - | break; |
| - | sym_set_tristate_value(child->sym, yes); |
| - | return; |
| - | case 1: |
| - | if (sscanf(first_sel_item(item_no, items)->tag, "%p", &child) == 1) { |
| - | show_help(child); |
| - | active = child->sym; |
| - | } else |
| - | show_help(menu); |
| - | break; |
| - | case 255: |
| - | return; |
| - | } |
| - | } |
| - | } |
| - | |
| - | static void conf_string(struct menu *menu) |
| - | { |
| - | const char *prompt = menu_get_prompt(menu); |
| - | |
| - | while (1) { |
| - | char *heading; |
| - | |
| - | switch (sym_get_type(menu->sym)) { |
| - | case S_INT: |
| - | heading = (char *) inputbox_instructions_int; |
| - | break; |
| - | case S_HEX: |
| - | heading = (char *) inputbox_instructions_hex; |
| - | break; |
| - | case S_STRING: |
| - | heading = (char *) inputbox_instructions_string; |
| - | break; |
| - | default: |
| - | heading = "Internal mconf error!"; |
| - | /* panic? */; |
| - | } |
| - | |
| - | switch (dialog_inputbox(prompt ? prompt : "Main Menu", |
| - | heading, 10, 75, |
| - | sym_get_string_value(menu->sym))) { |
| - | case 0: |
| - | if (sym_set_string_value(menu->sym, dialog_input_result)) |
| - | return; |
| - | show_textbox(NULL, "You have made an invalid entry.", 5, 43); |
| - | break; |
| - | case 1: |
| - | show_help(menu); |
| - | break; |
| - | case 255: |
| - | return; |
| - | } |
| - | } |
| - | } |
| - | |
| - | static void conf_load(void) |
| - | { |
| - | while (1) { |
| - | switch (dialog_inputbox(NULL, load_config_text, 11, 55, |
| - | filename)) { |
| - | case 0: |
| - | if (!dialog_input_result[0]) |
| - | return; |
| - | if (!conf_read(dialog_input_result)) |
| - | return; |
| - | show_textbox(NULL, "File does not exist!", 5, 38); |
| - | break; |
| - | case 1: |
| - | show_helptext("Load Alternate Configuration", load_config_help); |
| - | break; |
| - | case 255: |
| - | return; |
| - | } |
| - | } |
| - | } |
| - | |
| - | static void conf_save(void) |
| - | { |
| - | while (1) { |
| - | switch (dialog_inputbox(NULL, save_config_text, 11, 55, |
| - | filename)) { |
| - | case 0: |
| - | if (!dialog_input_result[0]) |
| - | return; |
| - | if (!conf_write(dialog_input_result)) |
| - | return; |
| - | show_textbox(NULL, "Can't create file! Probably a nonexistent directory.", 5, 60); |
| - | break; |
| - | case 1: |
| - | show_helptext("Save Alternate Configuration", save_config_help); |
| - | break; |
| - | case 255: |
| - | return; |
| - | } |
| - | } |
| - | } |
| - | |
| - | static void conf_cleanup(void) |
| - | { |
| - | tcsetattr(1, TCSAFLUSH, &ios_org); |
| - | unlink(".help.tmp"); |
| - | } |
| - | |
| - | static void winch_handler(int sig) |
| - | { |
| - | struct winsize ws; |
| - | |
| - | if (ioctl(1, TIOCGWINSZ, &ws) == -1) { |
| - | rows = 24; |
| - | cols = 80; |
| - | } else { |
| - | rows = ws.ws_row; |
| - | cols = ws.ws_col; |
| - | } |
| - | |
| - | if (rows < 19 || cols < 80) { |
| - | end_dialog(); |
| - | fprintf(stderr, "Your display is too small to run Menuconfig!\n"); |
| - | fprintf(stderr, "It must be at least 19 lines by 80 columns.\n"); |
| - | exit(1); |
| - | } |
| - | |
| - | rows -= 4; |
| - | cols -= 5; |
| - | |
| - | } |
| - | |
| - | int main(int ac, char **av) |
| - | { |
| - | struct symbol *sym; |
| - | char *mode; |
| - | int stat; |
| - | |
| - | conf_parse(av[1]); |
| - | conf_read(NULL); |
| - | |
| - | sym = sym_lookup("VERSION", 0); |
| - | sym_calc_value(sym); |
| - | snprintf(menu_backtitle, 128, "BusyBox v%s Configuration", |
| - | sym_get_string_value(sym)); |
| - | |
| - | mode = getenv("MENUCONFIG_MODE"); |
| - | if (mode) { |
| - | if (!strcasecmp(mode, "single_menu")) |
| - | single_menu_mode = 1; |
| - | } |
| - | |
| - | tcgetattr(1, &ios_org); |
| - | atexit(conf_cleanup); |
| - | init_wsize(); |
| - | init_dialog(); |
| - | signal(SIGWINCH, winch_handler); |
| - | conf(&rootmenu); |
| - | end_dialog(); |
| - | |
| - | /* Restart dialog to act more like when lxdialog was still separate */ |
| - | init_dialog(); |
| - | do { |
| - | stat = dialog_yesno(NULL, |
| - | "Do you wish to save your new BusyBox configuration?", 5, 60); |
| - | } while (stat < 0); |
| - | end_dialog(); |
| - | |
| - | if (stat == 0) { |
| - | conf_write(NULL); |
| - | printf("\n" |
| - | "*** End of BusyBox configuration.\n"); |
| - | } else |
| - | printf("\n\nYour BusyBox configuration changes were NOT saved.\n\n"); |
| - | |
| - | return 0; |
| - | } |
| @@ -1,391 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | struct menu rootmenu; |
| - | static struct menu **last_entry_ptr; |
| - | |
| - | struct file *file_list; |
| - | struct file *current_file; |
| - | |
| - | static void menu_warn(struct menu *menu, const char *fmt, ...) |
| - | { |
| - | va_list ap; |
| - | va_start(ap, fmt); |
| - | fprintf(stderr, "%s:%d:warning: ", menu->file->name, menu->lineno); |
| - | vfprintf(stderr, fmt, ap); |
| - | fprintf(stderr, "\n"); |
| - | va_end(ap); |
| - | } |
| - | |
| - | static void prop_warn(struct property *prop, const char *fmt, ...) |
| - | { |
| - | va_list ap; |
| - | va_start(ap, fmt); |
| - | fprintf(stderr, "%s:%d:warning: ", prop->file->name, prop->lineno); |
| - | vfprintf(stderr, fmt, ap); |
| - | fprintf(stderr, "\n"); |
| - | va_end(ap); |
| - | } |
| - | |
| - | void menu_init(void) |
| - | { |
| - | current_entry = current_menu = &rootmenu; |
| - | last_entry_ptr = &rootmenu.list; |
| - | } |
| - | |
| - | void menu_add_entry(struct symbol *sym) |
| - | { |
| - | struct menu *menu; |
| - | |
| - | menu = malloc(sizeof(*menu)); |
| - | memset(menu, 0, sizeof(*menu)); |
| - | menu->sym = sym; |
| - | menu->parent = current_menu; |
| - | menu->file = current_file; |
| - | menu->lineno = zconf_lineno(); |
| - | |
| - | *last_entry_ptr = menu; |
| - | last_entry_ptr = &menu->next; |
| - | current_entry = menu; |
| - | } |
| - | |
| - | void menu_end_entry(void) |
| - | { |
| - | } |
| - | |
| - | void menu_add_menu(void) |
| - | { |
| - | current_menu = current_entry; |
| - | last_entry_ptr = ¤t_entry->list; |
| - | } |
| - | |
| - | void menu_end_menu(void) |
| - | { |
| - | last_entry_ptr = ¤t_menu->next; |
| - | current_menu = current_menu->parent; |
| - | } |
| - | |
| - | struct expr *menu_check_dep(struct expr *e) |
| - | { |
| - | if (!e) |
| - | return e; |
| - | |
| - | switch (e->type) { |
| - | case E_NOT: |
| - | e->left.expr = menu_check_dep(e->left.expr); |
| - | break; |
| - | case E_OR: |
| - | case E_AND: |
| - | e->left.expr = menu_check_dep(e->left.expr); |
| - | e->right.expr = menu_check_dep(e->right.expr); |
| - | break; |
| - | case E_SYMBOL: |
| - | /* change 'm' into 'm' && MODULES */ |
| - | if (e->left.sym == &symbol_mod) |
| - | return expr_alloc_and(e, expr_alloc_symbol(modules_sym)); |
| - | break; |
| - | default: |
| - | break; |
| - | } |
| - | return e; |
| - | } |
| - | |
| - | void menu_add_dep(struct expr *dep) |
| - | { |
| - | current_entry->dep = expr_alloc_and(current_entry->dep, menu_check_dep(dep)); |
| - | } |
| - | |
| - | void menu_set_type(int type) |
| - | { |
| - | struct symbol *sym = current_entry->sym; |
| - | |
| - | if (sym->type == type) |
| - | return; |
| - | if (sym->type == S_UNKNOWN) { |
| - | sym->type = type; |
| - | return; |
| - | } |
| - | menu_warn(current_entry, "type of '%s' redefined from '%s' to '%s'\n", |
| - | sym->name ? sym->name : "<choice>", |
| - | sym_type_name(sym->type), sym_type_name(type)); |
| - | } |
| - | |
| - | struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep) |
| - | { |
| - | struct property *prop = prop_alloc(type, current_entry->sym); |
| - | |
| - | prop->menu = current_entry; |
| - | prop->text = prompt; |
| - | prop->expr = expr; |
| - | prop->visible.expr = menu_check_dep(dep); |
| - | |
| - | if (prompt) { |
| - | if (current_entry->prompt) |
| - | menu_warn(current_entry, "prompt redefined\n"); |
| - | current_entry->prompt = prop; |
| - | } |
| - | |
| - | return prop; |
| - | } |
| - | |
| - | void menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep) |
| - | { |
| - | menu_add_prop(type, prompt, NULL, dep); |
| - | } |
| - | |
| - | void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep) |
| - | { |
| - | menu_add_prop(type, NULL, expr, dep); |
| - | } |
| - | |
| - | void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep) |
| - | { |
| - | menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep); |
| - | } |
| - | |
| - | void sym_check_prop(struct symbol *sym) |
| - | { |
| - | struct property *prop; |
| - | struct symbol *sym2; |
| - | for (prop = sym->prop; prop; prop = prop->next) { |
| - | switch (prop->type) { |
| - | case P_DEFAULT: |
| - | if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) && |
| - | prop->expr->type != E_SYMBOL) |
| - | prop_warn(prop, |
| - | "default for config symbol '%'" |
| - | " must be a single symbol", sym->name); |
| - | break; |
| - | case P_SELECT: |
| - | sym2 = prop_get_symbol(prop); |
| - | if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE) |
| - | prop_warn(prop, |
| - | "config symbol '%s' uses select, but is " |
| - | "not boolean or tristate", sym->name); |
| - | else if (sym2->type == S_UNKNOWN) |
| - | prop_warn(prop, |
| - | "'select' used by config symbol '%s' " |
| - | "refer to undefined symbol '%s'", |
| - | sym->name, sym2->name); |
| - | else if (sym2->type != S_BOOLEAN && sym2->type != S_TRISTATE) |
| - | prop_warn(prop, |
| - | "'%s' has wrong type. 'select' only " |
| - | "accept arguments of boolean and " |
| - | "tristate type", sym2->name); |
| - | break; |
| - | case P_RANGE: |
| - | if (sym->type != S_INT && sym->type != S_HEX) |
| - | prop_warn(prop, "range is only allowed " |
| - | "for int or hex symbols"); |
| - | if (!sym_string_valid(sym, prop->expr->left.sym->name) || |
| - | !sym_string_valid(sym, prop->expr->right.sym->name)) |
| - | prop_warn(prop, "range is invalid"); |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | } |
| - | } |
| - | |
| - | void menu_finalize(struct menu *parent) |
| - | { |
| - | struct menu *menu, *last_menu; |
| - | struct symbol *sym; |
| - | struct property *prop; |
| - | struct expr *parentdep, *basedep, *dep, *dep2, **ep; |
| - | |
| - | sym = parent->sym; |
| - | if (parent->list) { |
| - | if (sym && sym_is_choice(sym)) { |
| - | /* find the first choice value and find out choice type */ |
| - | for (menu = parent->list; menu; menu = menu->next) { |
| - | if (menu->sym) { |
| - | current_entry = parent; |
| - | menu_set_type(menu->sym->type); |
| - | current_entry = menu; |
| - | menu_set_type(sym->type); |
| - | break; |
| - | } |
| - | } |
| - | parentdep = expr_alloc_symbol(sym); |
| - | } else if (parent->prompt) |
| - | parentdep = parent->prompt->visible.expr; |
| - | else |
| - | parentdep = parent->dep; |
| - | |
| - | for (menu = parent->list; menu; menu = menu->next) { |
| - | basedep = expr_transform(menu->dep); |
| - | basedep = expr_alloc_and(expr_copy(parentdep), basedep); |
| - | basedep = expr_eliminate_dups(basedep); |
| - | menu->dep = basedep; |
| - | if (menu->sym) |
| - | prop = menu->sym->prop; |
| - | else |
| - | prop = menu->prompt; |
| - | for (; prop; prop = prop->next) { |
| - | if (prop->menu != menu) |
| - | continue; |
| - | dep = expr_transform(prop->visible.expr); |
| - | dep = expr_alloc_and(expr_copy(basedep), dep); |
| - | dep = expr_eliminate_dups(dep); |
| - | if (menu->sym && menu->sym->type != S_TRISTATE) |
| - | dep = expr_trans_bool(dep); |
| - | prop->visible.expr = dep; |
| - | if (prop->type == P_SELECT) { |
| - | struct symbol *es = prop_get_symbol(prop); |
| - | es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr, |
| - | expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep))); |
| - | } |
| - | } |
| - | } |
| - | for (menu = parent->list; menu; menu = menu->next) |
| - | menu_finalize(menu); |
| - | } else if (sym) { |
| - | basedep = parent->prompt ? parent->prompt->visible.expr : NULL; |
| - | basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no); |
| - | basedep = expr_eliminate_dups(expr_transform(basedep)); |
| - | last_menu = NULL; |
| - | for (menu = parent->next; menu; menu = menu->next) { |
| - | dep = menu->prompt ? menu->prompt->visible.expr : menu->dep; |
| - | if (!expr_contains_symbol(dep, sym)) |
| - | break; |
| - | if (expr_depends_symbol(dep, sym)) |
| - | goto next; |
| - | dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no); |
| - | dep = expr_eliminate_dups(expr_transform(dep)); |
| - | dep2 = expr_copy(basedep); |
| - | expr_eliminate_eq(&dep, &dep2); |
| - | expr_free(dep); |
| - | if (!expr_is_yes(dep2)) { |
| - | expr_free(dep2); |
| - | break; |
| - | } |
| - | expr_free(dep2); |
| - | next: |
| - | menu_finalize(menu); |
| - | menu->parent = parent; |
| - | last_menu = menu; |
| - | } |
| - | if (last_menu) { |
| - | parent->list = parent->next; |
| - | parent->next = last_menu->next; |
| - | last_menu->next = NULL; |
| - | } |
| - | } |
| - | for (menu = parent->list; menu; menu = menu->next) { |
| - | if (sym && sym_is_choice(sym) && menu->sym) { |
| - | menu->sym->flags |= SYMBOL_CHOICEVAL; |
| - | if (!menu->prompt) |
| - | menu_warn(menu, "choice value must have a prompt"); |
| - | for (prop = menu->sym->prop; prop; prop = prop->next) { |
| - | if (prop->type == P_PROMPT && prop->menu != menu) { |
| - | prop_warn(prop, "choice values " |
| - | "currently only support a " |
| - | "single prompt"); |
| - | } |
| - | if (prop->type == P_DEFAULT) |
| - | prop_warn(prop, "defaults for choice " |
| - | "values not supported"); |
| - | } |
| - | current_entry = menu; |
| - | menu_set_type(sym->type); |
| - | menu_add_symbol(P_CHOICE, sym, NULL); |
| - | prop = sym_get_choice_prop(sym); |
| - | for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr) |
| - | ; |
| - | *ep = expr_alloc_one(E_CHOICE, NULL); |
| - | (*ep)->right.sym = menu->sym; |
| - | } |
| - | if (menu->list && (!menu->prompt || !menu->prompt->text)) { |
| - | for (last_menu = menu->list; ; last_menu = last_menu->next) { |
| - | last_menu->parent = parent; |
| - | if (!last_menu->next) |
| - | break; |
| - | } |
| - | last_menu->next = menu->next; |
| - | menu->next = menu->list; |
| - | menu->list = NULL; |
| - | } |
| - | } |
| - | |
| - | if (sym && !(sym->flags & SYMBOL_WARNED)) { |
| - | if (sym->type == S_UNKNOWN) |
| - | menu_warn(parent, "config symbol defined " |
| - | "without type\n"); |
| - | |
| - | if (sym_is_choice(sym) && !parent->prompt) |
| - | menu_warn(parent, "choice must have a prompt\n"); |
| - | |
| - | /* Check properties connected to this symbol */ |
| - | sym_check_prop(sym); |
| - | sym->flags |= SYMBOL_WARNED; |
| - | } |
| - | |
| - | if (sym && !sym_is_optional(sym) && parent->prompt) { |
| - | sym->rev_dep.expr = expr_alloc_or(sym->rev_dep.expr, |
| - | expr_alloc_and(parent->prompt->visible.expr, |
| - | expr_alloc_symbol(&symbol_mod))); |
| - | } |
| - | } |
| - | |
| - | bool menu_is_visible(struct menu *menu) |
| - | { |
| - | struct menu *child; |
| - | struct symbol *sym; |
| - | tristate visible; |
| - | |
| - | if (!menu->prompt) |
| - | return false; |
| - | sym = menu->sym; |
| - | if (sym) { |
| - | sym_calc_value(sym); |
| - | visible = menu->prompt->visible.tri; |
| - | } else |
| - | visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr); |
| - | |
| - | if (visible != no) |
| - | return true; |
| - | if (!sym || sym_get_tristate_value(menu->sym) == no) |
| - | return false; |
| - | |
| - | for (child = menu->list; child; child = child->next) |
| - | if (menu_is_visible(child)) |
| - | return true; |
| - | return false; |
| - | } |
| - | |
| - | const char *menu_get_prompt(struct menu *menu) |
| - | { |
| - | if (menu->prompt) |
| - | return menu->prompt->text; |
| - | else if (menu->sym) |
| - | return menu->sym->name; |
| - | return NULL; |
| - | } |
| - | |
| - | struct menu *menu_get_root_menu(struct menu *menu) |
| - | { |
| - | return &rootmenu; |
| - | } |
| - | |
| - | struct menu *menu_get_parent_menu(struct menu *menu) |
| - | { |
| - | enum prop_type type; |
| - | |
| - | for (; menu != &rootmenu; menu = menu->parent) { |
| - | type = menu->prompt ? menu->prompt->type : 0; |
| - | if (type == P_MENU) |
| - | break; |
| - | } |
| - | return menu; |
| - | } |
| - | |
| @@ -1,51 +0,0 @@ | |
| - | #!/bin/sh |
| - | # |
| - | # Copyright (C) 2002 Khalid Aziz <khalid_aziz at hp.com> |
| - | # Copyright (C) 2002 Randy Dunlap <rddunlap at osdl.org> |
| - | # Copyright (C) 2002 Al Stone <ahs3 at fc.hp.com> |
| - | # Copyright (C) 2002 Hewlett-Packard Company |
| - | # |
| - | # 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., 675 Mass Ave, Cambridge, MA 02139, USA. |
| - | # |
| - | # Busybox version by Matteo Croce <3297627799 at wind.it> |
| - | # |
| - | # Rules to generate bbconfig.h from .config: |
| - | # - Retain lines that begin with "CONFIG_" |
| - | # - Retain lines that begin with "# CONFIG_" |
| - | # - lines that use double-quotes must \\-escape-quote them |
| - | |
| - | if [ $# -lt 1 ] |
| - | then |
| - | config=.config |
| - | else config=$1 |
| - | fi |
| - | |
| - | echo "#ifndef _BBCONFIGOPTS_H" |
| - | echo "#define _BBCONFIGOPTS_H" |
| - | echo \ |
| - | "/* |
| - | * busybox configuration settings. |
| - | * |
| - | * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. |
| - | * |
| - | * This file is generated automatically by scripts/config/mkconfigs. |
| - | * Do not edit. |
| - | * |
| - | */" |
| - | |
| - | echo "static const char * const bbconfig_config =" |
| - | echo "`sed 's/\"/\\\\\"/g' $config | grep "^#\? \?CONFIG_" | awk '{print "\\"" $0 "\\\\n\\"";}'`" |
| - | echo ";" |
| - | echo "#endif /* _BBCONFIGOPTS_H */" |
| @@ -1,810 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <ctype.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <regex.h> |
| - | #include <sys/utsname.h> |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | struct symbol symbol_yes = { |
| - | .name = "y", |
| - | .curr = { "y", yes }, |
| - | .flags = SYMBOL_YES|SYMBOL_VALID, |
| - | }, symbol_mod = { |
| - | .name = "m", |
| - | .curr = { "m", mod }, |
| - | .flags = SYMBOL_MOD|SYMBOL_VALID, |
| - | }, symbol_no = { |
| - | .name = "n", |
| - | .curr = { "n", no }, |
| - | .flags = SYMBOL_NO|SYMBOL_VALID, |
| - | }, symbol_empty = { |
| - | .name = "", |
| - | .curr = { "", no }, |
| - | .flags = SYMBOL_VALID, |
| - | }; |
| - | |
| - | int sym_change_count; |
| - | struct symbol *modules_sym; |
| - | tristate modules_val; |
| - | |
| - | void sym_add_default(struct symbol *sym, const char *def) |
| - | { |
| - | struct property *prop = prop_alloc(P_DEFAULT, sym); |
| - | |
| - | prop->expr = expr_alloc_symbol(sym_lookup(def, 1)); |
| - | } |
| - | |
| - | void sym_init(void) |
| - | { |
| - | struct symbol *sym; |
| - | char *p; |
| - | static bool inited = false; |
| - | |
| - | if (inited) |
| - | return; |
| - | inited = true; |
| - | |
| - | sym = sym_lookup("VERSION", 0); |
| - | sym->type = S_STRING; |
| - | sym->flags |= SYMBOL_AUTO; |
| - | p = getenv("VERSION"); |
| - | if (p) |
| - | sym_add_default(sym, p); |
| - | |
| - | sym = sym_lookup("TARGET_ARCH", 0); |
| - | sym->type = S_STRING; |
| - | sym->flags |= SYMBOL_AUTO; |
| - | p = getenv("TARGET_ARCH"); |
| - | if (p) |
| - | sym_add_default(sym, p); |
| - | |
| - | } |
| - | |
| - | enum symbol_type sym_get_type(struct symbol *sym) |
| - | { |
| - | enum symbol_type type = sym->type; |
| - | |
| - | if (type == S_TRISTATE) { |
| - | if (sym_is_choice_value(sym) && sym->visible == yes) |
| - | type = S_BOOLEAN; |
| - | else if (modules_val == no) |
| - | type = S_BOOLEAN; |
| - | } |
| - | return type; |
| - | } |
| - | |
| - | const char *sym_type_name(enum symbol_type type) |
| - | { |
| - | switch (type) { |
| - | case S_BOOLEAN: |
| - | return "boolean"; |
| - | case S_TRISTATE: |
| - | return "tristate"; |
| - | case S_INT: |
| - | return "integer"; |
| - | case S_HEX: |
| - | return "hex"; |
| - | case S_STRING: |
| - | return "string"; |
| - | case S_UNKNOWN: |
| - | return "unknown"; |
| - | case S_OTHER: |
| - | break; |
| - | } |
| - | return "???"; |
| - | } |
| - | |
| - | struct property *sym_get_choice_prop(struct symbol *sym) |
| - | { |
| - | struct property *prop; |
| - | |
| - | for_all_choices(sym, prop) |
| - | return prop; |
| - | return NULL; |
| - | } |
| - | |
| - | struct property *sym_get_default_prop(struct symbol *sym) |
| - | { |
| - | struct property *prop; |
| - | |
| - | for_all_defaults(sym, prop) { |
| - | prop->visible.tri = expr_calc_value(prop->visible.expr); |
| - | if (prop->visible.tri != no) |
| - | return prop; |
| - | } |
| - | return NULL; |
| - | } |
| - | |
| - | struct property *sym_get_range_prop(struct symbol *sym) |
| - | { |
| - | struct property *prop; |
| - | |
| - | for_all_properties(sym, prop, P_RANGE) { |
| - | prop->visible.tri = expr_calc_value(prop->visible.expr); |
| - | if (prop->visible.tri != no) |
| - | return prop; |
| - | } |
| - | return NULL; |
| - | } |
| - | |
| - | static void sym_calc_visibility(struct symbol *sym) |
| - | { |
| - | struct property *prop; |
| - | tristate tri; |
| - | |
| - | /* any prompt visible? */ |
| - | tri = no; |
| - | for_all_prompts(sym, prop) { |
| - | prop->visible.tri = expr_calc_value(prop->visible.expr); |
| - | tri = E_OR(tri, prop->visible.tri); |
| - | } |
| - | if (tri == mod && (sym->type != S_TRISTATE || modules_val == no)) |
| - | tri = yes; |
| - | if (sym->visible != tri) { |
| - | sym->visible = tri; |
| - | sym_set_changed(sym); |
| - | } |
| - | if (sym_is_choice_value(sym)) |
| - | return; |
| - | tri = no; |
| - | if (sym->rev_dep.expr) |
| - | tri = expr_calc_value(sym->rev_dep.expr); |
| - | if (tri == mod && sym_get_type(sym) == S_BOOLEAN) |
| - | tri = yes; |
| - | if (sym->rev_dep.tri != tri) { |
| - | sym->rev_dep.tri = tri; |
| - | sym_set_changed(sym); |
| - | } |
| - | } |
| - | |
| - | static struct symbol *sym_calc_choice(struct symbol *sym) |
| - | { |
| - | struct symbol *def_sym; |
| - | struct property *prop; |
| - | struct expr *e; |
| - | |
| - | /* is the user choice visible? */ |
| - | def_sym = sym->user.val; |
| - | if (def_sym) { |
| - | sym_calc_visibility(def_sym); |
| - | if (def_sym->visible != no) |
| - | return def_sym; |
| - | } |
| - | |
| - | /* any of the defaults visible? */ |
| - | for_all_defaults(sym, prop) { |
| - | prop->visible.tri = expr_calc_value(prop->visible.expr); |
| - | if (prop->visible.tri == no) |
| - | continue; |
| - | def_sym = prop_get_symbol(prop); |
| - | sym_calc_visibility(def_sym); |
| - | if (def_sym->visible != no) |
| - | return def_sym; |
| - | } |
| - | |
| - | /* just get the first visible value */ |
| - | prop = sym_get_choice_prop(sym); |
| - | for (e = prop->expr; e; e = e->left.expr) { |
| - | def_sym = e->right.sym; |
| - | sym_calc_visibility(def_sym); |
| - | if (def_sym->visible != no) |
| - | return def_sym; |
| - | } |
| - | |
| - | /* no choice? reset tristate value */ |
| - | sym->curr.tri = no; |
| - | return NULL; |
| - | } |
| - | |
| - | void sym_calc_value(struct symbol *sym) |
| - | { |
| - | struct symbol_value newval, oldval; |
| - | struct property *prop; |
| - | struct expr *e; |
| - | |
| - | if (!sym) |
| - | return; |
| - | |
| - | if (sym->flags & SYMBOL_VALID) |
| - | return; |
| - | sym->flags |= SYMBOL_VALID; |
| - | |
| - | oldval = sym->curr; |
| - | |
| - | switch (sym->type) { |
| - | case S_INT: |
| - | case S_HEX: |
| - | case S_STRING: |
| - | newval = symbol_empty.curr; |
| - | break; |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | newval = symbol_no.curr; |
| - | break; |
| - | default: |
| - | sym->curr.val = sym->name; |
| - | sym->curr.tri = no; |
| - | return; |
| - | } |
| - | if (!sym_is_choice_value(sym)) |
| - | sym->flags &= ~SYMBOL_WRITE; |
| - | |
| - | sym_calc_visibility(sym); |
| - | |
| - | /* set default if recursively called */ |
| - | sym->curr = newval; |
| - | |
| - | switch (sym_get_type(sym)) { |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | if (sym_is_choice_value(sym) && sym->visible == yes) { |
| - | prop = sym_get_choice_prop(sym); |
| - | newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no; |
| - | } else if (E_OR(sym->visible, sym->rev_dep.tri) != no) { |
| - | sym->flags |= SYMBOL_WRITE; |
| - | if (sym_has_value(sym)) |
| - | newval.tri = sym->user.tri; |
| - | else if (!sym_is_choice(sym)) { |
| - | prop = sym_get_default_prop(sym); |
| - | if (prop) |
| - | newval.tri = expr_calc_value(prop->expr); |
| - | } |
| - | newval.tri = E_OR(E_AND(newval.tri, sym->visible), sym->rev_dep.tri); |
| - | } else if (!sym_is_choice(sym)) { |
| - | prop = sym_get_default_prop(sym); |
| - | if (prop) { |
| - | sym->flags |= SYMBOL_WRITE; |
| - | newval.tri = expr_calc_value(prop->expr); |
| - | } |
| - | } |
| - | if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN) |
| - | newval.tri = yes; |
| - | break; |
| - | case S_STRING: |
| - | case S_HEX: |
| - | case S_INT: |
| - | if (sym->visible != no) { |
| - | sym->flags |= SYMBOL_WRITE; |
| - | if (sym_has_value(sym)) { |
| - | newval.val = sym->user.val; |
| - | break; |
| - | } |
| - | } |
| - | prop = sym_get_default_prop(sym); |
| - | if (prop) { |
| - | struct symbol *ds = prop_get_symbol(prop); |
| - | if (ds) { |
| - | sym->flags |= SYMBOL_WRITE; |
| - | sym_calc_value(ds); |
| - | newval.val = ds->curr.val; |
| - | } |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | |
| - | sym->curr = newval; |
| - | if (sym_is_choice(sym) && newval.tri == yes) |
| - | sym->curr.val = sym_calc_choice(sym); |
| - | |
| - | if (memcmp(&oldval, &sym->curr, sizeof(oldval))) |
| - | sym_set_changed(sym); |
| - | if (modules_sym == sym) |
| - | modules_val = modules_sym->curr.tri; |
| - | |
| - | if (sym_is_choice(sym)) { |
| - | int flags = sym->flags & (SYMBOL_CHANGED | SYMBOL_WRITE); |
| - | prop = sym_get_choice_prop(sym); |
| - | for (e = prop->expr; e; e = e->left.expr) { |
| - | e->right.sym->flags |= flags; |
| - | if (flags & SYMBOL_CHANGED) |
| - | sym_set_changed(e->right.sym); |
| - | } |
| - | } |
| - | } |
| - | |
| - | void sym_clear_all_valid(void) |
| - | { |
| - | struct symbol *sym; |
| - | int i; |
| - | |
| - | for_all_symbols(i, sym) |
| - | sym->flags &= ~SYMBOL_VALID; |
| - | sym_change_count++; |
| - | if (modules_sym) |
| - | sym_calc_value(modules_sym); |
| - | } |
| - | |
| - | void sym_set_changed(struct symbol *sym) |
| - | { |
| - | struct property *prop; |
| - | |
| - | sym->flags |= SYMBOL_CHANGED; |
| - | for (prop = sym->prop; prop; prop = prop->next) { |
| - | if (prop->menu) |
| - | prop->menu->flags |= MENU_CHANGED; |
| - | } |
| - | } |
| - | |
| - | void sym_set_all_changed(void) |
| - | { |
| - | struct symbol *sym; |
| - | int i; |
| - | |
| - | for_all_symbols(i, sym) |
| - | sym_set_changed(sym); |
| - | } |
| - | |
| - | bool sym_tristate_within_range(struct symbol *sym, tristate val) |
| - | { |
| - | int type = sym_get_type(sym); |
| - | |
| - | if (sym->visible == no) |
| - | return false; |
| - | |
| - | if (type != S_BOOLEAN && type != S_TRISTATE) |
| - | return false; |
| - | |
| - | if (type == S_BOOLEAN && val == mod) |
| - | return false; |
| - | if (sym->visible <= sym->rev_dep.tri) |
| - | return false; |
| - | if (sym_is_choice_value(sym) && sym->visible == yes) |
| - | return val == yes; |
| - | return val >= sym->rev_dep.tri && val <= sym->visible; |
| - | } |
| - | |
| - | bool sym_set_tristate_value(struct symbol *sym, tristate val) |
| - | { |
| - | tristate oldval = sym_get_tristate_value(sym); |
| - | |
| - | if (oldval != val && !sym_tristate_within_range(sym, val)) |
| - | return false; |
| - | |
| - | if (sym->flags & SYMBOL_NEW) { |
| - | sym->flags &= ~SYMBOL_NEW; |
| - | sym_set_changed(sym); |
| - | } |
| - | if (sym_is_choice_value(sym) && val == yes) { |
| - | struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); |
| - | |
| - | cs->user.val = sym; |
| - | cs->flags &= ~SYMBOL_NEW; |
| - | } |
| - | |
| - | sym->user.tri = val; |
| - | if (oldval != val) { |
| - | sym_clear_all_valid(); |
| - | if (sym == modules_sym) |
| - | sym_set_all_changed(); |
| - | } |
| - | |
| - | return true; |
| - | } |
| - | |
| - | tristate sym_toggle_tristate_value(struct symbol *sym) |
| - | { |
| - | tristate oldval, newval; |
| - | |
| - | oldval = newval = sym_get_tristate_value(sym); |
| - | do { |
| - | switch (newval) { |
| - | case no: |
| - | newval = mod; |
| - | break; |
| - | case mod: |
| - | newval = yes; |
| - | break; |
| - | case yes: |
| - | newval = no; |
| - | break; |
| - | } |
| - | if (sym_set_tristate_value(sym, newval)) |
| - | break; |
| - | } while (oldval != newval); |
| - | return newval; |
| - | } |
| - | |
| - | bool sym_string_valid(struct symbol *sym, const char *str) |
| - | { |
| - | signed char ch; |
| - | |
| - | switch (sym->type) { |
| - | case S_STRING: |
| - | return true; |
| - | case S_INT: |
| - | ch = *str++; |
| - | if (ch == '-') |
| - | ch = *str++; |
| - | if (!isdigit(ch)) |
| - | return false; |
| - | if (ch == '0' && *str != 0) |
| - | return false; |
| - | while ((ch = *str++)) { |
| - | if (!isdigit(ch)) |
| - | return false; |
| - | } |
| - | return true; |
| - | case S_HEX: |
| - | if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) |
| - | str += 2; |
| - | ch = *str++; |
| - | do { |
| - | if (!isxdigit(ch)) |
| - | return false; |
| - | } while ((ch = *str++)); |
| - | return true; |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | switch (str[0]) { |
| - | case 'y': case 'Y': |
| - | case 'm': case 'M': |
| - | case 'n': case 'N': |
| - | return true; |
| - | } |
| - | return false; |
| - | default: |
| - | return false; |
| - | } |
| - | } |
| - | |
| - | bool sym_string_within_range(struct symbol *sym, const char *str) |
| - | { |
| - | struct property *prop; |
| - | int val; |
| - | |
| - | switch (sym->type) { |
| - | case S_STRING: |
| - | return sym_string_valid(sym, str); |
| - | case S_INT: |
| - | if (!sym_string_valid(sym, str)) |
| - | return false; |
| - | prop = sym_get_range_prop(sym); |
| - | if (!prop) |
| - | return true; |
| - | val = strtol(str, NULL, 10); |
| - | return val >= strtol(prop->expr->left.sym->name, NULL, 10) && |
| - | val <= strtol(prop->expr->right.sym->name, NULL, 10); |
| - | case S_HEX: |
| - | if (!sym_string_valid(sym, str)) |
| - | return false; |
| - | prop = sym_get_range_prop(sym); |
| - | if (!prop) |
| - | return true; |
| - | val = strtol(str, NULL, 16); |
| - | return val >= strtol(prop->expr->left.sym->name, NULL, 16) && |
| - | val <= strtol(prop->expr->right.sym->name, NULL, 16); |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | switch (str[0]) { |
| - | case 'y': case 'Y': |
| - | return sym_tristate_within_range(sym, yes); |
| - | case 'm': case 'M': |
| - | return sym_tristate_within_range(sym, mod); |
| - | case 'n': case 'N': |
| - | return sym_tristate_within_range(sym, no); |
| - | } |
| - | return false; |
| - | default: |
| - | return false; |
| - | } |
| - | } |
| - | |
| - | bool sym_set_string_value(struct symbol *sym, const char *newval) |
| - | { |
| - | const char *oldval; |
| - | char *val; |
| - | int size; |
| - | |
| - | switch (sym->type) { |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | switch (newval[0]) { |
| - | case 'y': case 'Y': |
| - | return sym_set_tristate_value(sym, yes); |
| - | case 'm': case 'M': |
| - | return sym_set_tristate_value(sym, mod); |
| - | case 'n': case 'N': |
| - | return sym_set_tristate_value(sym, no); |
| - | } |
| - | return false; |
| - | default: |
| - | ; |
| - | } |
| - | |
| - | if (!sym_string_within_range(sym, newval)) |
| - | return false; |
| - | |
| - | if (sym->flags & SYMBOL_NEW) { |
| - | sym->flags &= ~SYMBOL_NEW; |
| - | sym_set_changed(sym); |
| - | } |
| - | |
| - | oldval = sym->user.val; |
| - | size = strlen(newval) + 1; |
| - | if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) { |
| - | size += 2; |
| - | sym->user.val = val = malloc(size); |
| - | *val++ = '0'; |
| - | *val++ = 'x'; |
| - | } else if (!oldval || strcmp(oldval, newval)) |
| - | sym->user.val = val = malloc(size); |
| - | else |
| - | return true; |
| - | |
| - | strcpy(val, newval); |
| - | free((void *)oldval); |
| - | sym_clear_all_valid(); |
| - | |
| - | return true; |
| - | } |
| - | |
| - | const char *sym_get_string_value(struct symbol *sym) |
| - | { |
| - | tristate val; |
| - | |
| - | switch (sym->type) { |
| - | case S_BOOLEAN: |
| - | case S_TRISTATE: |
| - | val = sym_get_tristate_value(sym); |
| - | switch (val) { |
| - | case no: |
| - | return "n"; |
| - | case mod: |
| - | return "m"; |
| - | case yes: |
| - | return "y"; |
| - | } |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | return (const char *)sym->curr.val; |
| - | } |
| - | |
| - | bool sym_is_changable(struct symbol *sym) |
| - | { |
| - | return sym->visible > sym->rev_dep.tri; |
| - | } |
| - | |
| - | struct symbol *sym_lookup(const char *name, int isconst) |
| - | { |
| - | struct symbol *symbol; |
| - | const char *ptr; |
| - | char *new_name; |
| - | int hash = 0; |
| - | |
| - | if (name) { |
| - | if (name[0] && !name[1]) { |
| - | switch (name[0]) { |
| - | case 'y': return &symbol_yes; |
| - | case 'm': return &symbol_mod; |
| - | case 'n': return &symbol_no; |
| - | } |
| - | } |
| - | for (ptr = name; *ptr; ptr++) |
| - | hash += *ptr; |
| - | hash &= 0xff; |
| - | |
| - | for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) { |
| - | if (!strcmp(symbol->name, name)) { |
| - | if ((isconst && symbol->flags & SYMBOL_CONST) || |
| - | (!isconst && !(symbol->flags & SYMBOL_CONST))) |
| - | return symbol; |
| - | } |
| - | } |
| - | new_name = strdup(name); |
| - | } else { |
| - | new_name = NULL; |
| - | hash = 256; |
| - | } |
| - | |
| - | symbol = malloc(sizeof(*symbol)); |
| - | memset(symbol, 0, sizeof(*symbol)); |
| - | symbol->name = new_name; |
| - | symbol->type = S_UNKNOWN; |
| - | symbol->flags = SYMBOL_NEW; |
| - | if (isconst) |
| - | symbol->flags |= SYMBOL_CONST; |
| - | |
| - | symbol->next = symbol_hash[hash]; |
| - | symbol_hash[hash] = symbol; |
| - | |
| - | return symbol; |
| - | } |
| - | |
| - | struct symbol *sym_find(const char *name) |
| - | { |
| - | struct symbol *symbol = NULL; |
| - | const char *ptr; |
| - | int hash = 0; |
| - | |
| - | if (!name) |
| - | return NULL; |
| - | |
| - | if (name[0] && !name[1]) { |
| - | switch (name[0]) { |
| - | case 'y': return &symbol_yes; |
| - | case 'm': return &symbol_mod; |
| - | case 'n': return &symbol_no; |
| - | } |
| - | } |
| - | for (ptr = name; *ptr; ptr++) |
| - | hash += *ptr; |
| - | hash &= 0xff; |
| - | |
| - | for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) { |
| - | if (!strcmp(symbol->name, name) && |
| - | !(symbol->flags & SYMBOL_CONST)) |
| - | break; |
| - | } |
| - | |
| - | return symbol; |
| - | } |
| - | |
| - | struct symbol **sym_re_search(const char *pattern) |
| - | { |
| - | struct symbol *sym, **sym_arr = NULL; |
| - | int i, cnt, size; |
| - | regex_t re; |
| - | |
| - | cnt = size = 0; |
| - | /* Skip if empty */ |
| - | if (strlen(pattern) == 0) |
| - | return NULL; |
| - | if (regcomp(&re, pattern, REG_EXTENDED|REG_NOSUB|REG_ICASE)) |
| - | return NULL; |
| - | |
| - | for_all_symbols(i, sym) { |
| - | if (sym->flags & SYMBOL_CONST || !sym->name) |
| - | continue; |
| - | if (regexec(&re, sym->name, 0, NULL, 0)) |
| - | continue; |
| - | if (cnt + 1 >= size) { |
| - | void *tmp = sym_arr; |
| - | size += 16; |
| - | sym_arr = realloc(sym_arr, size * sizeof(struct symbol *)); |
| - | if (!sym_arr) { |
| - | free(tmp); |
| - | return NULL; |
| - | } |
| - | } |
| - | sym_arr[cnt++] = sym; |
| - | } |
| - | if (sym_arr) |
| - | sym_arr[cnt] = NULL; |
| - | regfree(&re); |
| - | |
| - | return sym_arr; |
| - | } |
| - | |
| - | |
| - | struct symbol *sym_check_deps(struct symbol *sym); |
| - | |
| - | static struct symbol *sym_check_expr_deps(struct expr *e) |
| - | { |
| - | struct symbol *sym; |
| - | |
| - | if (!e) |
| - | return NULL; |
| - | switch (e->type) { |
| - | case E_OR: |
| - | case E_AND: |
| - | sym = sym_check_expr_deps(e->left.expr); |
| - | if (sym) |
| - | return sym; |
| - | return sym_check_expr_deps(e->right.expr); |
| - | case E_NOT: |
| - | return sym_check_expr_deps(e->left.expr); |
| - | case E_EQUAL: |
| - | case E_UNEQUAL: |
| - | sym = sym_check_deps(e->left.sym); |
| - | if (sym) |
| - | return sym; |
| - | return sym_check_deps(e->right.sym); |
| - | case E_SYMBOL: |
| - | return sym_check_deps(e->left.sym); |
| - | default: |
| - | break; |
| - | } |
| - | printf("Oops! How to check %d?\n", e->type); |
| - | return NULL; |
| - | } |
| - | |
| - | struct symbol *sym_check_deps(struct symbol *sym) |
| - | { |
| - | struct symbol *sym2; |
| - | struct property *prop; |
| - | |
| - | if (sym->flags & SYMBOL_CHECK_DONE) |
| - | return NULL; |
| - | if (sym->flags & SYMBOL_CHECK) { |
| - | printf("Warning! Found recursive dependency: %s", sym->name); |
| - | return sym; |
| - | } |
| - | |
| - | sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); |
| - | sym2 = sym_check_expr_deps(sym->rev_dep.expr); |
| - | if (sym2) |
| - | goto out; |
| - | |
| - | for (prop = sym->prop; prop; prop = prop->next) { |
| - | if (prop->type == P_CHOICE || prop->type == P_SELECT) |
| - | continue; |
| - | sym2 = sym_check_expr_deps(prop->visible.expr); |
| - | if (sym2) |
| - | goto out; |
| - | if (prop->type != P_DEFAULT || sym_is_choice(sym)) |
| - | continue; |
| - | sym2 = sym_check_expr_deps(prop->expr); |
| - | if (sym2) |
| - | goto out; |
| - | } |
| - | out: |
| - | if (sym2) |
| - | printf(" %s", sym->name); |
| - | sym->flags &= ~SYMBOL_CHECK; |
| - | return sym2; |
| - | } |
| - | |
| - | struct property *prop_alloc(enum prop_type type, struct symbol *sym) |
| - | { |
| - | struct property *prop; |
| - | struct property **propp; |
| - | |
| - | prop = malloc(sizeof(*prop)); |
| - | memset(prop, 0, sizeof(*prop)); |
| - | prop->type = type; |
| - | prop->sym = sym; |
| - | prop->file = current_file; |
| - | prop->lineno = zconf_lineno(); |
| - | |
| - | /* append property to the prop list of symbol */ |
| - | if (sym) { |
| - | for (propp = &sym->prop; *propp; propp = &(*propp)->next) |
| - | ; |
| - | *propp = prop; |
| - | } |
| - | |
| - | return prop; |
| - | } |
| - | |
| - | struct symbol *prop_get_symbol(struct property *prop) |
| - | { |
| - | if (prop->expr && (prop->expr->type == E_SYMBOL || |
| - | prop->expr->type == E_CHOICE)) |
| - | return prop->expr->left.sym; |
| - | return NULL; |
| - | } |
| - | |
| - | const char *prop_get_type_name(enum prop_type type) |
| - | { |
| - | switch (type) { |
| - | case P_PROMPT: |
| - | return "prompt"; |
| - | case P_COMMENT: |
| - | return "comment"; |
| - | case P_MENU: |
| - | return "menu"; |
| - | case P_DEFAULT: |
| - | return "default"; |
| - | case P_CHOICE: |
| - | return "choice"; |
| - | case P_SELECT: |
| - | return "select"; |
| - | case P_RANGE: |
| - | return "range"; |
| - | case P_UNKNOWN: |
| - | break; |
| - | } |
| - | return "unknown"; |
| - | } |
| @@ -1,110 +0,0 @@ | |
| - | /* vi: set sw=4 ts=4: */ |
| - | /* |
| - | * Copyright (C) 2002-2005 Roman Zippel <[email protected]> |
| - | * Copyright (C) 2002-2005 Sam Ravnborg <[email protected]> |
| - | * |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <string.h> |
| - | #include "lkc.h" |
| - | |
| - | /* file already present in list? If not add it */ |
| - | struct file *file_lookup(const char *name) |
| - | { |
| - | struct file *file; |
| - | |
| - | for (file = file_list; file; file = file->next) { |
| - | if (!strcmp(name, file->name)) |
| - | return file; |
| - | } |
| - | |
| - | file = malloc(sizeof(*file)); |
| - | memset(file, 0, sizeof(*file)); |
| - | file->name = strdup(name); |
| - | file->next = file_list; |
| - | file_list = file; |
| - | return file; |
| - | } |
| - | |
| - | /* write a dependency file as used by kbuild to track dependencies */ |
| - | int file_write_dep(const char *name) |
| - | { |
| - | struct file *file; |
| - | FILE *out; |
| - | |
| - | if (!name) |
| - | name = ".config.cmd"; |
| - | out = fopen(".config.tmp", "w"); |
| - | if (!out) |
| - | return 1; |
| - | fprintf(out, "deps_config := \\\n"); |
| - | for (file = file_list; file; file = file->next) { |
| - | if (file->next) |
| - | fprintf(out, "\t%s \\\n", file->name); |
| - | else |
| - | fprintf(out, "\t%s\n", file->name); |
| - | } |
| - | fprintf(out, "\n.config include/config.h: $(deps_config)\n\n$(deps_config):\n"); |
| - | fclose(out); |
| - | rename(".config.tmp", name); |
| - | return 0; |
| - | } |
| - | |
| - | |
| - | /* Allocate initial growable sting */ |
| - | struct gstr str_new(void) |
| - | { |
| - | struct gstr gs; |
| - | gs.s = malloc(sizeof(char) * 64); |
| - | gs.len = 16; |
| - | strcpy(gs.s, "\0"); |
| - | return gs; |
| - | } |
| - | |
| - | /* Allocate and assign growable string */ |
| - | struct gstr str_assign(const char *s) |
| - | { |
| - | struct gstr gs; |
| - | gs.s = strdup(s); |
| - | gs.len = strlen(s) + 1; |
| - | return gs; |
| - | } |
| - | |
| - | /* Free storage for growable string */ |
| - | void str_free(struct gstr *gs) |
| - | { |
| - | if (gs->s) |
| - | free(gs->s); |
| - | gs->s = NULL; |
| - | gs->len = 0; |
| - | } |
| - | |
| - | /* Append to growable string */ |
| - | void str_append(struct gstr *gs, const char *s) |
| - | { |
| - | size_t l = strlen(gs->s) + strlen(s) + 1; |
| - | if (l > gs->len) { |
| - | gs->s = realloc(gs->s, l); |
| - | gs->len = l; |
| - | } |
| - | strcat(gs->s, s); |
| - | } |
| - | |
| - | /* Append printf formatted string to growable string */ |
| - | void str_printf(struct gstr *gs, const char *fmt, ...) |
| - | { |
| - | va_list ap; |
| - | char s[10000]; /* big enough... */ |
| - | va_start(ap, fmt); |
| - | vsnprintf(s, sizeof(s), fmt, ap); |
| - | str_append(gs, s); |
| - | va_end(ap); |
| - | } |
| - | |
| - | /* Retreive value of growable string */ |
| - | const char *str_get(struct gstr *gs) |
| - | { |
| - | return gs->s; |
| - | } |
| - | |
| @@ -1,366 +0,0 @@ | |
| - | %option backup nostdinit noyywrap never-interactive full ecs |
| - | %option 8bit backup nodefault perf-report perf-report |
| - | %x COMMAND HELP STRING PARAM |
| - | %{ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <limits.h> |
| - | #include <stdio.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <unistd.h> |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | #define START_STRSIZE 16 |
| - | |
| - | char *text; |
| - | static char *text_ptr; |
| - | static int text_size, text_asize; |
| - | |
| - | struct buffer { |
| - | struct buffer *parent; |
| - | YY_BUFFER_STATE state; |
| - | }; |
| - | |
| - | struct buffer *current_buf; |
| - | |
| - | static int last_ts, first_ts; |
| - | |
| - | static void zconf_endhelp(void); |
| - | static struct buffer *zconf_endfile(void); |
| - | |
| - | void new_string(void) |
| - | { |
| - | text = malloc(START_STRSIZE); |
| - | text_asize = START_STRSIZE; |
| - | text_ptr = text; |
| - | text_size = 0; |
| - | *text_ptr = 0; |
| - | } |
| - | |
| - | void append_string(const char *str, int size) |
| - | { |
| - | int new_size = text_size + size + 1; |
| - | if (new_size > text_asize) { |
| - | text = realloc(text, new_size); |
| - | text_asize = new_size; |
| - | text_ptr = text + text_size; |
| - | } |
| - | memcpy(text_ptr, str, size); |
| - | text_ptr += size; |
| - | text_size += size; |
| - | *text_ptr = 0; |
| - | } |
| - | |
| - | void alloc_string(const char *str, int size) |
| - | { |
| - | text = malloc(size + 1); |
| - | memcpy(text, str, size); |
| - | text[size] = 0; |
| - | } |
| - | %} |
| - | |
| - | ws [ \n\t] |
| - | n [A-Za-z0-9_] |
| - | |
| - | %% |
| - | int str = 0; |
| - | int ts, i; |
| - | |
| - | [ \t]*#.*\n current_file->lineno++; |
| - | [ \t]*#.* |
| - | |
| - | [ \t]*\n current_file->lineno++; return T_EOL; |
| - | |
| - | [ \t]+ { |
| - | BEGIN(COMMAND); |
| - | } |
| - | |
| - | . { |
| - | unput(yytext[0]); |
| - | BEGIN(COMMAND); |
| - | } |
| - | |
| - | |
| - | <COMMAND>{ |
| - | "mainmenu" BEGIN(PARAM); return T_MAINMENU; |
| - | "menu" BEGIN(PARAM); return T_MENU; |
| - | "endmenu" BEGIN(PARAM); return T_ENDMENU; |
| - | "source" BEGIN(PARAM); return T_SOURCE; |
| - | "choice" BEGIN(PARAM); return T_CHOICE; |
| - | "endchoice" BEGIN(PARAM); return T_ENDCHOICE; |
| - | "comment" BEGIN(PARAM); return T_COMMENT; |
| - | "config" BEGIN(PARAM); return T_CONFIG; |
| - | "menuconfig" BEGIN(PARAM); return T_MENUCONFIG; |
| - | "help" BEGIN(PARAM); return T_HELP; |
| - | "if" BEGIN(PARAM); return T_IF; |
| - | "endif" BEGIN(PARAM); return T_ENDIF; |
| - | "depends" BEGIN(PARAM); return T_DEPENDS; |
| - | "requires" BEGIN(PARAM); return T_REQUIRES; |
| - | "optional" BEGIN(PARAM); return T_OPTIONAL; |
| - | "default" BEGIN(PARAM); return T_DEFAULT; |
| - | "prompt" BEGIN(PARAM); return T_PROMPT; |
| - | "tristate" BEGIN(PARAM); return T_TRISTATE; |
| - | "def_tristate" BEGIN(PARAM); return T_DEF_TRISTATE; |
| - | "bool" BEGIN(PARAM); return T_BOOLEAN; |
| - | "boolean" BEGIN(PARAM); return T_BOOLEAN; |
| - | "def_bool" BEGIN(PARAM); return T_DEF_BOOLEAN; |
| - | "def_boolean" BEGIN(PARAM); return T_DEF_BOOLEAN; |
| - | "int" BEGIN(PARAM); return T_INT; |
| - | "hex" BEGIN(PARAM); return T_HEX; |
| - | "string" BEGIN(PARAM); return T_STRING; |
| - | "select" BEGIN(PARAM); return T_SELECT; |
| - | "enable" BEGIN(PARAM); return T_SELECT; |
| - | "range" BEGIN(PARAM); return T_RANGE; |
| - | {n}+ { |
| - | alloc_string(yytext, yyleng); |
| - | zconflval.string = text; |
| - | return T_WORD; |
| - | } |
| - | . |
| - | \n current_file->lineno++; BEGIN(INITIAL); |
| - | } |
| - | |
| - | <PARAM>{ |
| - | "&&" return T_AND; |
| - | "||" return T_OR; |
| - | "(" return T_OPEN_PAREN; |
| - | ")" return T_CLOSE_PAREN; |
| - | "!" return T_NOT; |
| - | "=" return T_EQUAL; |
| - | "!=" return T_UNEQUAL; |
| - | "if" return T_IF; |
| - | "on" return T_ON; |
| - | \"|\' { |
| - | str = yytext[0]; |
| - | new_string(); |
| - | BEGIN(STRING); |
| - | } |
| - | \n BEGIN(INITIAL); current_file->lineno++; return T_EOL; |
| - | --- /* ignore */ |
| - | ({n}|[-/.])+ { |
| - | alloc_string(yytext, yyleng); |
| - | zconflval.string = text; |
| - | return T_WORD; |
| - | } |
| - | #.* /* comment */ |
| - | \\\n current_file->lineno++; |
| - | . |
| - | <<EOF>> { |
| - | BEGIN(INITIAL); |
| - | } |
| - | } |
| - | |
| - | <STRING>{ |
| - | [^'"\\\n]+/\n { |
| - | append_string(yytext, yyleng); |
| - | zconflval.string = text; |
| - | return T_WORD_QUOTE; |
| - | } |
| - | [^'"\\\n]+ { |
| - | append_string(yytext, yyleng); |
| - | } |
| - | \\.?/\n { |
| - | append_string(yytext + 1, yyleng - 1); |
| - | zconflval.string = text; |
| - | return T_WORD_QUOTE; |
| - | } |
| - | \\.? { |
| - | append_string(yytext + 1, yyleng - 1); |
| - | } |
| - | \'|\" { |
| - | if (str == yytext[0]) { |
| - | BEGIN(PARAM); |
| - | zconflval.string = text; |
| - | return T_WORD_QUOTE; |
| - | } else |
| - | append_string(yytext, 1); |
| - | } |
| - | \n { |
| - | printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno()); |
| - | current_file->lineno++; |
| - | BEGIN(INITIAL); |
| - | return T_EOL; |
| - | } |
| - | <<EOF>> { |
| - | BEGIN(INITIAL); |
| - | } |
| - | } |
| - | |
| - | <HELP>{ |
| - | [ \t]+ { |
| - | ts = 0; |
| - | for (i = 0; i < yyleng; i++) { |
| - | if (yytext[i] == '\t') |
| - | ts = (ts & ~7) + 8; |
| - | else |
| - | ts++; |
| - | } |
| - | last_ts = ts; |
| - | if (first_ts) { |
| - | if (ts < first_ts) { |
| - | zconf_endhelp(); |
| - | return T_HELPTEXT; |
| - | } |
| - | ts -= first_ts; |
| - | while (ts > 8) { |
| - | append_string(" ", 8); |
| - | ts -= 8; |
| - | } |
| - | append_string(" ", ts); |
| - | } |
| - | } |
| - | [ \t]*\n/[^ \t\n] { |
| - | current_file->lineno++; |
| - | zconf_endhelp(); |
| - | return T_HELPTEXT; |
| - | } |
| - | [ \t]*\n { |
| - | current_file->lineno++; |
| - | append_string("\n", 1); |
| - | } |
| - | [^ \t\n].* { |
| - | append_string(yytext, yyleng); |
| - | if (!first_ts) |
| - | first_ts = last_ts; |
| - | } |
| - | <<EOF>> { |
| - | zconf_endhelp(); |
| - | return T_HELPTEXT; |
| - | } |
| - | } |
| - | |
| - | <<EOF>> { |
| - | if (current_buf) { |
| - | zconf_endfile(); |
| - | return T_EOF; |
| - | } |
| - | fclose(yyin); |
| - | yyterminate(); |
| - | } |
| - | |
| - | %% |
| - | void zconf_starthelp(void) |
| - | { |
| - | new_string(); |
| - | last_ts = first_ts = 0; |
| - | BEGIN(HELP); |
| - | } |
| - | |
| - | static void zconf_endhelp(void) |
| - | { |
| - | zconflval.string = text; |
| - | BEGIN(INITIAL); |
| - | } |
| - | |
| - | |
| - | /* |
| - | * Try to open specified file with following names: |
| - | * ./name |
| - | * $(srctree)/name |
| - | * The latter is used when srctree is separate from objtree |
| - | * when compiling the kernel. |
| - | * Return NULL if file is not found. |
| - | */ |
| - | FILE *zconf_fopen(const char *name) |
| - | { |
| - | char *env, fullname[PATH_MAX+1]; |
| - | FILE *f; |
| - | |
| - | f = fopen(name, "r"); |
| - | if (!f && name[0] != '/') { |
| - | env = getenv(SRCTREE); |
| - | if (env) { |
| - | sprintf(fullname, "%s/%s", env, name); |
| - | f = fopen(fullname, "r"); |
| - | } |
| - | } |
| - | return f; |
| - | } |
| - | |
| - | void zconf_initscan(const char *name) |
| - | { |
| - | yyin = zconf_fopen(name); |
| - | if (!yyin) { |
| - | printf("can't find file %s\n", name); |
| - | exit(1); |
| - | } |
| - | |
| - | current_buf = malloc(sizeof(*current_buf)); |
| - | memset(current_buf, 0, sizeof(*current_buf)); |
| - | |
| - | current_file = file_lookup(name); |
| - | current_file->lineno = 1; |
| - | current_file->flags = FILE_BUSY; |
| - | } |
| - | |
| - | void zconf_nextfile(const char *name) |
| - | { |
| - | struct file *file = file_lookup(name); |
| - | struct buffer *buf = malloc(sizeof(*buf)); |
| - | memset(buf, 0, sizeof(*buf)); |
| - | |
| - | current_buf->state = YY_CURRENT_BUFFER; |
| - | yyin = zconf_fopen(name); |
| - | if (!yyin) { |
| - | printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name); |
| - | exit(1); |
| - | } |
| - | yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE)); |
| - | buf->parent = current_buf; |
| - | current_buf = buf; |
| - | |
| - | if (file->flags & FILE_BUSY) { |
| - | printf("recursive scan (%s)?\n", name); |
| - | exit(1); |
| - | } |
| - | if (file->flags & FILE_SCANNED) { |
| - | printf("file %s already scanned?\n", name); |
| - | exit(1); |
| - | } |
| - | file->flags |= FILE_BUSY; |
| - | file->lineno = 1; |
| - | file->parent = current_file; |
| - | current_file = file; |
| - | } |
| - | |
| - | static struct buffer *zconf_endfile(void) |
| - | { |
| - | struct buffer *parent; |
| - | |
| - | current_file->flags |= FILE_SCANNED; |
| - | current_file->flags &= ~FILE_BUSY; |
| - | current_file = current_file->parent; |
| - | |
| - | parent = current_buf->parent; |
| - | if (parent) { |
| - | fclose(yyin); |
| - | yy_delete_buffer(YY_CURRENT_BUFFER); |
| - | yy_switch_to_buffer(parent->state); |
| - | } |
| - | free(current_buf); |
| - | current_buf = parent; |
| - | |
| - | return parent; |
| - | } |
| - | |
| - | int zconf_lineno(void) |
| - | { |
| - | if (current_buf) |
| - | return current_file->lineno - 1; |
| - | else |
| - | return 0; |
| - | } |
| - | |
| - | char *zconf_curname(void) |
| - | { |
| - | if (current_buf) |
| - | return current_file->name; |
| - | else |
| - | return "<none>"; |
| - | } |
| @@ -1,2130 +0,0 @@ | |
| - | /* A Bison parser, made by GNU Bison 1.875a. */ |
| - | |
| - | /* Skeleton parser for Yacc-like parsing with Bison, |
| - | Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. |
| - | |
| - | 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, 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. */ |
| - | |
| - | /* As a special exception, when this file is copied by Bison into a |
| - | Bison output file, you may use that output file without restriction. |
| - | This special exception was added by the Free Software Foundation |
| - | in version 1.24 of Bison. */ |
| - | |
| - | /* Written by Richard Stallman by simplifying the original so called |
| - | ``semantic'' parser. */ |
| - | |
| - | /* All symbols defined below should begin with yy or YY, to avoid |
| - | infringing on user name space. This should be done even for local |
| - | variables, as they might otherwise be expanded by user macros. |
| - | There are some unavoidable exceptions within include files to |
| - | define necessary library symbols; they are noted "INFRINGES ON |
| - | USER NAME SPACE" below. */ |
| - | |
| - | /* Identify Bison output. */ |
| - | #define YYBISON 1 |
| - | |
| - | /* Skeleton name. */ |
| - | #define YYSKELETON_NAME "yacc.c" |
| - | |
| - | /* Pure parsers. */ |
| - | #define YYPURE 0 |
| - | |
| - | /* Using locations. */ |
| - | #define YYLSP_NEEDED 0 |
| - | |
| - | /* If NAME_PREFIX is specified substitute the variables and functions |
| - | names. */ |
| - | #define yyparse zconfparse |
| - | #define yylex zconflex |
| - | #define yyerror zconferror |
| - | #define yylval zconflval |
| - | #define yychar zconfchar |
| - | #define yydebug zconfdebug |
| - | #define yynerrs zconfnerrs |
| - | |
| - | |
| - | /* Tokens. */ |
| - | #ifndef YYTOKENTYPE |
| - | # define YYTOKENTYPE |
| - | /* Put the tokens into the symbol table, so that GDB and other debuggers |
| - | know about them. */ |
| - | enum yytokentype { |
| - | T_MAINMENU = 258, |
| - | T_MENU = 259, |
| - | T_ENDMENU = 260, |
| - | T_SOURCE = 261, |
| - | T_CHOICE = 262, |
| - | T_ENDCHOICE = 263, |
| - | T_COMMENT = 264, |
| - | T_CONFIG = 265, |
| - | T_MENUCONFIG = 266, |
| - | T_HELP = 267, |
| - | T_HELPTEXT = 268, |
| - | T_IF = 269, |
| - | T_ENDIF = 270, |
| - | T_DEPENDS = 271, |
| - | T_REQUIRES = 272, |
| - | T_OPTIONAL = 273, |
| - | T_PROMPT = 274, |
| - | T_DEFAULT = 275, |
| - | T_TRISTATE = 276, |
| - | T_DEF_TRISTATE = 277, |
| - | T_BOOLEAN = 278, |
| - | T_DEF_BOOLEAN = 279, |
| - | T_STRING = 280, |
| - | T_INT = 281, |
| - | T_HEX = 282, |
| - | T_WORD = 283, |
| - | T_WORD_QUOTE = 284, |
| - | T_UNEQUAL = 285, |
| - | T_EOF = 286, |
| - | T_EOL = 287, |
| - | T_CLOSE_PAREN = 288, |
| - | T_OPEN_PAREN = 289, |
| - | T_ON = 290, |
| - | T_SELECT = 291, |
| - | T_RANGE = 292, |
| - | T_OR = 293, |
| - | T_AND = 294, |
| - | T_EQUAL = 295, |
| - | T_NOT = 296 |
| - | }; |
| - | #endif |
| - | #define T_MAINMENU 258 |
| - | #define T_MENU 259 |
| - | #define T_ENDMENU 260 |
| - | #define T_SOURCE 261 |
| - | #define T_CHOICE 262 |
| - | #define T_ENDCHOICE 263 |
| - | #define T_COMMENT 264 |
| - | #define T_CONFIG 265 |
| - | #define T_MENUCONFIG 266 |
| - | #define T_HELP 267 |
| - | #define T_HELPTEXT 268 |
| - | #define T_IF 269 |
| - | #define T_ENDIF 270 |
| - | #define T_DEPENDS 271 |
| - | #define T_REQUIRES 272 |
| - | #define T_OPTIONAL 273 |
| - | #define T_PROMPT 274 |
| - | #define T_DEFAULT 275 |
| - | #define T_TRISTATE 276 |
| - | #define T_DEF_TRISTATE 277 |
| - | #define T_BOOLEAN 278 |
| - | #define T_DEF_BOOLEAN 279 |
| - | #define T_STRING 280 |
| - | #define T_INT 281 |
| - | #define T_HEX 282 |
| - | #define T_WORD 283 |
| - | #define T_WORD_QUOTE 284 |
| - | #define T_UNEQUAL 285 |
| - | #define T_EOF 286 |
| - | #define T_EOL 287 |
| - | #define T_CLOSE_PAREN 288 |
| - | #define T_OPEN_PAREN 289 |
| - | #define T_ON 290 |
| - | #define T_SELECT 291 |
| - | #define T_RANGE 292 |
| - | #define T_OR 293 |
| - | #define T_AND 294 |
| - | #define T_EQUAL 295 |
| - | #define T_NOT 296 |
| - | |
| - | |
| - | |
| - | |
| - | /* Copy the first part of user declarations. */ |
| - | |
| - | |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <ctype.h> |
| - | #include <stdarg.h> |
| - | #include <stdio.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <stdbool.h> |
| - | |
| - | #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt) |
| - | |
| - | #define PRINTD 0x0001 |
| - | #define DEBUG_PARSE 0x0002 |
| - | |
| - | int cdebug = PRINTD; |
| - | |
| - | extern int zconflex(void); |
| - | static void zconfprint(const char *err, ...); |
| - | static void zconferror(const char *err); |
| - | static bool zconf_endtoken(int token, int starttoken, int endtoken); |
| - | |
| - | struct symbol *symbol_hash[257]; |
| - | |
| - | static struct menu *current_menu, *current_entry; |
| - | |
| - | #define YYERROR_VERBOSE |
| - | |
| - | |
| - | /* Enabling traces. */ |
| - | #ifndef YYDEBUG |
| - | # define YYDEBUG 0 |
| - | #endif |
| - | |
| - | /* Enabling verbose error messages. */ |
| - | #ifdef YYERROR_VERBOSE |
| - | # undef YYERROR_VERBOSE |
| - | # define YYERROR_VERBOSE 1 |
| - | #else |
| - | # define YYERROR_VERBOSE 0 |
| - | #endif |
| - | |
| - | #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
| - | |
| - | typedef union YYSTYPE { |
| - | int token; |
| - | char *string; |
| - | struct symbol *symbol; |
| - | struct expr *expr; |
| - | struct menu *menu; |
| - | } YYSTYPE; |
| - | /* Line 191 of yacc.c. */ |
| - | |
| - | # define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
| - | # define YYSTYPE_IS_DECLARED 1 |
| - | # define YYSTYPE_IS_TRIVIAL 1 |
| - | #endif |
| - | |
| - | |
| - | |
| - | /* Copy the second part of user declarations. */ |
| - | |
| - | |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | |
| - | |
| - | /* Line 214 of yacc.c. */ |
| - | |
| - | |
| - | #if ! defined (yyoverflow) || YYERROR_VERBOSE |
| - | |
| - | /* The parser invokes alloca or malloc; define the necessary symbols. */ |
| - | |
| - | # if YYSTACK_USE_ALLOCA |
| - | # define YYSTACK_ALLOC alloca |
| - | # else |
| - | # ifndef YYSTACK_USE_ALLOCA |
| - | # if defined (alloca) || (defined (_ALLOCA_H) && defined (__GNUC__)) |
| - | # define YYSTACK_ALLOC alloca |
| - | # else |
| - | # ifdef __GNUC__ |
| - | # define YYSTACK_ALLOC __builtin_alloca |
| - | # endif |
| - | # endif |
| - | # endif |
| - | # endif |
| - | |
| - | # ifdef YYSTACK_ALLOC |
| - | /* Pacify GCC's `empty if-body' warning. */ |
| - | # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) |
| - | # else |
| - | # if defined (__STDC__) || defined (__cplusplus) |
| - | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
| - | # define YYSIZE_T size_t |
| - | # endif |
| - | # define YYSTACK_ALLOC malloc |
| - | # define YYSTACK_FREE free |
| - | # endif |
| - | #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ |
| - | |
| - | |
| - | #if (! defined (yyoverflow) \ |
| - | && (! defined (__cplusplus) \ |
| - | || (YYSTYPE_IS_TRIVIAL))) |
| - | |
| - | /* A type that is properly aligned for any stack member. */ |
| - | union yyalloc |
| - | { |
| - | short yyss; |
| - | YYSTYPE yyvs; |
| - | }; |
| - | |
| - | /* The size of the maximum gap between one aligned stack and the next. */ |
| - | # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
| - | |
| - | /* The size of an array large to enough to hold all stacks, each with |
| - | N elements. */ |
| - | # define YYSTACK_BYTES(N) \ |
| - | ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ |
| - | + YYSTACK_GAP_MAXIMUM) |
| - | |
| - | /* Copy COUNT objects from FROM to TO. The source and destination do |
| - | not overlap. */ |
| - | # ifndef YYCOPY |
| - | # if 1 < __GNUC__ |
| - | # define YYCOPY(To, From, Count) \ |
| - | __builtin_memcpy (To, From, (Count) * sizeof (*(From))) |
| - | # else |
| - | # define YYCOPY(To, From, Count) \ |
| - | do \ |
| - | { \ |
| - | register YYSIZE_T yyi; \ |
| - | for (yyi = 0; yyi < (Count); yyi++) \ |
| - | (To)[yyi] = (From)[yyi]; \ |
| - | } \ |
| - | while (0) |
| - | # endif |
| - | # endif |
| - | |
| - | /* Relocate STACK from its old location to the new one. The |
| - | local variables YYSIZE and YYSTACKSIZE give the old and new number of |
| - | elements in the stack, and YYPTR gives the new location of the |
| - | stack. Advance YYPTR to a properly aligned location for the next |
| - | stack. */ |
| - | # define YYSTACK_RELOCATE(Stack) \ |
| - | do \ |
| - | { \ |
| - | YYSIZE_T yynewbytes; \ |
| - | YYCOPY (&yyptr->Stack, Stack, yysize); \ |
| - | Stack = &yyptr->Stack; \ |
| - | yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
| - | yyptr += yynewbytes / sizeof (*yyptr); \ |
| - | } \ |
| - | while (0) |
| - | |
| - | #endif |
| - | |
| - | #if defined (__STDC__) || defined (__cplusplus) |
| - | typedef signed char yysigned_char; |
| - | #else |
| - | typedef short yysigned_char; |
| - | #endif |
| - | |
| - | /* YYFINAL -- State number of the termination state. */ |
| - | #define YYFINAL 2 |
| - | /* YYLAST -- Last index in YYTABLE. */ |
| - | #define YYLAST 201 |
| - | |
| - | /* YYNTOKENS -- Number of terminals. */ |
| - | #define YYNTOKENS 42 |
| - | /* YYNNTS -- Number of nonterminals. */ |
| - | #define YYNNTS 41 |
| - | /* YYNRULES -- Number of rules. */ |
| - | #define YYNRULES 104 |
| - | /* YYNRULES -- Number of states. */ |
| - | #define YYNSTATES 182 |
| - | |
| - | /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
| - | #define YYUNDEFTOK 2 |
| - | #define YYMAXUTOK 296 |
| - | |
| - | #define YYTRANSLATE(YYX) \ |
| - | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
| - | |
| - | /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
| - | static const unsigned char yytranslate[] = |
| - | { |
| - | 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| - | 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, |
| - | 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
| - | 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, |
| - | 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, |
| - | 35, 36, 37, 38, 39, 40, 41 |
| - | }; |
| - | |
| - | #if YYDEBUG |
| - | /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
| - | YYRHS. */ |
| - | static const unsigned short yyprhs[] = |
| - | { |
| - | 0, 0, 3, 4, 7, 9, 11, 13, 17, 19, |
| - | 21, 23, 26, 28, 30, 32, 34, 36, 38, 42, |
| - | 45, 49, 52, 53, 56, 59, 62, 65, 69, 74, |
| - | 78, 83, 87, 91, 95, 100, 105, 110, 116, 119, |
| - | 122, 124, 128, 131, 132, 135, 138, 141, 144, 149, |
| - | 153, 157, 160, 165, 166, 169, 173, 175, 179, 182, |
| - | 183, 186, 189, 192, 196, 199, 201, 205, 208, 209, |
| - | 212, 215, 218, 222, 226, 228, 232, 235, 238, 241, |
| - | 242, 245, 248, 253, 257, 261, 262, 265, 267, 269, |
| - | 272, 275, 278, 280, 282, 283, 286, 288, 292, 296, |
| - | 300, 303, 307, 311, 313 |
| - | }; |
| - | |
| - | /* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
| - | static const yysigned_char yyrhs[] = |
| - | { |
| - | 43, 0, -1, -1, 43, 44, -1, 45, -1, 55, |
| - | -1, 66, -1, 3, 77, 79, -1, 5, -1, 15, |
| - | -1, 8, -1, 1, 79, -1, 61, -1, 71, -1, |
| - | 47, -1, 49, -1, 69, -1, 79, -1, 10, 28, |
| - | 32, -1, 46, 50, -1, 11, 28, 32, -1, 48, |
| - | 50, -1, -1, 50, 51, -1, 50, 75, -1, 50, |
| - | 73, -1, 50, 32, -1, 21, 76, 32, -1, 22, |
| - | 81, 80, 32, -1, 23, 76, 32, -1, 24, 81, |
| - | 80, 32, -1, 26, 76, 32, -1, 27, 76, 32, |
| - | -1, 25, 76, 32, -1, 19, 77, 80, 32, -1, |
| - | 20, 81, 80, 32, -1, 36, 28, 80, 32, -1, |
| - | 37, 82, 82, 80, 32, -1, 7, 32, -1, 52, |
| - | 56, -1, 78, -1, 53, 58, 54, -1, 53, 58, |
| - | -1, -1, 56, 57, -1, 56, 75, -1, 56, 73, |
| - | -1, 56, 32, -1, 19, 77, 80, 32, -1, 21, |
| - | 76, 32, -1, 23, 76, 32, -1, 18, 32, -1, |
| - | 20, 28, 80, 32, -1, -1, 58, 45, -1, 14, |
| - | 81, 32, -1, 78, -1, 59, 62, 60, -1, 59, |
| - | 62, -1, -1, 62, 45, -1, 62, 66, -1, 62, |
| - | 55, -1, 4, 77, 32, -1, 63, 74, -1, 78, |
| - | -1, 64, 67, 65, -1, 64, 67, -1, -1, 67, |
| - | 45, -1, 67, 66, -1, 67, 55, -1, 67, 1, |
| - | 32, -1, 6, 77, 32, -1, 68, -1, 9, 77, |
| - | 32, -1, 70, 74, -1, 12, 32, -1, 72, 13, |
| - | -1, -1, 74, 75, -1, 74, 32, -1, 16, 35, |
| - | 81, 32, -1, 16, 81, 32, -1, 17, 81, 32, |
| - | -1, -1, 77, 80, -1, 28, -1, 29, -1, 5, |
| - | 79, -1, 8, 79, -1, 15, 79, -1, 32, -1, |
| - | 31, -1, -1, 14, 81, -1, 82, -1, 82, 40, |
| - | 82, -1, 82, 30, 82, -1, 34, 81, 33, -1, |
| - | 41, 81, -1, 81, 38, 81, -1, 81, 39, 81, |
| - | -1, 28, -1, 29, -1 |
| - | }; |
| - | |
| - | /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
| - | static const unsigned short yyrline[] = |
| - | { |
| - | 0, 94, 94, 95, 98, 99, 100, 101, 102, 103, |
| - | 104, 105, 109, 110, 111, 112, 113, 114, 120, 128, |
| - | 134, 142, 152, 154, 155, 156, 157, 160, 166, 173, |
| - | 179, 186, 192, 198, 204, 210, 216, 222, 230, 239, |
| - | 245, 254, 255, 261, 263, 264, 265, 266, 269, 275, |
| - | 281, 287, 293, 299, 301, 306, 315, 324, 325, 331, |
| - | 333, 334, 335, 340, 347, 353, 362, 363, 369, 371, |
| - | 372, 373, 374, 377, 383, 390, 397, 404, 410, 417, |
| - | 418, 419, 422, 427, 432, 440, 442, 447, 448, 451, |
| - | 452, 453, 457, 457, 459, 460, 463, 464, 465, 466, |
| - | 467, 468, 469, 472, 473 |
| - | }; |
| - | #endif |
| - | |
| - | #if YYDEBUG || YYERROR_VERBOSE |
| - | /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
| - | First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
| - | static const char *const yytname[] = |
| - | { |
| - | "$end", "error", "$undefined", "T_MAINMENU", "T_MENU", "T_ENDMENU", |
| - | "T_SOURCE", "T_CHOICE", "T_ENDCHOICE", "T_COMMENT", "T_CONFIG", |
| - | "T_MENUCONFIG", "T_HELP", "T_HELPTEXT", "T_IF", "T_ENDIF", "T_DEPENDS", |
| - | "T_REQUIRES", "T_OPTIONAL", "T_PROMPT", "T_DEFAULT", "T_TRISTATE", |
| - | "T_DEF_TRISTATE", "T_BOOLEAN", "T_DEF_BOOLEAN", "T_STRING", "T_INT", |
| - | "T_HEX", "T_WORD", "T_WORD_QUOTE", "T_UNEQUAL", "T_EOF", "T_EOL", |
| - | "T_CLOSE_PAREN", "T_OPEN_PAREN", "T_ON", "T_SELECT", "T_RANGE", "T_OR", |
| - | "T_AND", "T_EQUAL", "T_NOT", "$accept", "input", "block", |
| - | "common_block", "config_entry_start", "config_stmt", |
| - | "menuconfig_entry_start", "menuconfig_stmt", "config_option_list", |
| - | "config_option", "choice", "choice_entry", "choice_end", "choice_stmt", |
| - | "choice_option_list", "choice_option", "choice_block", "if", "if_end", |
| - | "if_stmt", "if_block", "menu", "menu_entry", "menu_end", "menu_stmt", |
| - | "menu_block", "source", "source_stmt", "comment", "comment_stmt", |
| - | "help_start", "help", "depends_list", "depends", "prompt_stmt_opt", |
| - | "prompt", "end", "nl_or_eof", "if_expr", "expr", "symbol", 0 |
| - | }; |
| - | #endif |
| - | |
| - | # ifdef YYPRINT |
| - | /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
| - | token YYLEX-NUM. */ |
| - | static const unsigned short yytoknum[] = |
| - | { |
| - | 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, |
| - | 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, |
| - | 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, |
| - | 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, |
| - | 295, 296 |
| - | }; |
| - | # endif |
| - | |
| - | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
| - | static const unsigned char yyr1[] = |
| - | { |
| - | 0, 42, 43, 43, 44, 44, 44, 44, 44, 44, |
| - | 44, 44, 45, 45, 45, 45, 45, 45, 46, 47, |
| - | 48, 49, 50, 50, 50, 50, 50, 51, 51, 51, |
| - | 51, 51, 51, 51, 51, 51, 51, 51, 52, 53, |
| - | 54, 55, 55, 56, 56, 56, 56, 56, 57, 57, |
| - | 57, 57, 57, 58, 58, 59, 60, 61, 61, 62, |
| - | 62, 62, 62, 63, 64, 65, 66, 66, 67, 67, |
| - | 67, 67, 67, 68, 69, 70, 71, 72, 73, 74, |
| - | 74, 74, 75, 75, 75, 76, 76, 77, 77, 78, |
| - | 78, 78, 79, 79, 80, 80, 81, 81, 81, 81, |
| - | 81, 81, 81, 82, 82 |
| - | }; |
| - | |
| - | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
| - | static const unsigned char yyr2[] = |
| - | { |
| - | 0, 2, 0, 2, 1, 1, 1, 3, 1, 1, |
| - | 1, 2, 1, 1, 1, 1, 1, 1, 3, 2, |
| - | 3, 2, 0, 2, 2, 2, 2, 3, 4, 3, |
| - | 4, 3, 3, 3, 4, 4, 4, 5, 2, 2, |
| - | 1, 3, 2, 0, 2, 2, 2, 2, 4, 3, |
| - | 3, 2, 4, 0, 2, 3, 1, 3, 2, 0, |
| - | 2, 2, 2, 3, 2, 1, 3, 2, 0, 2, |
| - | 2, 2, 3, 3, 1, 3, 2, 2, 2, 0, |
| - | 2, 2, 4, 3, 3, 0, 2, 1, 1, 2, |
| - | 2, 2, 1, 1, 0, 2, 1, 3, 3, 3, |
| - | 2, 3, 3, 1, 1 |
| - | }; |
| - | |
| - | /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state |
| - | STATE-NUM when YYTABLE doesn't specify something else to do. Zero |
| - | means the default is an error. */ |
| - | static const unsigned char yydefact[] = |
| - | { |
| - | 2, 0, 1, 0, 0, 0, 8, 0, 0, 10, |
| - | 0, 0, 0, 0, 9, 93, 92, 3, 4, 22, |
| - | 14, 22, 15, 43, 53, 5, 59, 12, 79, 68, |
| - | 6, 74, 16, 79, 13, 17, 11, 87, 88, 0, |
| - | 0, 0, 38, 0, 0, 0, 103, 104, 0, 0, |
| - | 0, 96, 19, 21, 39, 42, 58, 64, 0, 76, |
| - | 7, 63, 73, 75, 18, 20, 0, 100, 55, 0, |
| - | 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, |
| - | 85, 0, 85, 85, 85, 26, 0, 0, 23, 0, |
| - | 25, 24, 0, 0, 0, 85, 85, 47, 44, 46, |
| - | 45, 0, 0, 0, 54, 41, 40, 60, 62, 57, |
| - | 61, 56, 81, 80, 0, 69, 71, 66, 70, 65, |
| - | 99, 101, 102, 98, 97, 77, 0, 0, 0, 94, |
| - | 94, 0, 94, 94, 0, 94, 0, 0, 0, 94, |
| - | 0, 78, 51, 94, 94, 0, 0, 89, 90, 91, |
| - | 72, 0, 83, 84, 0, 0, 0, 27, 86, 0, |
| - | 29, 0, 33, 31, 32, 0, 94, 0, 0, 49, |
| - | 50, 82, 95, 34, 35, 28, 30, 36, 0, 48, |
| - | 52, 37 |
| - | }; |
| - | |
| - | /* YYDEFGOTO[NTERM-NUM]. */ |
| - | static const short yydefgoto[] = |
| - | { |
| - | -1, 1, 17, 18, 19, 20, 21, 22, 52, 88, |
| - | 23, 24, 105, 25, 54, 98, 55, 26, 109, 27, |
| - | 56, 28, 29, 117, 30, 58, 31, 32, 33, 34, |
| - | 89, 90, 57, 91, 131, 132, 106, 35, 155, 50, |
| - | 51 |
| - | }; |
| - | |
| - | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
| - | STATE-NUM. */ |
| - | #define YYPACT_NINF -99 |
| - | static const short yypact[] = |
| - | { |
| - | -99, 48, -99, 38, 46, 46, -99, 46, -29, -99, |
| - | 46, -17, -3, -11, -99, -99, -99, -99, -99, -99, |
| - | -99, -99, -99, -99, -99, -99, -99, -99, -99, -99, |
| - | -99, -99, -99, -99, -99, -99, -99, -99, -99, 38, |
| - | 12, 15, -99, 18, 51, 62, -99, -99, -11, -11, |
| - | 4, -24, 138, 138, 160, 121, 110, -4, 81, -4, |
| - | -99, -99, -99, -99, -99, -99, -19, -99, -99, -11, |
| - | -11, 70, 70, 73, 32, -11, 46, -11, 46, -11, |
| - | 46, -11, 46, 46, 46, -99, 36, 70, -99, 95, |
| - | -99, -99, 96, 46, 106, 46, 46, -99, -99, -99, |
| - | -99, 38, 38, 38, -99, -99, -99, -99, -99, -99, |
| - | -99, -99, -99, -99, 112, -99, -99, -99, -99, -99, |
| - | -99, 117, -99, -99, -99, -99, -11, 33, 65, 131, |
| - | 1, 119, 131, 1, 136, 1, 153, 154, 155, 131, |
| - | 70, -99, -99, 131, 131, 156, 157, -99, -99, -99, |
| - | -99, 101, -99, -99, -11, 158, 159, -99, -99, 161, |
| - | -99, 162, -99, -99, -99, 163, 131, 164, 165, -99, |
| - | -99, -99, 99, -99, -99, -99, -99, -99, 166, -99, |
| - | -99, -99 |
| - | }; |
| - | |
| - | /* YYPGOTO[NTERM-NUM]. */ |
| - | static const short yypgoto[] = |
| - | { |
| - | -99, -99, -99, 111, -99, -99, -99, -99, 178, -99, |
| - | -99, -99, -99, 91, -99, -99, -99, -99, -99, -99, |
| - | -99, -99, -99, -99, 115, -99, -99, -99, -99, -99, |
| - | -99, 146, 168, 89, 27, 0, 126, -1, -98, -48, |
| - | -63 |
| - | }; |
| - | |
| - | /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
| - | positive, shift that token. If negative, reduce the rule which |
| - | number is the opposite. If zero, do what YYDEFACT says. |
| - | If YYTABLE_NINF, syntax error. */ |
| - | #define YYTABLE_NINF -68 |
| - | static const short yytable[] = |
| - | { |
| - | 66, 67, 36, 42, 39, 40, 71, 41, 123, 124, |
| - | 43, 44, 74, 75, 120, 154, 72, 46, 47, 69, |
| - | 70, 121, 122, 48, 140, 45, 127, 128, 112, 130, |
| - | 49, 133, 156, 135, 158, 159, 68, 161, 60, 69, |
| - | 70, 165, 69, 70, 61, 167, 168, 62, 2, 3, |
| - | 63, 4, 5, 6, 7, 8, 9, 10, 11, 12, |
| - | 46, 47, 13, 14, 139, 152, 48, 126, 178, 15, |
| - | 16, 69, 70, 49, 37, 38, 129, 166, 151, 15, |
| - | 16, -67, 114, 64, -67, 5, 101, 7, 8, 102, |
| - | 10, 11, 12, 143, 65, 13, 103, 153, 46, 47, |
| - | 147, 148, 149, 69, 70, 125, 172, 134, 141, 136, |
| - | 137, 138, 15, 16, 5, 101, 7, 8, 102, 10, |
| - | 11, 12, 145, 146, 13, 103, 101, 7, 142, 102, |
| - | 10, 11, 12, 171, 144, 13, 103, 69, 70, 69, |
| - | 70, 15, 16, 100, 150, 154, 113, 108, 113, 116, |
| - | 73, 157, 15, 16, 74, 75, 70, 76, 77, 78, |
| - | 79, 80, 81, 82, 83, 84, 104, 107, 160, 115, |
| - | 85, 110, 73, 118, 86, 87, 74, 75, 92, 93, |
| - | 94, 95, 111, 96, 119, 162, 163, 164, 169, 170, |
| - | 173, 174, 97, 175, 176, 177, 179, 180, 181, 53, |
| - | 99, 59 |
| - | }; |
| - | |
| - | static const unsigned char yycheck[] = |
| - | { |
| - | 48, 49, 3, 32, 4, 5, 30, 7, 71, 72, |
| - | 10, 28, 16, 17, 33, 14, 40, 28, 29, 38, |
| - | 39, 69, 70, 34, 87, 28, 74, 75, 32, 77, |
| - | 41, 79, 130, 81, 132, 133, 32, 135, 39, 38, |
| - | 39, 139, 38, 39, 32, 143, 144, 32, 0, 1, |
| - | 32, 3, 4, 5, 6, 7, 8, 9, 10, 11, |
| - | 28, 29, 14, 15, 28, 32, 34, 35, 166, 31, |
| - | 32, 38, 39, 41, 28, 29, 76, 140, 126, 31, |
| - | 32, 0, 1, 32, 3, 4, 5, 6, 7, 8, |
| - | 9, 10, 11, 93, 32, 14, 15, 32, 28, 29, |
| - | 101, 102, 103, 38, 39, 32, 154, 80, 13, 82, |
| - | 83, 84, 31, 32, 4, 5, 6, 7, 8, 9, |
| - | 10, 11, 95, 96, 14, 15, 5, 6, 32, 8, |
| - | 9, 10, 11, 32, 28, 14, 15, 38, 39, 38, |
| - | 39, 31, 32, 54, 32, 14, 57, 56, 59, 58, |
| - | 12, 32, 31, 32, 16, 17, 39, 19, 20, 21, |
| - | 22, 23, 24, 25, 26, 27, 55, 56, 32, 58, |
| - | 32, 56, 12, 58, 36, 37, 16, 17, 18, 19, |
| - | 20, 21, 56, 23, 58, 32, 32, 32, 32, 32, |
| - | 32, 32, 32, 32, 32, 32, 32, 32, 32, 21, |
| - | 54, 33 |
| - | }; |
| - | |
| - | /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
| - | symbol of state STATE-NUM. */ |
| - | static const unsigned char yystos[] = |
| - | { |
| - | 0, 43, 0, 1, 3, 4, 5, 6, 7, 8, |
| - | 9, 10, 11, 14, 15, 31, 32, 44, 45, 46, |
| - | 47, 48, 49, 52, 53, 55, 59, 61, 63, 64, |
| - | 66, 68, 69, 70, 71, 79, 79, 28, 29, 77, |
| - | 77, 77, 32, 77, 28, 28, 28, 29, 34, 41, |
| - | 81, 82, 50, 50, 56, 58, 62, 74, 67, 74, |
| - | 79, 32, 32, 32, 32, 32, 81, 81, 32, 38, |
| - | 39, 30, 40, 12, 16, 17, 19, 20, 21, 22, |
| - | 23, 24, 25, 26, 27, 32, 36, 37, 51, 72, |
| - | 73, 75, 18, 19, 20, 21, 23, 32, 57, 73, |
| - | 75, 5, 8, 15, 45, 54, 78, 45, 55, 60, |
| - | 66, 78, 32, 75, 1, 45, 55, 65, 66, 78, |
| - | 33, 81, 81, 82, 82, 32, 35, 81, 81, 77, |
| - | 81, 76, 77, 81, 76, 81, 76, 76, 76, 28, |
| - | 82, 13, 32, 77, 28, 76, 76, 79, 79, 79, |
| - | 32, 81, 32, 32, 14, 80, 80, 32, 80, 80, |
| - | 32, 80, 32, 32, 32, 80, 82, 80, 80, 32, |
| - | 32, 32, 81, 32, 32, 32, 32, 32, 80, 32, |
| - | 32, 32 |
| - | }; |
| - | |
| - | #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) |
| - | # define YYSIZE_T __SIZE_TYPE__ |
| - | #endif |
| - | #if ! defined (YYSIZE_T) && defined (size_t) |
| - | # define YYSIZE_T size_t |
| - | #endif |
| - | #if ! defined (YYSIZE_T) |
| - | # if defined (__STDC__) || defined (__cplusplus) |
| - | # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
| - | # define YYSIZE_T size_t |
| - | # endif |
| - | #endif |
| - | #if ! defined (YYSIZE_T) |
| - | # define YYSIZE_T unsigned int |
| - | #endif |
| - | |
| - | #define yyerrok (yyerrstatus = 0) |
| - | #define yyclearin (yychar = YYEMPTY) |
| - | #define YYEMPTY (-2) |
| - | #define YYEOF 0 |
| - | |
| - | #define YYACCEPT goto yyacceptlab |
| - | #define YYABORT goto yyabortlab |
| - | #define YYERROR goto yyerrlab1 |
| - | |
| - | |
| - | /* Like YYERROR except do call yyerror. This remains here temporarily |
| - | to ease the transition to the new meaning of YYERROR, for GCC. |
| - | Once GCC version 2 has supplanted version 1, this can go. */ |
| - | |
| - | #define YYFAIL goto yyerrlab |
| - | |
| - | #define YYRECOVERING() (!!yyerrstatus) |
| - | |
| - | #define YYBACKUP(Token, Value) \ |
| - | do \ |
| - | if (yychar == YYEMPTY && yylen == 1) \ |
| - | { \ |
| - | yychar = (Token); \ |
| - | yylval = (Value); \ |
| - | yytoken = YYTRANSLATE (yychar); \ |
| - | YYPOPSTACK; \ |
| - | goto yybackup; \ |
| - | } \ |
| - | else \ |
| - | { \ |
| - | yyerror ("syntax error: cannot back up");\ |
| - | YYERROR; \ |
| - | } \ |
| - | while (0) |
| - | |
| - | #define YYTERROR 1 |
| - | #define YYERRCODE 256 |
| - | |
| - | /* YYLLOC_DEFAULT -- Compute the default location (before the actions |
| - | are run). */ |
| - | |
| - | #ifndef YYLLOC_DEFAULT |
| - | # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
| - | Current.first_line = Rhs[1].first_line; \ |
| - | Current.first_column = Rhs[1].first_column; \ |
| - | Current.last_line = Rhs[N].last_line; \ |
| - | Current.last_column = Rhs[N].last_column; |
| - | #endif |
| - | |
| - | /* YYLEX -- calling `yylex' with the right arguments. */ |
| - | |
| - | #ifdef YYLEX_PARAM |
| - | # define YYLEX yylex (YYLEX_PARAM) |
| - | #else |
| - | # define YYLEX yylex () |
| - | #endif |
| - | |
| - | /* Enable debugging if requested. */ |
| - | #if YYDEBUG |
| - | |
| - | # ifndef YYFPRINTF |
| - | # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
| - | # define YYFPRINTF fprintf |
| - | # endif |
| - | |
| - | # define YYDPRINTF(Args) \ |
| - | do { \ |
| - | if (yydebug) \ |
| - | YYFPRINTF Args; \ |
| - | } while (0) |
| - | |
| - | # define YYDSYMPRINT(Args) \ |
| - | do { \ |
| - | if (yydebug) \ |
| - | yysymprint Args; \ |
| - | } while (0) |
| - | |
| - | # define YYDSYMPRINTF(Title, Token, Value, Location) \ |
| - | do { \ |
| - | if (yydebug) \ |
| - | { \ |
| - | YYFPRINTF (stderr, "%s ", Title); \ |
| - | yysymprint (stderr, \ |
| - | Token, Value); \ |
| - | YYFPRINTF (stderr, "\n"); \ |
| - | } \ |
| - | } while (0) |
| - | |
| - | /*------------------------------------------------------------------. |
| - | | yy_stack_print -- Print the state stack from its BOTTOM up to its | |
| - | | TOP (cinluded). | |
| - | `------------------------------------------------------------------*/ |
| - | |
| - | #if defined (__STDC__) || defined (__cplusplus) |
| - | static void |
| - | yy_stack_print (short *bottom, short *top) |
| - | #else |
| - | static void |
| - | yy_stack_print (bottom, top) |
| - | short *bottom; |
| - | short *top; |
| - | #endif |
| - | { |
| - | YYFPRINTF (stderr, "Stack now"); |
| - | for (/* Nothing. */; bottom <= top; ++bottom) |
| - | YYFPRINTF (stderr, " %d", *bottom); |
| - | YYFPRINTF (stderr, "\n"); |
| - | } |
| - | |
| - | # define YY_STACK_PRINT(Bottom, Top) \ |
| - | do { \ |
| - | if (yydebug) \ |
| - | yy_stack_print ((Bottom), (Top)); \ |
| - | } while (0) |
| - | |
| - | |
| - | /*------------------------------------------------. |
| - | | Report that the YYRULE is going to be reduced. | |
| - | `------------------------------------------------*/ |
| - | |
| - | #if defined (__STDC__) || defined (__cplusplus) |
| - | static void |
| - | yy_reduce_print (int yyrule) |
| - | #else |
| - | static void |
| - | yy_reduce_print (yyrule) |
| - | int yyrule; |
| - | #endif |
| - | { |
| - | int yyi; |
| - | unsigned int yylineno = yyrline[yyrule]; |
| - | YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", |
| - | yyrule - 1, yylineno); |
| - | /* Print the symbols being reduced, and their result. */ |
| - | for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) |
| - | YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); |
| - | YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); |
| - | } |
| - | |
| - | # define YY_REDUCE_PRINT(Rule) \ |
| - | do { \ |
| - | if (yydebug) \ |
| - | yy_reduce_print (Rule); \ |
| - | } while (0) |
| - | |
| - | /* Nonzero means print parse trace. It is left uninitialized so that |
| - | multiple parsers can coexist. */ |
| - | int yydebug; |
| - | #else /* !YYDEBUG */ |
| - | # define YYDPRINTF(Args) |
| - | # define YYDSYMPRINT(Args) |
| - | # define YYDSYMPRINTF(Title, Token, Value, Location) |
| - | # define YY_STACK_PRINT(Bottom, Top) |
| - | # define YY_REDUCE_PRINT(Rule) |
| - | #endif /* !YYDEBUG */ |
| - | |
| - | |
| - | /* YYINITDEPTH -- initial size of the parser's stacks. */ |
| - | #ifndef YYINITDEPTH |
| - | # define YYINITDEPTH 200 |
| - | #endif |
| - | |
| - | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
| - | if the built-in stack extension method is used). |
| - | |
| - | Do not make this value too large; the results are undefined if |
| - | SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) |
| - | evaluated with infinite-precision integer arithmetic. */ |
| - | |
| - | #if YYMAXDEPTH == 0 |
| - | # undef YYMAXDEPTH |
| - | #endif |
| - | |
| - | #ifndef YYMAXDEPTH |
| - | # define YYMAXDEPTH 10000 |
| - | #endif |
| - | |
| - | |
| - | |
| - | #if YYERROR_VERBOSE |
| - | |
| - | # ifndef yystrlen |
| - | # if defined (__GLIBC__) && defined (_STRING_H) |
| - | # define yystrlen strlen |
| - | # else |
| - | /* Return the length of YYSTR. */ |
| - | static YYSIZE_T |
| - | # if defined (__STDC__) || defined (__cplusplus) |
| - | yystrlen (const char *yystr) |
| - | # else |
| - | yystrlen (yystr) |
| - | const char *yystr; |
| - | # endif |
| - | { |
| - | register const char *yys = yystr; |
| - | |
| - | while (*yys++ != '\0') |
| - | continue; |
| - | |
| - | return yys - yystr - 1; |
| - | } |
| - | # endif |
| - | # endif |
| - | |
| - | # ifndef yystpcpy |
| - | # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) |
| - | # define yystpcpy stpcpy |
| - | # else |
| - | /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in |
| - | YYDEST. */ |
| - | static char * |
| - | # if defined (__STDC__) || defined (__cplusplus) |
| - | yystpcpy (char *yydest, const char *yysrc) |
| - | # else |
| - | yystpcpy (yydest, yysrc) |
| - | char *yydest; |
| - | const char *yysrc; |
| - | # endif |
| - | { |
| - | register char *yyd = yydest; |
| - | register const char *yys = yysrc; |
| - | |
| - | while ((*yyd++ = *yys++) != '\0') |
| - | continue; |
| - | |
| - | return yyd - 1; |
| - | } |
| - | # endif |
| - | # endif |
| - | |
| - | #endif /* !YYERROR_VERBOSE */ |
| - | |
| - | |
| - | |
| - | #if YYDEBUG |
| - | /*--------------------------------. |
| - | | Print this symbol on YYOUTPUT. | |
| - | `--------------------------------*/ |
| - | |
| - | #if defined (__STDC__) || defined (__cplusplus) |
| - | static void |
| - | yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) |
| - | #else |
| - | static void |
| - | yysymprint (yyoutput, yytype, yyvaluep) |
| - | FILE *yyoutput; |
| - | int yytype; |
| - | YYSTYPE *yyvaluep; |
| - | #endif |
| - | { |
| - | /* Pacify ``unused variable'' warnings. */ |
| - | (void) yyvaluep; |
| - | |
| - | if (yytype < YYNTOKENS) |
| - | { |
| - | YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
| - | # ifdef YYPRINT |
| - | YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); |
| - | # endif |
| - | } |
| - | else |
| - | YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
| - | |
| - | switch (yytype) |
| - | { |
| - | default: |
| - | break; |
| - | } |
| - | YYFPRINTF (yyoutput, ")"); |
| - | } |
| - | |
| - | #endif /* ! YYDEBUG */ |
| - | /*-----------------------------------------------. |
| - | | Release the memory associated to this symbol. | |
| - | `-----------------------------------------------*/ |
| - | |
| - | #if defined (__STDC__) || defined (__cplusplus) |
| - | static void |
| - | yydestruct (int yytype, YYSTYPE *yyvaluep) |
| - | #else |
| - | static void |
| - | yydestruct (yytype, yyvaluep) |
| - | int yytype; |
| - | YYSTYPE *yyvaluep; |
| - | #endif |
| - | { |
| - | /* Pacify ``unused variable'' warnings. */ |
| - | (void) yyvaluep; |
| - | |
| - | switch (yytype) |
| - | { |
| - | |
| - | default: |
| - | break; |
| - | } |
| - | } |
| - | |
| - | |
| - | /* Prevent warnings from -Wmissing-prototypes. */ |
| - | |
| - | #ifdef YYPARSE_PARAM |
| - | # if defined (__STDC__) || defined (__cplusplus) |
| - | int yyparse (void *YYPARSE_PARAM); |
| - | # else |
| - | int yyparse (); |
| - | # endif |
| - | #else /* ! YYPARSE_PARAM */ |
| - | #if defined (__STDC__) || defined (__cplusplus) |
| - | int yyparse (void); |
| - | #else |
| - | int yyparse (); |
| - | #endif |
| - | #endif /* ! YYPARSE_PARAM */ |
| - | |
| - | |
| - | |
| - | /* The lookahead symbol. */ |
| - | int yychar; |
| - | |
| - | /* The semantic value of the lookahead symbol. */ |
| - | YYSTYPE yylval; |
| - | |
| - | /* Number of syntax errors so far. */ |
| - | int yynerrs; |
| - | |
| - | |
| - | |
| - | /*----------. |
| - | | yyparse. | |
| - | `----------*/ |
| - | |
| - | #ifdef YYPARSE_PARAM |
| - | # if defined (__STDC__) || defined (__cplusplus) |
| - | int yyparse (void *YYPARSE_PARAM) |
| - | # else |
| - | int yyparse (YYPARSE_PARAM) |
| - | void *YYPARSE_PARAM; |
| - | # endif |
| - | #else /* ! YYPARSE_PARAM */ |
| - | #if defined (__STDC__) || defined (__cplusplus) |
| - | int |
| - | yyparse (void) |
| - | #else |
| - | int |
| - | yyparse () |
| - | |
| - | #endif |
| - | #endif |
| - | { |
| - | |
| - | register int yystate; |
| - | register int yyn; |
| - | int yyresult; |
| - | /* Number of tokens to shift before error messages enabled. */ |
| - | int yyerrstatus; |
| - | /* Lookahead token as an internal (translated) token number. */ |
| - | int yytoken = 0; |
| - | |
| - | /* Three stacks and their tools: |
| - | `yyss': related to states, |
| - | `yyvs': related to semantic values, |
| - | `yyls': related to locations. |
| - | |
| - | Refer to the stacks thru separate pointers, to allow yyoverflow |
| - | to reallocate them elsewhere. */ |
| - | |
| - | /* The state stack. */ |
| - | short yyssa[YYINITDEPTH]; |
| - | short *yyss = yyssa; |
| - | register short *yyssp; |
| - | |
| - | /* The semantic value stack. */ |
| - | YYSTYPE yyvsa[YYINITDEPTH]; |
| - | YYSTYPE *yyvs = yyvsa; |
| - | register YYSTYPE *yyvsp; |
| - | |
| - | |
| - | |
| - | #define YYPOPSTACK (yyvsp--, yyssp--) |
| - | |
| - | YYSIZE_T yystacksize = YYINITDEPTH; |
| - | |
| - | /* The variables used to return semantic value and location from the |
| - | action routines. */ |
| - | YYSTYPE yyval; |
| - | |
| - | |
| - | /* When reducing, the number of symbols on the RHS of the reduced |
| - | rule. */ |
| - | int yylen; |
| - | |
| - | YYDPRINTF ((stderr, "Starting parse\n")); |
| - | |
| - | yystate = 0; |
| - | yyerrstatus = 0; |
| - | yynerrs = 0; |
| - | yychar = YYEMPTY; /* Cause a token to be read. */ |
| - | |
| - | /* Initialize stack pointers. |
| - | Waste one element of value and location stack |
| - | so that they stay on the same level as the state stack. |
| - | The wasted elements are never initialized. */ |
| - | |
| - | yyssp = yyss; |
| - | yyvsp = yyvs; |
| - | |
| - | goto yysetstate; |
| - | |
| - | /*------------------------------------------------------------. |
| - | | yynewstate -- Push a new state, which is found in yystate. | |
| - | `------------------------------------------------------------*/ |
| - | yynewstate: |
| - | /* In all cases, when you get here, the value and location stacks |
| - | have just been pushed. so pushing a state here evens the stacks. |
| - | */ |
| - | yyssp++; |
| - | |
| - | yysetstate: |
| - | *yyssp = yystate; |
| - | |
| - | if (yyss + yystacksize - 1 <= yyssp) |
| - | { |
| - | /* Get the current used size of the three stacks, in elements. */ |
| - | YYSIZE_T yysize = yyssp - yyss + 1; |
| - | |
| - | #ifdef yyoverflow |
| - | { |
| - | /* Give user a chance to reallocate the stack. Use copies of |
| - | these so that the &'s don't force the real ones into |
| - | memory. */ |
| - | YYSTYPE *yyvs1 = yyvs; |
| - | short *yyss1 = yyss; |
| - | |
| - | |
| - | /* Each stack pointer address is followed by the size of the |
| - | data in use in that stack, in bytes. This used to be a |
| - | conditional around just the two extra args, but that might |
| - | be undefined if yyoverflow is a macro. */ |
| - | yyoverflow ("parser stack overflow", |
| - | &yyss1, yysize * sizeof (*yyssp), |
| - | &yyvs1, yysize * sizeof (*yyvsp), |
| - | |
| - | &yystacksize); |
| - | |
| - | yyss = yyss1; |
| - | yyvs = yyvs1; |
| - | } |
| - | #else /* no yyoverflow */ |
| - | # ifndef YYSTACK_RELOCATE |
| - | goto yyoverflowlab; |
| - | # else |
| - | /* Extend the stack our own way. */ |
| - | if (YYMAXDEPTH <= yystacksize) |
| - | goto yyoverflowlab; |
| - | yystacksize *= 2; |
| - | if (YYMAXDEPTH < yystacksize) |
| - | yystacksize = YYMAXDEPTH; |
| - | |
| - | { |
| - | short *yyss1 = yyss; |
| - | union yyalloc *yyptr = |
| - | (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
| - | if (! yyptr) |
| - | goto yyoverflowlab; |
| - | YYSTACK_RELOCATE (yyss); |
| - | YYSTACK_RELOCATE (yyvs); |
| - | |
| - | # undef YYSTACK_RELOCATE |
| - | if (yyss1 != yyssa) |
| - | YYSTACK_FREE (yyss1); |
| - | } |
| - | # endif |
| - | #endif /* no yyoverflow */ |
| - | |
| - | yyssp = yyss + yysize - 1; |
| - | yyvsp = yyvs + yysize - 1; |
| - | |
| - | |
| - | YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
| - | (unsigned long int) yystacksize)); |
| - | |
| - | if (yyss + yystacksize - 1 <= yyssp) |
| - | YYABORT; |
| - | } |
| - | |
| - | YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
| - | |
| - | goto yybackup; |
| - | |
| - | /*-----------. |
| - | | yybackup. | |
| - | `-----------*/ |
| - | yybackup: |
| - | |
| - | /* Do appropriate processing given the current state. */ |
| - | /* Read a lookahead token if we need one and don't already have one. */ |
| - | /* yyresume: */ |
| - | |
| - | /* First try to decide what to do without reference to lookahead token. */ |
| - | |
| - | yyn = yypact[yystate]; |
| - | if (yyn == YYPACT_NINF) |
| - | goto yydefault; |
| - | |
| - | /* Not known => get a lookahead token if don't already have one. */ |
| - | |
| - | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ |
| - | if (yychar == YYEMPTY) |
| - | { |
| - | YYDPRINTF ((stderr, "Reading a token: ")); |
| - | yychar = YYLEX; |
| - | } |
| - | |
| - | if (yychar <= YYEOF) |
| - | { |
| - | yychar = yytoken = YYEOF; |
| - | YYDPRINTF ((stderr, "Now at end of input.\n")); |
| - | } |
| - | else |
| - | { |
| - | yytoken = YYTRANSLATE (yychar); |
| - | YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); |
| - | } |
| - | |
| - | /* If the proper action on seeing token YYTOKEN is to reduce or to |
| - | detect an error, take that action. */ |
| - | yyn += yytoken; |
| - | if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) |
| - | goto yydefault; |
| - | yyn = yytable[yyn]; |
| - | if (yyn <= 0) |
| - | { |
| - | if (yyn == 0 || yyn == YYTABLE_NINF) |
| - | goto yyerrlab; |
| - | yyn = -yyn; |
| - | goto yyreduce; |
| - | } |
| - | |
| - | if (yyn == YYFINAL) |
| - | YYACCEPT; |
| - | |
| - | /* Shift the lookahead token. */ |
| - | YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); |
| - | |
| - | /* Discard the token being shifted unless it is eof. */ |
| - | if (yychar != YYEOF) |
| - | yychar = YYEMPTY; |
| - | |
| - | *++yyvsp = yylval; |
| - | |
| - | |
| - | /* Count tokens shifted since error; after three, turn off error |
| - | status. */ |
| - | if (yyerrstatus) |
| - | yyerrstatus--; |
| - | |
| - | yystate = yyn; |
| - | goto yynewstate; |
| - | |
| - | |
| - | /*-----------------------------------------------------------. |
| - | | yydefault -- do the default action for the current state. | |
| - | `-----------------------------------------------------------*/ |
| - | yydefault: |
| - | yyn = yydefact[yystate]; |
| - | if (yyn == 0) |
| - | goto yyerrlab; |
| - | goto yyreduce; |
| - | |
| - | |
| - | /*-----------------------------. |
| - | | yyreduce -- Do a reduction. | |
| - | `-----------------------------*/ |
| - | yyreduce: |
| - | /* yyn is the number of a rule to reduce with. */ |
| - | yylen = yyr2[yyn]; |
| - | |
| - | /* If YYLEN is nonzero, implement the default value of the action: |
| - | `$$ = $1'. |
| - | |
| - | Otherwise, the following line sets YYVAL to garbage. |
| - | This behavior is undocumented and Bison |
| - | users should not rely upon it. Assigning to YYVAL |
| - | unconditionally makes the parser a bit smaller, and it avoids a |
| - | GCC warning that YYVAL may be used uninitialized. */ |
| - | yyval = yyvsp[1-yylen]; |
| - | |
| - | |
| - | YY_REDUCE_PRINT (yyn); |
| - | switch (yyn) |
| - | { |
| - | case 8: |
| - | |
| - | { zconfprint("unexpected 'endmenu' statement"); ;} |
| - | break; |
| - | |
| - | case 9: |
| - | |
| - | { zconfprint("unexpected 'endif' statement"); ;} |
| - | break; |
| - | |
| - | case 10: |
| - | |
| - | { zconfprint("unexpected 'endchoice' statement"); ;} |
| - | break; |
| - | |
| - | case 11: |
| - | |
| - | { zconfprint("syntax error"); yyerrok; ;} |
| - | break; |
| - | |
| - | case 18: |
| - | |
| - | { |
| - | struct symbol *sym = sym_lookup(yyvsp[-1].string, 0); |
| - | sym->flags |= SYMBOL_OPTIONAL; |
| - | menu_add_entry(sym); |
| - | printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), yyvsp[-1].string); |
| - | ;} |
| - | break; |
| - | |
| - | case 19: |
| - | |
| - | { |
| - | menu_end_entry(); |
| - | printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 20: |
| - | |
| - | { |
| - | struct symbol *sym = sym_lookup(yyvsp[-1].string, 0); |
| - | sym->flags |= SYMBOL_OPTIONAL; |
| - | menu_add_entry(sym); |
| - | printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), yyvsp[-1].string); |
| - | ;} |
| - | break; |
| - | |
| - | case 21: |
| - | |
| - | { |
| - | if (current_entry->prompt) |
| - | current_entry->prompt->type = P_MENU; |
| - | else |
| - | zconfprint("warning: menuconfig statement without prompt"); |
| - | menu_end_entry(); |
| - | printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 27: |
| - | |
| - | { |
| - | menu_set_type(S_TRISTATE); |
| - | printd(DEBUG_PARSE, "%s:%d:tristate\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 28: |
| - | |
| - | { |
| - | menu_add_expr(P_DEFAULT, yyvsp[-2].expr, yyvsp[-1].expr); |
| - | menu_set_type(S_TRISTATE); |
| - | printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 29: |
| - | |
| - | { |
| - | menu_set_type(S_BOOLEAN); |
| - | printd(DEBUG_PARSE, "%s:%d:boolean\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 30: |
| - | |
| - | { |
| - | menu_add_expr(P_DEFAULT, yyvsp[-2].expr, yyvsp[-1].expr); |
| - | menu_set_type(S_BOOLEAN); |
| - | printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 31: |
| - | |
| - | { |
| - | menu_set_type(S_INT); |
| - | printd(DEBUG_PARSE, "%s:%d:int\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 32: |
| - | |
| - | { |
| - | menu_set_type(S_HEX); |
| - | printd(DEBUG_PARSE, "%s:%d:hex\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 33: |
| - | |
| - | { |
| - | menu_set_type(S_STRING); |
| - | printd(DEBUG_PARSE, "%s:%d:string\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 34: |
| - | |
| - | { |
| - | menu_add_prompt(P_PROMPT, yyvsp[-2].string, yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 35: |
| - | |
| - | { |
| - | menu_add_expr(P_DEFAULT, yyvsp[-2].expr, yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 36: |
| - | |
| - | { |
| - | menu_add_symbol(P_SELECT, sym_lookup(yyvsp[-2].string, 0), yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 37: |
| - | |
| - | { |
| - | menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,yyvsp[-3].symbol, yyvsp[-2].symbol), yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 38: |
| - | |
| - | { |
| - | struct symbol *sym = sym_lookup(NULL, 0); |
| - | sym->flags |= SYMBOL_CHOICE; |
| - | menu_add_entry(sym); |
| - | menu_add_expr(P_CHOICE, NULL, NULL); |
| - | printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 39: |
| - | |
| - | { |
| - | menu_end_entry(); |
| - | menu_add_menu(); |
| - | ;} |
| - | break; |
| - | |
| - | case 40: |
| - | |
| - | { |
| - | if (zconf_endtoken(yyvsp[0].token, T_CHOICE, T_ENDCHOICE)) { |
| - | menu_end_menu(); |
| - | printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | ;} |
| - | break; |
| - | |
| - | case 42: |
| - | |
| - | { |
| - | printf("%s:%d: missing 'endchoice' for this 'choice' statement\n", current_menu->file->name, current_menu->lineno); |
| - | zconfnerrs++; |
| - | ;} |
| - | break; |
| - | |
| - | case 48: |
| - | |
| - | { |
| - | menu_add_prompt(P_PROMPT, yyvsp[-2].string, yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 49: |
| - | |
| - | { |
| - | menu_set_type(S_TRISTATE); |
| - | printd(DEBUG_PARSE, "%s:%d:tristate\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 50: |
| - | |
| - | { |
| - | menu_set_type(S_BOOLEAN); |
| - | printd(DEBUG_PARSE, "%s:%d:boolean\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 51: |
| - | |
| - | { |
| - | current_entry->sym->flags |= SYMBOL_OPTIONAL; |
| - | printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 52: |
| - | |
| - | { |
| - | menu_add_symbol(P_DEFAULT, sym_lookup(yyvsp[-2].string, 0), yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 55: |
| - | |
| - | { |
| - | printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno()); |
| - | menu_add_entry(NULL); |
| - | menu_add_dep(yyvsp[-1].expr); |
| - | menu_end_entry(); |
| - | menu_add_menu(); |
| - | ;} |
| - | break; |
| - | |
| - | case 56: |
| - | |
| - | { |
| - | if (zconf_endtoken(yyvsp[0].token, T_IF, T_ENDIF)) { |
| - | menu_end_menu(); |
| - | printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | ;} |
| - | break; |
| - | |
| - | case 58: |
| - | |
| - | { |
| - | printf("%s:%d: missing 'endif' for this 'if' statement\n", current_menu->file->name, current_menu->lineno); |
| - | zconfnerrs++; |
| - | ;} |
| - | break; |
| - | |
| - | case 63: |
| - | |
| - | { |
| - | menu_add_entry(NULL); |
| - | menu_add_prop(P_MENU, yyvsp[-1].string, NULL, NULL); |
| - | printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 64: |
| - | |
| - | { |
| - | menu_end_entry(); |
| - | menu_add_menu(); |
| - | ;} |
| - | break; |
| - | |
| - | case 65: |
| - | |
| - | { |
| - | if (zconf_endtoken(yyvsp[0].token, T_MENU, T_ENDMENU)) { |
| - | menu_end_menu(); |
| - | printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | ;} |
| - | break; |
| - | |
| - | case 67: |
| - | |
| - | { |
| - | printf("%s:%d: missing 'endmenu' for this 'menu' statement\n", current_menu->file->name, current_menu->lineno); |
| - | zconfnerrs++; |
| - | ;} |
| - | break; |
| - | |
| - | case 72: |
| - | |
| - | { zconfprint("invalid menu option"); yyerrok; ;} |
| - | break; |
| - | |
| - | case 73: |
| - | |
| - | { |
| - | yyval.string = yyvsp[-1].string; |
| - | printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), yyvsp[-1].string); |
| - | ;} |
| - | break; |
| - | |
| - | case 74: |
| - | |
| - | { |
| - | zconf_nextfile(yyvsp[0].string); |
| - | ;} |
| - | break; |
| - | |
| - | case 75: |
| - | |
| - | { |
| - | menu_add_entry(NULL); |
| - | menu_add_prop(P_COMMENT, yyvsp[-1].string, NULL, NULL); |
| - | printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 76: |
| - | |
| - | { |
| - | menu_end_entry(); |
| - | ;} |
| - | break; |
| - | |
| - | case 77: |
| - | |
| - | { |
| - | printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno()); |
| - | zconf_starthelp(); |
| - | ;} |
| - | break; |
| - | |
| - | case 78: |
| - | |
| - | { |
| - | current_entry->sym->help = yyvsp[0].string; |
| - | ;} |
| - | break; |
| - | |
| - | case 82: |
| - | |
| - | { |
| - | menu_add_dep(yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 83: |
| - | |
| - | { |
| - | menu_add_dep(yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:depends\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 84: |
| - | |
| - | { |
| - | menu_add_dep(yyvsp[-1].expr); |
| - | printd(DEBUG_PARSE, "%s:%d:requires\n", zconf_curname(), zconf_lineno()); |
| - | ;} |
| - | break; |
| - | |
| - | case 86: |
| - | |
| - | { |
| - | menu_add_prop(P_PROMPT, yyvsp[-1].string, NULL, yyvsp[0].expr); |
| - | ;} |
| - | break; |
| - | |
| - | case 89: |
| - | |
| - | { yyval.token = T_ENDMENU; ;} |
| - | break; |
| - | |
| - | case 90: |
| - | |
| - | { yyval.token = T_ENDCHOICE; ;} |
| - | break; |
| - | |
| - | case 91: |
| - | |
| - | { yyval.token = T_ENDIF; ;} |
| - | break; |
| - | |
| - | case 94: |
| - | |
| - | { yyval.expr = NULL; ;} |
| - | break; |
| - | |
| - | case 95: |
| - | |
| - | { yyval.expr = yyvsp[0].expr; ;} |
| - | break; |
| - | |
| - | case 96: |
| - | |
| - | { yyval.expr = expr_alloc_symbol(yyvsp[0].symbol); ;} |
| - | break; |
| - | |
| - | case 97: |
| - | |
| - | { yyval.expr = expr_alloc_comp(E_EQUAL, yyvsp[-2].symbol, yyvsp[0].symbol); ;} |
| - | break; |
| - | |
| - | case 98: |
| - | |
| - | { yyval.expr = expr_alloc_comp(E_UNEQUAL, yyvsp[-2].symbol, yyvsp[0].symbol); ;} |
| - | break; |
| - | |
| - | case 99: |
| - | |
| - | { yyval.expr = yyvsp[-1].expr; ;} |
| - | break; |
| - | |
| - | case 100: |
| - | |
| - | { yyval.expr = expr_alloc_one(E_NOT, yyvsp[0].expr); ;} |
| - | break; |
| - | |
| - | case 101: |
| - | |
| - | { yyval.expr = expr_alloc_two(E_OR, yyvsp[-2].expr, yyvsp[0].expr); ;} |
| - | break; |
| - | |
| - | case 102: |
| - | |
| - | { yyval.expr = expr_alloc_two(E_AND, yyvsp[-2].expr, yyvsp[0].expr); ;} |
| - | break; |
| - | |
| - | case 103: |
| - | |
| - | { yyval.symbol = sym_lookup(yyvsp[0].string, 0); free(yyvsp[0].string); ;} |
| - | break; |
| - | |
| - | case 104: |
| - | |
| - | { yyval.symbol = sym_lookup(yyvsp[0].string, 1); free(yyvsp[0].string); ;} |
| - | break; |
| - | |
| - | |
| - | } |
| - | |
| - | /* Line 999 of yacc.c. */ |
| - | |
| - | |
| - | yyvsp -= yylen; |
| - | yyssp -= yylen; |
| - | |
| - | |
| - | YY_STACK_PRINT (yyss, yyssp); |
| - | |
| - | *++yyvsp = yyval; |
| - | |
| - | |
| - | /* Now `shift' the result of the reduction. Determine what state |
| - | that goes to, based on the state we popped back to and the rule |
| - | number reduced by. */ |
| - | |
| - | yyn = yyr1[yyn]; |
| - | |
| - | yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; |
| - | if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
| - | yystate = yytable[yystate]; |
| - | else |
| - | yystate = yydefgoto[yyn - YYNTOKENS]; |
| - | |
| - | goto yynewstate; |
| - | |
| - | |
| - | /*------------------------------------. |
| - | | yyerrlab -- here on detecting error | |
| - | `------------------------------------*/ |
| - | yyerrlab: |
| - | /* If not already recovering from an error, report this error. */ |
| - | if (!yyerrstatus) |
| - | { |
| - | ++yynerrs; |
| - | #if YYERROR_VERBOSE |
| - | yyn = yypact[yystate]; |
| - | |
| - | if (YYPACT_NINF < yyn && yyn < YYLAST) |
| - | { |
| - | YYSIZE_T yysize = 0; |
| - | int yytype = YYTRANSLATE (yychar); |
| - | char *yymsg; |
| - | int yyx, yycount; |
| - | |
| - | yycount = 0; |
| - | /* Start YYX at -YYN if negative to avoid negative indexes in |
| - | YYCHECK. */ |
| - | for (yyx = yyn < 0 ? -yyn : 0; |
| - | yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) |
| - | if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
| - | yysize += yystrlen (yytname[yyx]) + 15, yycount++; |
| - | yysize += yystrlen ("syntax error, unexpected ") + 1; |
| - | yysize += yystrlen (yytname[yytype]); |
| - | yymsg = (char *) YYSTACK_ALLOC (yysize); |
| - | if (yymsg != 0) |
| - | { |
| - | char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); |
| - | yyp = yystpcpy (yyp, yytname[yytype]); |
| - | |
| - | if (yycount < 5) |
| - | { |
| - | yycount = 0; |
| - | for (yyx = yyn < 0 ? -yyn : 0; |
| - | yyx < (int) (sizeof (yytname) / sizeof (char *)); |
| - | yyx++) |
| - | if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
| - | { |
| - | const char *yyq = ! yycount ? ", expecting " : " or "; |
| - | yyp = yystpcpy (yyp, yyq); |
| - | yyp = yystpcpy (yyp, yytname[yyx]); |
| - | yycount++; |
| - | } |
| - | } |
| - | yyerror (yymsg); |
| - | YYSTACK_FREE (yymsg); |
| - | } |
| - | else |
| - | yyerror ("syntax error; also virtual memory exhausted"); |
| - | } |
| - | else |
| - | #endif /* YYERROR_VERBOSE */ |
| - | yyerror ("syntax error"); |
| - | } |
| - | |
| - | |
| - | |
| - | if (yyerrstatus == 3) |
| - | { |
| - | /* If just tried and failed to reuse lookahead token after an |
| - | error, discard it. */ |
| - | |
| - | /* Return failure if at end of input. */ |
| - | if (yychar == YYEOF) |
| - | { |
| - | /* Pop the error token. */ |
| - | YYPOPSTACK; |
| - | /* Pop the rest of the stack. */ |
| - | while (yyss < yyssp) |
| - | { |
| - | YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
| - | yydestruct (yystos[*yyssp], yyvsp); |
| - | YYPOPSTACK; |
| - | } |
| - | YYABORT; |
| - | } |
| - | |
| - | YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); |
| - | yydestruct (yytoken, &yylval); |
| - | yychar = YYEMPTY; |
| - | |
| - | } |
| - | |
| - | /* Else will try to reuse lookahead token after shifting the error |
| - | token. */ |
| - | goto yyerrlab1; |
| - | |
| - | |
| - | /*----------------------------------------------------. |
| - | | yyerrlab1 -- error raised explicitly by an action. | |
| - | `----------------------------------------------------*/ |
| - | yyerrlab1: |
| - | yyerrstatus = 3; /* Each real token shifted decrements this. */ |
| - | |
| - | for (;;) |
| - | { |
| - | yyn = yypact[yystate]; |
| - | if (yyn != YYPACT_NINF) |
| - | { |
| - | yyn += YYTERROR; |
| - | if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
| - | { |
| - | yyn = yytable[yyn]; |
| - | if (0 < yyn) |
| - | break; |
| - | } |
| - | } |
| - | |
| - | /* Pop the current state because it cannot handle the error token. */ |
| - | if (yyssp == yyss) |
| - | YYABORT; |
| - | |
| - | YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
| - | yydestruct (yystos[yystate], yyvsp); |
| - | yyvsp--; |
| - | yystate = *--yyssp; |
| - | |
| - | YY_STACK_PRINT (yyss, yyssp); |
| - | } |
| - | |
| - | if (yyn == YYFINAL) |
| - | YYACCEPT; |
| - | |
| - | YYDPRINTF ((stderr, "Shifting error token, ")); |
| - | |
| - | *++yyvsp = yylval; |
| - | |
| - | |
| - | yystate = yyn; |
| - | goto yynewstate; |
| - | |
| - | |
| - | /*-------------------------------------. |
| - | | yyacceptlab -- YYACCEPT comes here. | |
| - | `-------------------------------------*/ |
| - | yyacceptlab: |
| - | yyresult = 0; |
| - | goto yyreturn; |
| - | |
| - | /*-----------------------------------. |
| - | | yyabortlab -- YYABORT comes here. | |
| - | `-----------------------------------*/ |
| - | yyabortlab: |
| - | yyresult = 1; |
| - | goto yyreturn; |
| - | |
| - | #ifndef yyoverflow |
| - | /*----------------------------------------------. |
| - | | yyoverflowlab -- parser overflow comes here. | |
| - | `----------------------------------------------*/ |
| - | yyoverflowlab: |
| - | yyerror ("parser stack overflow"); |
| - | yyresult = 2; |
| - | /* Fall through. */ |
| - | #endif |
| - | |
| - | yyreturn: |
| - | #ifndef yyoverflow |
| - | if (yyss != yyssa) |
| - | YYSTACK_FREE (yyss); |
| - | #endif |
| - | return yyresult; |
| - | } |
| - | |
| - | |
| - | |
| - | |
| - | |
| - | void conf_parse(const char *name) |
| - | { |
| - | struct symbol *sym; |
| - | int i; |
| - | |
| - | zconf_initscan(name); |
| - | |
| - | sym_init(); |
| - | menu_init(); |
| - | modules_sym = sym_lookup("MODULES", 0); |
| - | rootmenu.prompt = menu_add_prop(P_MENU, "BusyBox Configuration", NULL, NULL); |
| - | |
| - | //zconfdebug = 1; |
| - | zconfparse(); |
| - | if (zconfnerrs) |
| - | exit(1); |
| - | menu_finalize(&rootmenu); |
| - | for_all_symbols(i, sym) { |
| - | if (!(sym->flags & SYMBOL_CHECKED) && sym_check_deps(sym)) |
| - | printf("\n"); |
| - | else |
| - | sym->flags |= SYMBOL_CHECK_DONE; |
| - | } |
| - | |
| - | sym_change_count = 1; |
| - | } |
| - | |
| - | const char *zconf_tokenname(int token) |
| - | { |
| - | switch (token) { |
| - | case T_MENU: return "menu"; |
| - | case T_ENDMENU: return "endmenu"; |
| - | case T_CHOICE: return "choice"; |
| - | case T_ENDCHOICE: return "endchoice"; |
| - | case T_IF: return "if"; |
| - | case T_ENDIF: return "endif"; |
| - | } |
| - | return "<token>"; |
| - | } |
| - | |
| - | static bool zconf_endtoken(int token, int starttoken, int endtoken) |
| - | { |
| - | if (token != endtoken) { |
| - | zconfprint("unexpected '%s' within %s block", zconf_tokenname(token), zconf_tokenname(starttoken)); |
| - | zconfnerrs++; |
| - | return false; |
| - | } |
| - | if (current_menu->file != current_file) { |
| - | zconfprint("'%s' in different file than '%s'", zconf_tokenname(token), zconf_tokenname(starttoken)); |
| - | zconfprint("location of the '%s'", zconf_tokenname(starttoken)); |
| - | zconfnerrs++; |
| - | return false; |
| - | } |
| - | return true; |
| - | } |
| - | |
| - | static void zconfprint(const char *err, ...) |
| - | { |
| - | va_list ap; |
| - | |
| - | fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno() + 1); |
| - | va_start(ap, err); |
| - | vfprintf(stderr, err, ap); |
| - | va_end(ap); |
| - | fprintf(stderr, "\n"); |
| - | } |
| - | |
| - | static void zconferror(const char *err) |
| - | { |
| - | fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err); |
| - | } |
| - | |
| - | void print_quoted_string(FILE *out, const char *str) |
| - | { |
| - | const char *p; |
| - | int len; |
| - | |
| - | putc('"', out); |
| - | while ((p = strchr(str, '"'))) { |
| - | len = p - str; |
| - | if (len) |
| - | fprintf(out, "%.*s", len, str); |
| - | fputs("\\\"", out); |
| - | str = p + 1; |
| - | } |
| - | fputs(str, out); |
| - | putc('"', out); |
| - | } |
| - | |
| - | void print_symbol(FILE *out, struct menu *menu) |
| - | { |
| - | struct symbol *sym = menu->sym; |
| - | struct property *prop; |
| - | |
| - | if (sym_is_choice(sym)) |
| - | fprintf(out, "choice\n"); |
| - | else |
| - | fprintf(out, "config %s\n", sym->name); |
| - | switch (sym->type) { |
| - | case S_BOOLEAN: |
| - | fputs(" boolean\n", out); |
| - | break; |
| - | case S_TRISTATE: |
| - | fputs(" tristate\n", out); |
| - | break; |
| - | case S_STRING: |
| - | fputs(" string\n", out); |
| - | break; |
| - | case S_INT: |
| - | fputs(" integer\n", out); |
| - | break; |
| - | case S_HEX: |
| - | fputs(" hex\n", out); |
| - | break; |
| - | default: |
| - | fputs(" ???\n", out); |
| - | break; |
| - | } |
| - | for (prop = sym->prop; prop; prop = prop->next) { |
| - | if (prop->menu != menu) |
| - | continue; |
| - | switch (prop->type) { |
| - | case P_PROMPT: |
| - | fputs(" prompt ", out); |
| - | print_quoted_string(out, prop->text); |
| - | if (!expr_is_yes(prop->visible.expr)) { |
| - | fputs(" if ", out); |
| - | expr_fprint(prop->visible.expr, out); |
| - | } |
| - | fputc('\n', out); |
| - | break; |
| - | case P_DEFAULT: |
| - | fputs( " default ", out); |
| - | expr_fprint(prop->expr, out); |
| - | if (!expr_is_yes(prop->visible.expr)) { |
| - | fputs(" if ", out); |
| - | expr_fprint(prop->visible.expr, out); |
| - | } |
| - | fputc('\n', out); |
| - | break; |
| - | case P_CHOICE: |
| - | fputs(" #choice value\n", out); |
| - | break; |
| - | default: |
| - | fprintf(out, " unknown prop %d!\n", prop->type); |
| - | break; |
| - | } |
| - | } |
| - | if (sym->help) { |
| - | int len = strlen(sym->help); |
| - | while (sym->help[--len] == '\n') |
| - | sym->help[len] = 0; |
| - | fprintf(out, " help\n%s\n", sym->help); |
| - | } |
| - | fputc('\n', out); |
| - | } |
| - | |
| - | void zconfdump(FILE *out) |
| - | { |
| - | struct property *prop; |
| - | struct symbol *sym; |
| - | struct menu *menu; |
| - | |
| - | menu = rootmenu.list; |
| - | while (menu) { |
| - | if ((sym = menu->sym)) |
| - | print_symbol(out, menu); |
| - | else if ((prop = menu->prompt)) { |
| - | switch (prop->type) { |
| - | case P_COMMENT: |
| - | fputs("\ncomment ", out); |
| - | print_quoted_string(out, prop->text); |
| - | fputs("\n", out); |
| - | break; |
| - | case P_MENU: |
| - | fputs("\nmenu ", out); |
| - | print_quoted_string(out, prop->text); |
| - | fputs("\n", out); |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | if (!expr_is_yes(prop->visible.expr)) { |
| - | fputs(" depends ", out); |
| - | expr_fprint(prop->visible.expr, out); |
| - | fputc('\n', out); |
| - | } |
| - | fputs("\n", out); |
| - | } |
| - | |
| - | if (menu->list) |
| - | menu = menu->list; |
| - | else if (menu->next) |
| - | menu = menu->next; |
| - | else while ((menu = menu->parent)) { |
| - | if (menu->prompt && menu->prompt->type == P_MENU) |
| - | fputs("\nendmenu\n", out); |
| - | if (menu->next) { |
| - | menu = menu->next; |
| - | break; |
| - | } |
| - | } |
| - | } |
| - | } |
| - | |
| - | #include "lex.zconf.c" |
| - | #include "util.c" |
| - | #include "confdata.c" |
| - | #include "expr.c" |
| - | #include "symbol.c" |
| - | #include "menu.c" |
| - | |
| - | |
| @@ -1,125 +0,0 @@ | |
| - | /* A Bison parser, made from zconf.y, by GNU bison 1.75. */ |
| - | |
| - | /* Skeleton parser for Yacc-like parsing with Bison, |
| - | Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. |
| - | |
| - | 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, 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. */ |
| - | |
| - | /* As a special exception, when this file is copied by Bison into a |
| - | Bison output file, you may use that output file without restriction. |
| - | This special exception was added by the Free Software Foundation |
| - | in version 1.24 of Bison. */ |
| - | |
| - | #ifndef BISON_ZCONF_TAB_H |
| - | # define BISON_ZCONF_TAB_H |
| - | |
| - | /* Tokens. */ |
| - | #ifndef YYTOKENTYPE |
| - | # define YYTOKENTYPE |
| - | /* Put the tokens into the symbol table, so that GDB and other debuggers |
| - | know about them. */ |
| - | enum yytokentype { |
| - | T_MAINMENU = 258, |
| - | T_MENU = 259, |
| - | T_ENDMENU = 260, |
| - | T_SOURCE = 261, |
| - | T_CHOICE = 262, |
| - | T_ENDCHOICE = 263, |
| - | T_COMMENT = 264, |
| - | T_CONFIG = 265, |
| - | T_HELP = 266, |
| - | T_HELPTEXT = 267, |
| - | T_IF = 268, |
| - | T_ENDIF = 269, |
| - | T_DEPENDS = 270, |
| - | T_REQUIRES = 271, |
| - | T_OPTIONAL = 272, |
| - | T_PROMPT = 273, |
| - | T_DEFAULT = 274, |
| - | T_TRISTATE = 275, |
| - | T_BOOLEAN = 276, |
| - | T_INT = 277, |
| - | T_HEX = 278, |
| - | T_WORD = 279, |
| - | T_STRING = 280, |
| - | T_UNEQUAL = 281, |
| - | T_EOF = 282, |
| - | T_EOL = 283, |
| - | T_CLOSE_PAREN = 284, |
| - | T_OPEN_PAREN = 285, |
| - | T_ON = 286, |
| - | T_OR = 287, |
| - | T_AND = 288, |
| - | T_EQUAL = 289, |
| - | T_NOT = 290 |
| - | }; |
| - | #endif |
| - | #define T_MAINMENU 258 |
| - | #define T_MENU 259 |
| - | #define T_ENDMENU 260 |
| - | #define T_SOURCE 261 |
| - | #define T_CHOICE 262 |
| - | #define T_ENDCHOICE 263 |
| - | #define T_COMMENT 264 |
| - | #define T_CONFIG 265 |
| - | #define T_HELP 266 |
| - | #define T_HELPTEXT 267 |
| - | #define T_IF 268 |
| - | #define T_ENDIF 269 |
| - | #define T_DEPENDS 270 |
| - | #define T_REQUIRES 271 |
| - | #define T_OPTIONAL 272 |
| - | #define T_PROMPT 273 |
| - | #define T_DEFAULT 274 |
| - | #define T_TRISTATE 275 |
| - | #define T_BOOLEAN 276 |
| - | #define T_INT 277 |
| - | #define T_HEX 278 |
| - | #define T_WORD 279 |
| - | #define T_STRING 280 |
| - | #define T_UNEQUAL 281 |
| - | #define T_EOF 282 |
| - | #define T_EOL 283 |
| - | #define T_CLOSE_PAREN 284 |
| - | #define T_OPEN_PAREN 285 |
| - | #define T_ON 286 |
| - | #define T_OR 287 |
| - | #define T_AND 288 |
| - | #define T_EQUAL 289 |
| - | #define T_NOT 290 |
| - | |
| - | |
| - | |
| - | |
| - | #ifndef YYSTYPE |
| - | #line 33 "zconf.y" |
| - | typedef union { |
| - | int token; |
| - | char *string; |
| - | struct symbol *symbol; |
| - | struct expr *expr; |
| - | struct menu *menu; |
| - | } yystype; |
| - | /* Line 1281 of /usr/share/bison/yacc.c. */ |
| - | #line 118 "zconf.tab.h" |
| - | # define YYSTYPE yystype |
| - | #endif |
| - | |
| - | extern YYSTYPE zconflval; |
| - | |
| - | |
| - | #endif /* not BISON_ZCONF_TAB_H */ |
| - | |
| @@ -1,690 +0,0 @@ | |
| - | %{ |
| - | /* |
| - | * Copyright (C) 2002 Roman Zippel <[email protected]> |
| - | * Released under the terms of the GNU GPL v2.0. |
| - | */ |
| - | |
| - | #include <ctype.h> |
| - | #include <stdarg.h> |
| - | #include <stdio.h> |
| - | #include <stdlib.h> |
| - | #include <string.h> |
| - | #include <stdbool.h> |
| - | |
| - | #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt) |
| - | |
| - | #define PRINTD 0x0001 |
| - | #define DEBUG_PARSE 0x0002 |
| - | |
| - | int cdebug = PRINTD; |
| - | |
| - | extern int zconflex(void); |
| - | static void zconfprint(const char *err, ...); |
| - | static void zconferror(const char *err); |
| - | static bool zconf_endtoken(int token, int starttoken, int endtoken); |
| - | |
| - | struct symbol *symbol_hash[257]; |
| - | |
| - | static struct menu *current_menu, *current_entry; |
| - | |
| - | #define YYERROR_VERBOSE |
| - | %} |
| - | %expect 40 |
| - | |
| - | %union |
| - | { |
| - | int token; |
| - | char *string; |
| - | struct symbol *symbol; |
| - | struct expr *expr; |
| - | struct menu *menu; |
| - | } |
| - | |
| - | %token T_MAINMENU |
| - | %token T_MENU |
| - | %token T_ENDMENU |
| - | %token T_SOURCE |
| - | %token T_CHOICE |
| - | %token T_ENDCHOICE |
| - | %token T_COMMENT |
| - | %token T_CONFIG |
| - | %token T_MENUCONFIG |
| - | %token T_HELP |
| - | %token <string> T_HELPTEXT |
| - | %token T_IF |
| - | %token T_ENDIF |
| - | %token T_DEPENDS |
| - | %token T_REQUIRES |
| - | %token T_OPTIONAL |
| - | %token T_PROMPT |
| - | %token T_DEFAULT |
| - | %token T_TRISTATE |
| - | %token T_DEF_TRISTATE |
| - | %token T_BOOLEAN |
| - | %token T_DEF_BOOLEAN |
| - | %token T_STRING |
| - | %token T_INT |
| - | %token T_HEX |
| - | %token <string> T_WORD |
| - | %token <string> T_WORD_QUOTE |
| - | %token T_UNEQUAL |
| - | %token T_EOF |
| - | %token T_EOL |
| - | %token T_CLOSE_PAREN |
| - | %token T_OPEN_PAREN |
| - | %token T_ON |
| - | %token T_SELECT |
| - | %token T_RANGE |
| - | |
| - | %left T_OR |
| - | %left T_AND |
| - | %left T_EQUAL T_UNEQUAL |
| - | %nonassoc T_NOT |
| - | |
| - | %type <string> prompt |
| - | %type <string> source |
| - | %type <symbol> symbol |
| - | %type <expr> expr |
| - | %type <expr> if_expr |
| - | %type <token> end |
| - | |
| - | %{ |
| - | #define LKC_DIRECT_LINK |
| - | #include "lkc.h" |
| - | %} |
| - | %% |
| - | input: /* empty */ |
| - | | input block |
| - | ; |
| - | |
| - | block: common_block |
| - | | choice_stmt |
| - | | menu_stmt |
| - | | T_MAINMENU prompt nl_or_eof |
| - | | T_ENDMENU { zconfprint("unexpected 'endmenu' statement"); } |
| - | | T_ENDIF { zconfprint("unexpected 'endif' statement"); } |
| - | | T_ENDCHOICE { zconfprint("unexpected 'endchoice' statement"); } |
| - | | error nl_or_eof { zconfprint("syntax error"); yyerrok; } |
| - | ; |
| - | |
| - | common_block: |
| - | if_stmt |
| - | | comment_stmt |
| - | | config_stmt |
| - | | menuconfig_stmt |
| - | | source_stmt |
| - | | nl_or_eof |
| - | ; |
| - | |
| - | |
| - | /* config/menuconfig entry */ |
| - | |
| - | config_entry_start: T_CONFIG T_WORD T_EOL |
| - | { |
| - | struct symbol *sym = sym_lookup($2, 0); |
| - | sym->flags |= SYMBOL_OPTIONAL; |
| - | menu_add_entry(sym); |
| - | printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), $2); |
| - | }; |
| - | |
| - | config_stmt: config_entry_start config_option_list |
| - | { |
| - | menu_end_entry(); |
| - | printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | menuconfig_entry_start: T_MENUCONFIG T_WORD T_EOL |
| - | { |
| - | struct symbol *sym = sym_lookup($2, 0); |
| - | sym->flags |= SYMBOL_OPTIONAL; |
| - | menu_add_entry(sym); |
| - | printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), $2); |
| - | }; |
| - | |
| - | menuconfig_stmt: menuconfig_entry_start config_option_list |
| - | { |
| - | if (current_entry->prompt) |
| - | current_entry->prompt->type = P_MENU; |
| - | else |
| - | zconfprint("warning: menuconfig statement without prompt"); |
| - | menu_end_entry(); |
| - | printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option_list: |
| - | /* empty */ |
| - | | config_option_list config_option |
| - | | config_option_list depends |
| - | | config_option_list help |
| - | | config_option_list T_EOL |
| - | ; |
| - | |
| - | config_option: T_TRISTATE prompt_stmt_opt T_EOL |
| - | { |
| - | menu_set_type(S_TRISTATE); |
| - | printd(DEBUG_PARSE, "%s:%d:tristate\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_DEF_TRISTATE expr if_expr T_EOL |
| - | { |
| - | menu_add_expr(P_DEFAULT, $2, $3); |
| - | menu_set_type(S_TRISTATE); |
| - | printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_BOOLEAN prompt_stmt_opt T_EOL |
| - | { |
| - | menu_set_type(S_BOOLEAN); |
| - | printd(DEBUG_PARSE, "%s:%d:boolean\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_DEF_BOOLEAN expr if_expr T_EOL |
| - | { |
| - | menu_add_expr(P_DEFAULT, $2, $3); |
| - | menu_set_type(S_BOOLEAN); |
| - | printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_INT prompt_stmt_opt T_EOL |
| - | { |
| - | menu_set_type(S_INT); |
| - | printd(DEBUG_PARSE, "%s:%d:int\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_HEX prompt_stmt_opt T_EOL |
| - | { |
| - | menu_set_type(S_HEX); |
| - | printd(DEBUG_PARSE, "%s:%d:hex\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_STRING prompt_stmt_opt T_EOL |
| - | { |
| - | menu_set_type(S_STRING); |
| - | printd(DEBUG_PARSE, "%s:%d:string\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_PROMPT prompt if_expr T_EOL |
| - | { |
| - | menu_add_prompt(P_PROMPT, $2, $3); |
| - | printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_DEFAULT expr if_expr T_EOL |
| - | { |
| - | menu_add_expr(P_DEFAULT, $2, $3); |
| - | printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_SELECT T_WORD if_expr T_EOL |
| - | { |
| - | menu_add_symbol(P_SELECT, sym_lookup($2, 0), $3); |
| - | printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | config_option: T_RANGE symbol symbol if_expr T_EOL |
| - | { |
| - | menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,$2, $3), $4); |
| - | printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | /* choice entry */ |
| - | |
| - | choice: T_CHOICE T_EOL |
| - | { |
| - | struct symbol *sym = sym_lookup(NULL, 0); |
| - | sym->flags |= SYMBOL_CHOICE; |
| - | menu_add_entry(sym); |
| - | menu_add_expr(P_CHOICE, NULL, NULL); |
| - | printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | choice_entry: choice choice_option_list |
| - | { |
| - | menu_end_entry(); |
| - | menu_add_menu(); |
| - | }; |
| - | |
| - | choice_end: end |
| - | { |
| - | if (zconf_endtoken($1, T_CHOICE, T_ENDCHOICE)) { |
| - | menu_end_menu(); |
| - | printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | }; |
| - | |
| - | choice_stmt: |
| - | choice_entry choice_block choice_end |
| - | | choice_entry choice_block |
| - | { |
| - | printf("%s:%d: missing 'endchoice' for this 'choice' statement\n", current_menu->file->name, current_menu->lineno); |
| - | zconfnerrs++; |
| - | }; |
| - | |
| - | choice_option_list: |
| - | /* empty */ |
| - | | choice_option_list choice_option |
| - | | choice_option_list depends |
| - | | choice_option_list help |
| - | | choice_option_list T_EOL |
| - | ; |
| - | |
| - | choice_option: T_PROMPT prompt if_expr T_EOL |
| - | { |
| - | menu_add_prompt(P_PROMPT, $2, $3); |
| - | printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | choice_option: T_TRISTATE prompt_stmt_opt T_EOL |
| - | { |
| - | menu_set_type(S_TRISTATE); |
| - | printd(DEBUG_PARSE, "%s:%d:tristate\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | choice_option: T_BOOLEAN prompt_stmt_opt T_EOL |
| - | { |
| - | menu_set_type(S_BOOLEAN); |
| - | printd(DEBUG_PARSE, "%s:%d:boolean\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | choice_option: T_OPTIONAL T_EOL |
| - | { |
| - | current_entry->sym->flags |= SYMBOL_OPTIONAL; |
| - | printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | choice_option: T_DEFAULT T_WORD if_expr T_EOL |
| - | { |
| - | menu_add_symbol(P_DEFAULT, sym_lookup($2, 0), $3); |
| - | printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | choice_block: |
| - | /* empty */ |
| - | | choice_block common_block |
| - | ; |
| - | |
| - | /* if entry */ |
| - | |
| - | if: T_IF expr T_EOL |
| - | { |
| - | printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno()); |
| - | menu_add_entry(NULL); |
| - | menu_add_dep($2); |
| - | menu_end_entry(); |
| - | menu_add_menu(); |
| - | }; |
| - | |
| - | if_end: end |
| - | { |
| - | if (zconf_endtoken($1, T_IF, T_ENDIF)) { |
| - | menu_end_menu(); |
| - | printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | }; |
| - | |
| - | if_stmt: |
| - | if if_block if_end |
| - | | if if_block |
| - | { |
| - | printf("%s:%d: missing 'endif' for this 'if' statement\n", current_menu->file->name, current_menu->lineno); |
| - | zconfnerrs++; |
| - | }; |
| - | |
| - | if_block: |
| - | /* empty */ |
| - | | if_block common_block |
| - | | if_block menu_stmt |
| - | | if_block choice_stmt |
| - | ; |
| - | |
| - | /* menu entry */ |
| - | |
| - | menu: T_MENU prompt T_EOL |
| - | { |
| - | menu_add_entry(NULL); |
| - | menu_add_prop(P_MENU, $2, NULL, NULL); |
| - | printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | menu_entry: menu depends_list |
| - | { |
| - | menu_end_entry(); |
| - | menu_add_menu(); |
| - | }; |
| - | |
| - | menu_end: end |
| - | { |
| - | if (zconf_endtoken($1, T_MENU, T_ENDMENU)) { |
| - | menu_end_menu(); |
| - | printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | }; |
| - | |
| - | menu_stmt: |
| - | menu_entry menu_block menu_end |
| - | | menu_entry menu_block |
| - | { |
| - | printf("%s:%d: missing 'endmenu' for this 'menu' statement\n", current_menu->file->name, current_menu->lineno); |
| - | zconfnerrs++; |
| - | }; |
| - | |
| - | menu_block: |
| - | /* empty */ |
| - | | menu_block common_block |
| - | | menu_block menu_stmt |
| - | | menu_block choice_stmt |
| - | | menu_block error T_EOL { zconfprint("invalid menu option"); yyerrok; } |
| - | ; |
| - | |
| - | source: T_SOURCE prompt T_EOL |
| - | { |
| - | $$ = $2; |
| - | printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), $2); |
| - | }; |
| - | |
| - | source_stmt: source |
| - | { |
| - | zconf_nextfile($1); |
| - | }; |
| - | |
| - | /* comment entry */ |
| - | |
| - | comment: T_COMMENT prompt T_EOL |
| - | { |
| - | menu_add_entry(NULL); |
| - | menu_add_prop(P_COMMENT, $2, NULL, NULL); |
| - | printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | comment_stmt: comment depends_list |
| - | { |
| - | menu_end_entry(); |
| - | }; |
| - | |
| - | /* help option */ |
| - | |
| - | help_start: T_HELP T_EOL |
| - | { |
| - | printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno()); |
| - | zconf_starthelp(); |
| - | }; |
| - | |
| - | help: help_start T_HELPTEXT |
| - | { |
| - | current_entry->sym->help = $2; |
| - | }; |
| - | |
| - | /* depends option */ |
| - | |
| - | depends_list: /* empty */ |
| - | | depends_list depends |
| - | | depends_list T_EOL |
| - | ; |
| - | |
| - | depends: T_DEPENDS T_ON expr T_EOL |
| - | { |
| - | menu_add_dep($3); |
| - | printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | | T_DEPENDS expr T_EOL |
| - | { |
| - | menu_add_dep($2); |
| - | printd(DEBUG_PARSE, "%s:%d:depends\n", zconf_curname(), zconf_lineno()); |
| - | } |
| - | | T_REQUIRES expr T_EOL |
| - | { |
| - | menu_add_dep($2); |
| - | printd(DEBUG_PARSE, "%s:%d:requires\n", zconf_curname(), zconf_lineno()); |
| - | }; |
| - | |
| - | /* prompt statement */ |
| - | |
| - | prompt_stmt_opt: |
| - | /* empty */ |
| - | | prompt if_expr |
| - | { |
| - | menu_add_prop(P_PROMPT, $1, NULL, $2); |
| - | }; |
| - | |
| - | prompt: T_WORD |
| - | | T_WORD_QUOTE |
| - | ; |
| - | |
| - | end: T_ENDMENU nl_or_eof { $$ = T_ENDMENU; } |
| - | | T_ENDCHOICE nl_or_eof { $$ = T_ENDCHOICE; } |
| - | | T_ENDIF nl_or_eof { $$ = T_ENDIF; } |
| - | ; |
| - | |
| - | nl_or_eof: |
| - | T_EOL | T_EOF; |
| - | |
| - | if_expr: /* empty */ { $$ = NULL; } |
| - | | T_IF expr { $$ = $2; } |
| - | ; |
| - | |
| - | expr: symbol { $$ = expr_alloc_symbol($1); } |
| - | | symbol T_EQUAL symbol { $$ = expr_alloc_comp(E_EQUAL, $1, $3); } |
| - | | symbol T_UNEQUAL symbol { $$ = expr_alloc_comp(E_UNEQUAL, $1, $3); } |
| - | | T_OPEN_PAREN expr T_CLOSE_PAREN { $$ = $2; } |
| - | | T_NOT expr { $$ = expr_alloc_one(E_NOT, $2); } |
| - | | expr T_OR expr { $$ = expr_alloc_two(E_OR, $1, $3); } |
| - | | expr T_AND expr { $$ = expr_alloc_two(E_AND, $1, $3); } |
| - | ; |
| - | |
| - | symbol: T_WORD { $$ = sym_lookup($1, 0); free($1); } |
| - | | T_WORD_QUOTE { $$ = sym_lookup($1, 1); free($1); } |
| - | ; |
| - | |
| - | %% |
| - | |
| - | void conf_parse(const char *name) |
| - | { |
| - | struct symbol *sym; |
| - | int i; |
| - | |
| - | zconf_initscan(name); |
| - | |
| - | sym_init(); |
| - | menu_init(); |
| - | modules_sym = sym_lookup("MODULES", 0); |
| - | rootmenu.prompt = menu_add_prop(P_MENU, "BusyBox Configuration", NULL, NULL); |
| - | |
| - | //zconfdebug = 1; |
| - | zconfparse(); |
| - | if (zconfnerrs) |
| - | exit(1); |
| - | menu_finalize(&rootmenu); |
| - | for_all_symbols(i, sym) { |
| - | if (!(sym->flags & SYMBOL_CHECKED) && sym_check_deps(sym)) |
| - | printf("\n"); |
| - | else |
| - | sym->flags |= SYMBOL_CHECK_DONE; |
| - | } |
| - | |
| - | sym_change_count = 1; |
| - | } |
| - | |
| - | const char *zconf_tokenname(int token) |
| - | { |
| - | switch (token) { |
| - | case T_MENU: return "menu"; |
| - | case T_ENDMENU: return "endmenu"; |
| - | case T_CHOICE: return "choice"; |
| - | case T_ENDCHOICE: return "endchoice"; |
| - | case T_IF: return "if"; |
| - | case T_ENDIF: return "endif"; |
| - | } |
| - | return "<token>"; |
| - | } |
| - | |
| - | static bool zconf_endtoken(int token, int starttoken, int endtoken) |
| - | { |
| - | if (token != endtoken) { |
| - | zconfprint("unexpected '%s' within %s block", zconf_tokenname(token), zconf_tokenname(starttoken)); |
| - | zconfnerrs++; |
| - | return false; |
| - | } |
| - | if (current_menu->file != current_file) { |
| - | zconfprint("'%s' in different file than '%s'", zconf_tokenname(token), zconf_tokenname(starttoken)); |
| - | zconfprint("location of the '%s'", zconf_tokenname(starttoken)); |
| - | zconfnerrs++; |
| - | return false; |
| - | } |
| - | return true; |
| - | } |
| - | |
| - | static void zconfprint(const char *err, ...) |
| - | { |
| - | va_list ap; |
| - | |
| - | fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno() + 1); |
| - | va_start(ap, err); |
| - | vfprintf(stderr, err, ap); |
| - | va_end(ap); |
| - | fprintf(stderr, "\n"); |
| - | } |
| - | |
| - | static void zconferror(const char *err) |
| - | { |
| - | fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err); |
| - | } |
| - | |
| - | void print_quoted_string(FILE *out, const char *str) |
| - | { |
| - | const char *p; |
| - | int len; |
| - | |
| - | putc('"', out); |
| - | while ((p = strchr(str, '"'))) { |
| - | len = p - str; |
| - | if (len) |
| - | fprintf(out, "%.*s", len, str); |
| - | fputs("\\\"", out); |
| - | str = p + 1; |
| - | } |
| - | fputs(str, out); |
| - | putc('"', out); |
| - | } |
| - | |
| - | void print_symbol(FILE *out, struct menu *menu) |
| - | { |
| - | struct symbol *sym = menu->sym; |
| - | struct property *prop; |
| - | |
| - | if (sym_is_choice(sym)) |
| - | fprintf(out, "choice\n"); |
| - | else |
| - | fprintf(out, "config %s\n", sym->name); |
| - | switch (sym->type) { |
| - | case S_BOOLEAN: |
| - | fputs(" boolean\n", out); |
| - | break; |
| - | case S_TRISTATE: |
| - | fputs(" tristate\n", out); |
| - | break; |
| - | case S_STRING: |
| - | fputs(" string\n", out); |
| - | break; |
| - | case S_INT: |
| - | fputs(" integer\n", out); |
| - | break; |
| - | case S_HEX: |
| - | fputs(" hex\n", out); |
| - | break; |
| - | default: |
| - | fputs(" ???\n", out); |
| - | break; |
| - | } |
| - | for (prop = sym->prop; prop; prop = prop->next) { |
| - | if (prop->menu != menu) |
| - | continue; |
| - | switch (prop->type) { |
| - | case P_PROMPT: |
| - | fputs(" prompt ", out); |
| - | print_quoted_string(out, prop->text); |
| - | if (!expr_is_yes(prop->visible.expr)) { |
| - | fputs(" if ", out); |
| - | expr_fprint(prop->visible.expr, out); |
| - | } |
| - | fputc('\n', out); |
| - | break; |
| - | case P_DEFAULT: |
| - | fputs( " default ", out); |
| - | expr_fprint(prop->expr, out); |
| - | if (!expr_is_yes(prop->visible.expr)) { |
| - | fputs(" if ", out); |
| - | expr_fprint(prop->visible.expr, out); |
| - | } |
| - | fputc('\n', out); |
| - | break; |
| - | case P_CHOICE: |
| - | fputs(" #choice value\n", out); |
| - | break; |
| - | default: |
| - | fprintf(out, " unknown prop %d!\n", prop->type); |
| - | break; |
| - | } |
| - | } |
| - | if (sym->help) { |
| - | int len = strlen(sym->help); |
| - | while (sym->help[--len] == '\n') |
| - | sym->help[len] = 0; |
| - | fprintf(out, " help\n%s\n", sym->help); |
| - | } |
| - | fputc('\n', out); |
| - | } |
| - | |
| - | void zconfdump(FILE *out) |
| - | { |
| - | struct property *prop; |
| - | struct symbol *sym; |
| - | struct menu *menu; |
| - | |
| - | menu = rootmenu.list; |
| - | while (menu) { |
| - | if ((sym = menu->sym)) |
| - | print_symbol(out, menu); |
| - | else if ((prop = menu->prompt)) { |
| - | switch (prop->type) { |
| - | case P_COMMENT: |
| - | fputs("\ncomment ", out); |
| - | print_quoted_string(out, prop->text); |
| - | fputs("\n", out); |
| - | break; |
| - | case P_MENU: |
| - | fputs("\nmenu ", out); |
| - | print_quoted_string(out, prop->text); |
| - | fputs("\n", out); |
| - | break; |
| - | default: |
| - | ; |
| - | } |
| - | if (!expr_is_yes(prop->visible.expr)) { |
| - | fputs(" depends ", out); |
| - | expr_fprint(prop->visible.expr, out); |
| - | fputc('\n', out); |
| - | } |
| - | fputs("\n", out); |
| - | } |
| - | |
| - | if (menu->list) |
| - | menu = menu->list; |
| - | else if (menu->next) |
| - | menu = menu->next; |
| - | else while ((menu = menu->parent)) { |
| - | if (menu->prompt && menu->prompt->type == P_MENU) |
| - | fputs("\nendmenu\n", out); |
| - | if (menu->next) { |
| - | menu = menu->next; |
| - | break; |
| - | } |
| - | } |
| - | } |
| - | } |
| - | |
| - | #include "lex.zconf.c" |
| - | #include "util.c" |
| - | #include "confdata.c" |
| - | #include "expr.c" |
| - | #include "symbol.c" |
| - | #include "menu.c" |