Move the libxlutil source to tools/libs/util and delete tools/libxl.
Signed-off-by: Juergen Gross <jgross@suse.com>
Acked-by: Wei Liu <wl@xen.org>
tools/libs/store/xenstore.pc
tools/libs/store/xs_lib.c
tools/libs/store/include/xenstore_lib.h
+tools/libs/util/*.pc
+tools/libs/util/_paths.h
+tools/libs/util/libxlu_cfg_y.output
+tools/libs/util/libxenutil.map
tools/libs/vchan/headers.chk
tools/libs/vchan/libxenvchan.map
tools/libs/vchan/xenvchan.pc
tools/include/xen-xsm/*
tools/include/xen-foreign/*.(c|h|size)
tools/include/xen-foreign/checker
-tools/libxl/*.pc
-tools/libxl/libxlu_cfg_y.output
tools/misc/cpuperf/cpuperf-perfcntr
tools/misc/cpuperf/cpuperf-xen
tools/misc/xc_shadow
endif
SUBDIRS-y += xenpmd
-SUBDIRS-y += libxl
SUBDIRS-$(CONFIG_GOLANG) += golang
SUBDIRS-y += xl
SUBDIRS-y += helpers
include $(XEN_ROOT)/tools/libs/uselibs.mk
-XEN_libxenutil = $(XEN_ROOT)/tools/libxl
-
CFLAGS_xeninclude = -I$(XEN_INCLUDE)
XENSTORE_XENSTORED ?= y
CFLAGS += -O2 -fomit-frame-pointer
endif
-CFLAGS_libxenutil = -I$(XEN_libxenutil)
-SHDEPS_libxenutil = $(SHLIB_libxenlight)
-LDLIBS_libxenutil = $(SHDEPS_libxenutil) $(XEN_libxenutil)/libxlutil$(libextension)
-SHLIB_libxenutil = $(SHDEPS_libxenutil) -Wl,-rpath-link=$(XEN_libxenutil)
-
CFLAGS += -D__XEN_INTERFACE_VERSION__=__XEN_LATEST_INTERFACE_VERSION__
# Get gcc to generate the dependencies for us.
SUBDIRS-y += stat
SUBDIRS-$(CONFIG_Linux) += vchan
SUBDIRS-y += light
+SUBDIRS-y += util
ifeq ($(CONFIG_RUMP),y)
SUBDIRS-y := toolcore
USELIBS_stat := ctrl store
LIBS_LIBS += light
USELIBS_light := toollog evtchn toolcore ctrl store hypfs guest
+LIBS_LIBS += util
+USELIBS_util := light
+FILENAME_util := xlutil
--- /dev/null
+LIBXENLIGHT CODING STYLE
+========================
+
+
+AN APOLOGY AND WARNING
+----------------------
+
+Much of the code in libxl does not yet follow this coding style
+document in every respect. However, new code is expected to conform.
+
+Patches to improve the style of existing code are welcome. Please
+separate these out from functional changes.
+
+If it is not feasible to conform fully to the style while patching old
+code, without doing substantial style reengineering first, we may
+accept patches which contain nonconformant elements, provided that
+they don't make the coding style problem worse overall.
+
+In this case, the new code should conform to the prevailing style in
+the area being touched.
+
+
+MEMORY ALLOCATION
+-----------------
+
+Memory allocation for libxl-internal purposes should normally be done
+with the provided gc mechanisms; there is then no need to free. See
+"libxl memory management" in libxl.h.
+
+
+CONVENTIONAL VARIABLE NAMES
+---------------------------
+
+The following local variable names should be used where applicable:
+
+ int rc; /* a libxl error code - and not anything else */
+ int r; /* the return value from a system call (or libxc call) */
+ bool ok; /* the success return value from a boolean function */
+
+ uint32_t domid;
+ libxl__gc *gc;
+ libxl__egc *egc;
+ libxl__ao *ao;
+
+ libxl_foo_bar_state *fbs; /* local variable */
+ libxl_foo_bar_state foo_bar; /* inside another state struct */
+
+
+CONVENIENCE MACROS
+------------------
+
+There are a number of convenience macros which shorten the program and
+avoid opportunity for mistakes. In some cases non-use of the macros
+produces functional bugs or incorrect error handling. Use the macros
+whenever they are applicable. For example:
+
+ Usually, don't use: Instead, use (see libxl_internal.h):
+ libxl__log[v] LOG, LOGE, LOGEV
+ libxl__sprintf GCSPRINTF
+ libxl__*alloc et al. GCNEW, GCNEW_ARRAY, GCREALLOC_ARRAY
+ isalnum etc. directly CTYPE
+ libxl__ctx_[un]lock CTX_LOCK, CTX_UNLOCK
+ gc=...; ao=...; EGC_GC, AO_GC, STATE_AO_GC
+ explicit gc creation GC_INIT, GC_FREE
+ memset(..,0,sizeof..) FILLZERO
+
+Instead of malloc et al one should (as an exception to the above) use
+libxl__{zalloc,calloc,realloc} etc but passing NOGC.
+
+ERROR HANDLING
+--------------
+
+Unless, there are good reasons to do otherwise, the following error
+handling and cleanup paradigm should be used:
+
+ * All local variables referring to resources which might need
+ cleaning up are declared at the top of the function, and
+ initialised to a sentinel value indicating "nothing allocated".
+ For example,
+ libxl_evgen_disk_eject *evg = NULL;
+ int nullfd = -1;
+
+ * If the function is to return a libxl error value, `rc' is
+ used to contain the error code, but it is NOT initialised:
+ int rc;
+
+ * There is only one error cleanup path out of the function. It
+ starts with a label `out:'. That error cleanup path checks for
+ each allocated resource and frees it iff necessary. It then
+ returns rc. For example,
+ out:
+ if (evg) libxl__evdisable_disk_eject(gc, evg);
+ if (nullfd >= 0) close(nullfd);
+ return rc;
+
+ * Function calls which might fail (ie most function calls) are
+ handled by putting the return/status value into a variable, and
+ then checking it in a separate statement:
+ char *dompath = libxl__xs_get_dompath(gc, bl->domid);
+ if (!dompath) { rc = ERROR_FAIL; goto out; }
+
+ * If a resource is freed in the main body of the function (for
+ example, in a loop), the corresponding variable has to be reset to
+ the sentinel at the point where it's freed.
+
+Whether to use the `out' path for successful returns as well as error
+returns is a matter of taste and convenience for the specific
+function. Not reusing the out path is fine if the duplicated function
+exit code is only `CTX_UNLOCK; GC_FREE;' (or similar).
+
+If you reuse the `out' path for successful returns, there may be
+resources which are to be returned to the caller rather than freed.
+In that case you have to reset the local variable to `nothing here',
+to avoid the resource being freed on the out path. That resetting
+should be done immediately after the resource value is stored at the
+applicable _r function parameter (or equivalent). Do not test `rc' in
+the out section, to discover whether to free things.
+
+The uses of the single-line formatting in the examples above are
+permitted exceptions to the usual libxl code formatting rules.
+
+
+
+IDEMPOTENT DATA STRUCTURE CONSTRUCTION/DESTRUCTION
+--------------------------------------------------
+
+Nontrivial data structures (in structs) should come with an idempotent
+_dispose function, which must free all resources associated with the
+data structure (but not free the struct itself).
+
+Such a struct should also come with an _init function which
+initialises the struct so that _dispose is a no-op.
+
+
+ASYNCHRONOUS/LONG-RUNNING OPERATIONS
+------------------------------------
+
+All long-running operations in libxl need to use the asynchronous
+operation machinery. Consult the programmer documentation in
+libxl_internal.h for details - search for "Machinery for asynchronous
+operations".
+
+The code for asynchronous operations should be laid out in
+chronological order. That is, where there is a chain of callback
+functions, each subsequent function should be, textually, the next
+function in the file. This will normally involve predeclaring the
+callback functions. Synchronous helper functions should be separated
+out into a section preceding the main callback chain.
+
+Control flow arrangements in asynchronous operations should be made as
+simple as possible, because it can otherwise be very hard to see
+through the tangle.
+
+
+When inventing a new sub-operation in asynchronous code, consider
+whether to structure it formally as a sub-operation with its own state
+structure. (See, for example, libxl__datacopier_*.)
+
+An ao-suboperation state structure should contain, in this order:
+ * fields that the caller must fill in, and which are,
+ effectively, the parameters to the operation, including:
+ - libxl__ao *ao
+ - the callback function pointer(s), which
+ should be named callback or callback_*.
+ * shared information fields or ones used for returning information
+ to the calling operation
+ * private fields
+These sections should be clearly demarcated by comments.
+
+An asynchronous operation should normally have an idempotent stop or
+cancel function. It should normally also have an _init function for
+its state struct, which arranges that the stop is a no-op.
+
+The permitted order of calls into your ao operation's methods must be
+documented in comments, if it is nontrivial.
+
+
+When using an ao sub-operation, you should normally:
+ * Physically include the sub-operation state struct in your
+ own state struct;
+ * Use CONTAINER_OF to find your own state struct at the start of
+ your implementations of the sub-operation callback functions;
+ * Unconditionally initialise the sub-operation's struct (with its
+ _init method) in your own _init method.
+ * Unconditionally cancel or destroy the sub-operation in your own
+ cancel or destroy method.
+
+
+FORMATTING AND NAMING
+---------------------
+
+Blatantly copied from qemu and linux with few modifications.
+
+
+1. Whitespace
+
+Of course, the most important aspect in any coding style is whitespace.
+Crusty old coders who have trouble spotting the glasses on their noses
+can tell the difference between a tab and eight spaces from a distance
+of approximately fifteen parsecs. Many a flamewar have been fought and
+lost on this issue.
+
+Libxenlight indents are four spaces. Tabs are never used, except in
+Makefiles where they have been irreversibly coded into the syntax.
+Spaces of course are superior to tabs because:
+
+ - You have just one way to specify whitespace, not two. Ambiguity breeds
+ mistakes.
+ - The confusion surrounding 'use tabs to indent, spaces to justify' is gone.
+ - Tab indents push your code to the right, making your screen seriously
+ unbalanced.
+ - Tabs will be rendered incorrectly on editors who are misconfigured not
+ to use tab stops of eight positions.
+ - Tabs are rendered badly in patches, causing off-by-one errors in almost
+ every line.
+ - It is the libxenlight coding style.
+
+Do not leave whitespace dangling off the ends of lines.
+
+
+2. Line width
+
+Lines are limited to 75 characters.
+
+Rationale:
+ - Some people like to tile their 24" screens with a 6x4 matrix of 80x24
+ xterms and use vi in all of them. The best way to punish them is to
+ let them keep doing it.
+ - In an 80 column terminal, some room needs to be left for > quoting
+ characters, +/- diff characters, and so on, in emails.
+ - Code and especially patches is much more readable if limited to a sane
+ line length. Eighty is traditional.
+ - It is the libxenlight coding style.
+
+
+3. Naming
+
+C is a Spartan language, and so should your naming be. Unlike Modula-2
+and Pascal programmers, C programmers do not use cute names like
+ThisVariableIsATemporaryCounter. A C programmer would call that
+variable "tmp", which is much easier to write, and not the least more
+difficult to understand.
+
+HOWEVER, while mixed-case names are frowned upon, descriptive names for
+global variables are a must. To call a global function "foo" is a
+shooting offense.
+
+GLOBAL variables (to be used only if you _really_ need them) need to
+have descriptive names, as do global functions. If you have a function
+that counts the number of active users, you should call that
+"count_active_users()" or similar, you should _not_ call it "cntusr()".
+
+Encoding the type of a function into the name (so-called Hungarian
+notation) is brain damaged - the compiler knows the types anyway and can
+check those, and it only confuses the programmer.
+
+LOCAL variable names should be short, and to the point. If you have
+some random integer loop counter, it should probably be called "i".
+Calling it "loop_counter" is non-productive, if there is no chance of it
+being mis-understood. Similarly, "tmp" can be just about any type of
+variable that is used to hold a temporary value.
+
+Local variables used to store return values should have descriptive name
+like "rc" or "ret". Following the same reasoning the label used as exit
+path should be called "out".
+
+Function arguments which are used to return values to the caller
+should be suffixed `_r' or `_out'.
+
+Variables, type names and function names are
+lower_case_with_underscores.
+Type names and function names use the prefix libxl__ when internal to
+libxenlight and libxl_ when exported in libxl.h.
+Xl should avoid using libxl_ and libxl__ as prefix for its own function
+names.
+
+When wrapping standard library functions, use the prefix libxl_ to alert
+readers that they are seeing a wrapped version; otherwise avoid this prefix.
+
+Typedefs are used to eliminate the redundant 'struct' keyword.
+It is the libxenlight coding style.
+
+
+4. Statements
+
+Don't put multiple statements on a single line.
+Don't put multiple assignments on a single line either.
+Error code paths with an if statement and a goto or a return on the same
+line are allowed. Examples:
+
+ if (rc) goto out;
+ if (rc < 0) return;
+
+Libxenlight coding style is super simple. Avoid tricky expressions.
+
+
+5. Block structure
+
+Every indented statement is braced, but blocks that contain just one
+statement may have the braces omitted. To avoid confusion, either all
+the blocks in an if...else chain have braces, or none of them do.
+
+The opening brace is on the line that contains the control flow
+statement that introduces the new block; the closing brace is on the
+same line as the else keyword, or on a line by itself if there is no
+else keyword. Examples:
+
+ if (a == 5) {
+ printf("a was 5.\n");
+ } else if (a == 6) {
+ printf("a was 6.\n");
+ } else {
+ printf("a was something else entirely.\n");
+ }
+
+ if (a == 5)
+ printf("a was 5.\n");
+
+An exception is the opening brace for a function; for reasons of tradition
+and clarity it comes on a line by itself:
+
+ void a_function(void)
+ {
+ do_something();
+ }
+
+Rationale: a consistent (except for functions...) bracing style reduces
+ambiguity and avoids needless churn when lines are added or removed.
+Furthermore, it is the libxenlight coding style.
+
--- /dev/null
+XEN_ROOT = $(CURDIR)/../../..
+include $(XEN_ROOT)/tools/Rules.mk
+
+SRCS-y += libxlu_cfg_y.c
+SRCS-y += libxlu_cfg_l.c
+SRCS-y += libxlu_cfg.c
+SRCS-y += libxlu_disk_l.c
+SRCS-y += libxlu_disk.c
+SRCS-y += libxlu_vif.c
+SRCS-y += libxlu_pci.c
+
+CFLAGS += -Wno-format-zero-length -Wmissing-declarations \
+ -Wno-declaration-after-statement -Wformat-nonliteral
+CFLAGS += -I. $(CFLAGS_libxenctrl)
+
+CFLAGS += $(PTHREAD_CFLAGS)
+LDFLAGS += $(PTHREAD_LDFLAGS)
+
+ifeq ($(FLEX),)
+%.c %.h:: %.l
+ $(warning Flex is needed to rebuild some libxl parsers and \
+ scanners, please install it and rerun configure)
+endif
+
+ifeq ($(BISON),)
+%.c %.h:: %.y
+ $(warning Bison is needed to rebuild some libxl parsers and \
+ scanners, please install it and rerun configure)
+endif
+
+AUTOINCS = libxlu_cfg_y.h libxlu_cfg_l.h libxlu_disk_l.h
+AUTOSRCS = libxlu_cfg_y.c libxlu_cfg_l.c
+
+LIBHEADER := libxlutil.h
+PKG_CONFIG_NAME := Xlutil
+PKG_CONFIG_DESC := The xl utility library for Xen hypervisor
+
+NO_HEADERS_CHK := y
+
+include $(XEN_ROOT)/tools/libs/libs.mk
+
+$(PKG_CONFIG_LOCAL): PKG_CONFIG_INCDIR = $(XEN_libxenutil)/include
+$(PKG_CONFIG_LOCAL): PKG_CONFIG_CFLAGS_LOCAL = $(CFLAGS_xeninclude)
+
+$(LIB_OBJS) $(PIC_OBJS): $(AUTOINCS) _paths.h
+
+%.c %.h:: %.y
+ @rm -f $*.[ch]
+ $(BISON) --output=$*.c $<
+
+%.c %.h:: %.l
+ @rm -f $*.[ch]
+ $(FLEX) --header-file=$*.h --outfile=$*.c $<
+
+genpath-target = $(call buildmakevars2header,_paths.h)
+$(eval $(genpath-target))
+
+clean: cleanlocal
+
+.PHONY: cleanlocal
+cleanlocal:
+ $(RM) -f _*.h
+ $(RM) -f libxlutil.map
--- /dev/null
+/*
+ * Copyright (C) 2010 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+#ifndef LIBXLUTIL_H
+#define LIBXLUTIL_H
+
+#include <stdio.h>
+
+#include "libxl.h"
+
+enum XLU_ConfigValueType {
+ XLU_STRING,
+ XLU_LIST,
+};
+
+enum XLU_Operation {
+ XLU_OP_ASSIGNMENT = 0,
+ XLU_OP_ADDITION,
+};
+
+/* Unless otherwise stated, all functions return an errno value. */
+typedef struct XLU_Config XLU_Config;
+typedef struct XLU_ConfigList XLU_ConfigList;
+typedef struct XLU_ConfigValue XLU_ConfigValue;
+
+XLU_Config *xlu_cfg_init(FILE *report, const char *report_filename);
+ /* 0 means we got ENOMEM. */
+ /* report_filename is copied; report is saved and must remain valid
+ * until the Config is destroyed. */
+
+int xlu_cfg_readfile(XLU_Config*, const char *real_filename);
+int xlu_cfg_readdata(XLU_Config*, const char *data, int length);
+ /* If these fail, then it is undefined behaviour to call xlu_cfg_get_...
+ * functions. You have to just xlu_cfg_destroy. */
+
+void xlu_cfg_destroy(XLU_Config*);
+
+
+/* All of the following print warnings to "report" if there is a problem.
+ * Return values are:
+ * 0 OK
+ * ESRCH not defined
+ * EINVAL value found but wrong format for request (prints warning unless dont_warn=true)
+ * ERANGE value out of range (from strtol)
+ */
+
+int xlu_cfg_get_string(const XLU_Config*, const char *n, const char **value_r,
+ int dont_warn);
+/* free/strdup version */
+int xlu_cfg_replace_string(const XLU_Config *cfg, const char *n,
+ char **value_r, int dont_warn);
+int xlu_cfg_get_long(const XLU_Config*, const char *n, long *value_r,
+ int dont_warn);
+int xlu_cfg_get_bounded_long(const XLU_Config*, const char *n, long min,
+ long max, long *value_r, int dont_warn);
+int xlu_cfg_get_defbool(const XLU_Config*, const char *n, libxl_defbool *b,
+ int dont_warn);
+
+int xlu_cfg_get_list(const XLU_Config*, const char *n,
+ XLU_ConfigList **list_r /* may be 0 */,
+ int *entries_r /* may be 0 */,
+ int dont_warn);
+ /* there is no need to free *list_r; lifetime is that of the XLU_Config */
+int xlu_cfg_get_list_as_string_list(const XLU_Config *cfg, const char *n,
+ libxl_string_list *sl, int dont_warn);
+const char *xlu_cfg_get_listitem(const XLU_ConfigList*, int entry);
+ /* xlu_cfg_get_listitem cannot fail, except that if entry is
+ * out of range it returns 0 (not setting errno) */
+
+enum XLU_ConfigValueType xlu_cfg_value_type(const XLU_ConfigValue *value);
+int xlu_cfg_value_get_string(const XLU_Config *cfg, XLU_ConfigValue *value,
+ char **value_r, int dont_warn);
+int xlu_cfg_value_get_list(const XLU_Config *cfg, XLU_ConfigValue *value,
+ XLU_ConfigList **value_r, int dont_warn);
+XLU_ConfigValue *xlu_cfg_get_listitem2(const XLU_ConfigList *list,
+ int entry);
+
+/*
+ * Disk specification parsing.
+ */
+
+int xlu_disk_parse(XLU_Config *cfg, int nspecs, const char *const *specs,
+ libxl_device_disk *disk);
+ /* disk must have been initialised.
+ *
+ * On error, returns errno value. Bad strings cause EINVAL and
+ * print a message to cfg's report (that's all cfg is used for).
+ *
+ * Normally one would pass nspecs==1 and only specs[0]. But it is
+ * permitted to pass more strings in which case each is parsed as a
+ * string containing a collection of parameters (but they all refer
+ * to of the configuration for a single disk).
+ *
+ * nspecs==0 is permitted but since it does not specify some mandatory
+ * properties, it produces a run-time configuration error if the
+ * resulting disk struct is used with libxl.
+ */
+
+/*
+ * PCI specification parsing
+ */
+int xlu_pci_parse_bdf(XLU_Config *cfg, libxl_device_pci *pcidev, const char *str);
+
+/*
+ * RDM parsing
+ */
+int xlu_rdm_parse(XLU_Config *cfg, libxl_rdm_reserve *rdm, const char *str);
+
+/*
+ * Vif rate parsing.
+ */
+
+int xlu_vif_parse_rate(XLU_Config *cfg, const char *rate,
+ libxl_device_nic *nic);
+
+#endif /* LIBXLUTIL_H */
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- /dev/null
+/*
+ * libxlu_cfg.c - xl configuration file parsing: setup and helper functions
+ *
+ * Copyright (C) 2010 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+#define _GNU_SOURCE
+
+#include <limits.h>
+
+#include "libxlu_internal.h"
+#include "libxlu_cfg_y.h"
+#include "libxlu_cfg_l.h"
+#include "libxlu_cfg_i.h"
+
+XLU_Config *xlu_cfg_init(FILE *report, const char *report_source) {
+ XLU_Config *cfg;
+
+ cfg= malloc(sizeof(*cfg));
+ if (!cfg) return 0;
+
+ cfg->report= report;
+ cfg->config_source= strdup(report_source);
+ if (!cfg->config_source) { free(cfg); return 0; }
+
+ cfg->settings= 0;
+ return cfg;
+}
+
+static int ctx_prep(CfgParseContext *ctx, XLU_Config *cfg) {
+ int e;
+
+ ctx->cfg= cfg;
+ ctx->err= 0;
+ ctx->lexerrlineno= -1;
+ ctx->likely_python= 0;
+ ctx->scanner= 0;
+
+ e= xlu__cfg_yylex_init_extra(ctx, &ctx->scanner);
+ if (e) {
+ fprintf(cfg->report,"%s: unable to create scanner: %s\n",
+ cfg->config_source, strerror(e));
+ return e;
+ }
+ return 0;
+}
+
+static void ctx_dispose(CfgParseContext *ctx) {
+ if (ctx->scanner) xlu__cfg_yylex_destroy(ctx->scanner);
+}
+
+static void parse(CfgParseContext *ctx) {
+ /* On return, ctx.err will be updated with the error status. */
+ int r;
+
+ xlu__cfg_yyset_lineno(1, ctx->scanner);
+
+ r= xlu__cfg_yyparse(ctx);
+ if (r) assert(ctx->err);
+
+ if (ctx->err && ctx->likely_python) {
+ fputs(
+ "warning: Config file looks like it contains Python code.\n"
+ "warning: Arbitrary Python is no longer supported.\n"
+ "warning: See https://wiki.xen.org/wiki/PythonInXlConfig\n",
+ ctx->cfg->report);
+ }
+}
+
+int xlu_cfg_readfile(XLU_Config *cfg, const char *real_filename) {
+ FILE *f = 0;
+ int e;
+
+ CfgParseContext ctx;
+ e = ctx_prep(&ctx, cfg);
+ if (e) { ctx.err= e; goto xe; }
+
+ f= fopen(real_filename, "r");
+ if (!f) {
+ ctx.err = errno;
+ fprintf(cfg->report,"%s: unable to open configuration file: %s\n",
+ real_filename, strerror(e));
+ goto xe;
+ }
+
+ xlu__cfg_yyrestart(f, ctx.scanner);
+
+ parse(&ctx);
+
+ xe:
+ ctx_dispose(&ctx);
+ if (f) fclose(f);
+
+ return ctx.err;
+}
+
+int xlu_cfg_readdata(XLU_Config *cfg, const char *data, int length) {
+ int e;
+ YY_BUFFER_STATE buf= 0;
+
+ CfgParseContext ctx;
+ e= ctx_prep(&ctx, cfg);
+ if (e) { ctx.err= e; goto xe; }
+
+ buf = xlu__cfg_yy_scan_bytes(data, length, ctx.scanner);
+ if (!buf) {
+ fprintf(cfg->report,"%s: unable to allocate scanner buffer\n",
+ cfg->config_source);
+ ctx.err= ENOMEM;
+ goto xe;
+ }
+
+ parse(&ctx);
+
+ xe:
+ if (buf) xlu__cfg_yy_delete_buffer(buf, ctx.scanner);
+ ctx_dispose(&ctx);
+
+ return ctx.err;
+}
+
+void xlu__cfg_value_free(XLU_ConfigValue *value)
+{
+ int i;
+
+ if (!value) return;
+
+ switch (value->type) {
+ case XLU_STRING:
+ free(value->u.string);
+ break;
+ case XLU_LIST:
+ for (i = 0; i < value->u.list.nvalues; i++)
+ xlu__cfg_value_free(value->u.list.values[i]);
+ free(value->u.list.values);
+ }
+ free(value);
+}
+
+void xlu__cfg_set_free(XLU_ConfigSetting *set) {
+ if (!set) return;
+ free(set->name);
+ xlu__cfg_value_free(set->value);
+ free(set);
+}
+
+void xlu_cfg_destroy(XLU_Config *cfg) {
+ XLU_ConfigSetting *set, *set_next;
+
+ if (!cfg) return;
+ for (set= cfg->settings;
+ set;
+ set= set_next) {
+ set_next= set->next;
+ xlu__cfg_set_free(set);
+ }
+ free(cfg->config_source);
+ free(cfg);
+}
+
+static XLU_ConfigSetting *find(const XLU_Config *cfg, const char *n) {
+ XLU_ConfigSetting *set;
+
+ for (set= cfg->settings;
+ set;
+ set= set->next)
+ if (!strcmp(set->name, n))
+ return set;
+ return 0;
+}
+
+static int find_atom(const XLU_Config *cfg, const char *n,
+ XLU_ConfigSetting **set_r, int dont_warn) {
+ XLU_ConfigSetting *set;
+
+ set= find(cfg,n);
+ if (!set) return ESRCH;
+
+ if (set->value->type!=XLU_STRING) {
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d: warning: parameter `%s' is"
+ " a list but should be a single value\n",
+ cfg->config_source, set->lineno, n);
+ return EINVAL;
+ }
+ *set_r= set;
+ return 0;
+}
+
+
+enum XLU_ConfigValueType xlu_cfg_value_type(const XLU_ConfigValue *value)
+{
+ return value->type;
+}
+
+int xlu_cfg_value_get_string(const XLU_Config *cfg, XLU_ConfigValue *value,
+ char **value_r, int dont_warn)
+{
+ if (value->type != XLU_STRING) {
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d:%d: warning: value is not a string\n",
+ cfg->config_source, value->loc.first_line,
+ value->loc.first_column);
+ *value_r = NULL;
+ return EINVAL;
+ }
+
+ *value_r = value->u.string;
+ return 0;
+}
+
+int xlu_cfg_value_get_list(const XLU_Config *cfg, XLU_ConfigValue *value,
+ XLU_ConfigList **value_r, int dont_warn)
+{
+ if (value->type != XLU_LIST) {
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d:%d: warning: value is not a list\n",
+ cfg->config_source, value->loc.first_line,
+ value->loc.first_column);
+ *value_r = NULL;
+ return EINVAL;
+ }
+
+ *value_r = &value->u.list;
+ return 0;
+}
+
+XLU_ConfigValue *xlu_cfg_get_listitem2(const XLU_ConfigList *list,
+ int entry)
+{
+ if (entry < 0 || entry >= list->nvalues) return NULL;
+ return list->values[entry];
+}
+
+int xlu_cfg_get_string(const XLU_Config *cfg, const char *n,
+ const char **value_r, int dont_warn) {
+ XLU_ConfigSetting *set;
+ int e;
+
+ e= find_atom(cfg,n,&set,dont_warn); if (e) return e;
+ *value_r= set->value->u.string;
+ return 0;
+}
+
+int xlu_cfg_replace_string(const XLU_Config *cfg, const char *n,
+ char **value_r, int dont_warn) {
+ XLU_ConfigSetting *set;
+ int e;
+
+ e= find_atom(cfg,n,&set,dont_warn); if (e) return e;
+ free(*value_r);
+ *value_r= strdup(set->value->u.string);
+ return 0;
+}
+
+int xlu_cfg_get_bounded_long(const XLU_Config *cfg, const char *n,
+ long min, long max, long *value_r,
+ int dont_warn) {
+ long l;
+ XLU_ConfigSetting *set;
+ int e;
+ char *ep;
+
+ e= find_atom(cfg,n,&set,dont_warn); if (e) return e;
+ if (set->op == XLU_OP_ADDITION) {
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d: warning: can't use += with numbers"
+ " for parameter `%s'\n",
+ cfg->config_source, set->lineno, n);
+ return EINVAL;
+ }
+ errno= 0; l= strtol(set->value->u.string, &ep, 0);
+ e= errno;
+ if (errno) {
+ e= errno;
+ assert(e==EINVAL || e==ERANGE);
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d: warning: parameter `%s' could not be parsed"
+ " as a number: %s\n",
+ cfg->config_source, set->lineno, n, strerror(e));
+ return e;
+ }
+ if (*ep || ep==set->value->u.string) {
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d: warning: parameter `%s' is not a valid number\n",
+ cfg->config_source, set->lineno, n);
+ return EINVAL;
+ }
+ if (l < min) {
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d: warning: value `%ld' is smaller than minimum bound '%ld'\n",
+ cfg->config_source, set->lineno, l, min);
+ return EINVAL;
+ }
+ if (l > max) {
+ if (!dont_warn)
+ fprintf(cfg->report,
+ "%s:%d: warning: value `%ld' is greater than maximum bound '%ld'\n",
+ cfg->config_source, set->lineno, l, max);
+ return EINVAL;
+ }
+
+ *value_r= l;
+ return 0;
+}
+
+int xlu_cfg_get_long(const XLU_Config *cfg, const char *n,
+ long *value_r, int dont_warn) {
+ return xlu_cfg_get_bounded_long(cfg, n, LONG_MIN, LONG_MAX, value_r,
+ dont_warn);
+}
+
+int xlu_cfg_get_defbool(const XLU_Config *cfg, const char *n, libxl_defbool *b,
+ int dont_warn)
+{
+ int ret;
+ long l;
+
+ ret = xlu_cfg_get_long(cfg, n, &l, dont_warn);
+ if (ret) return ret;
+ libxl_defbool_set(b, !!l);
+ return 0;
+}
+
+int xlu_cfg_get_list(const XLU_Config *cfg, const char *n,
+ XLU_ConfigList **list_r, int *entries_r, int dont_warn) {
+ XLU_ConfigSetting *set;
+ set= find(cfg,n); if (!set) return ESRCH;
+ if (set->value->type!=XLU_LIST) {
+ if (!dont_warn) {
+ fprintf(cfg->report,
+ "%s:%d: warning: parameter `%s' is a single value"
+ " but should be a list\n",
+ cfg->config_source, set->lineno, n);
+ }
+ return EINVAL;
+ }
+ if (list_r) *list_r= &set->value->u.list;
+ if (entries_r) *entries_r= set->value->u.list.nvalues;
+ return 0;
+}
+
+int xlu_cfg_get_list_as_string_list(const XLU_Config *cfg, const char *n,
+ libxl_string_list *psl, int dont_warn) {
+ int i, rc, nr;
+ XLU_ConfigList *list;
+ libxl_string_list sl;
+
+ rc = xlu_cfg_get_list(cfg, n, &list, &nr, dont_warn);
+ if (rc) return rc;
+
+ sl = malloc(sizeof(char*)*(nr + 1));
+ if (sl == NULL) return ENOMEM;
+
+ for (i=0; i<nr; i++) {
+ const char *a = xlu_cfg_get_listitem(list, i);
+ sl[i] = a ? strdup(a) : NULL;
+ }
+
+ sl[nr] = NULL;
+
+ *psl = sl;
+ return 0;
+}
+
+const char *xlu_cfg_get_listitem(const XLU_ConfigList *list, int entry) {
+ if (entry < 0 || entry >= list->nvalues) return 0;
+ if (list->values[entry]->type != XLU_STRING) return 0;
+ return list->values[entry]->u.string;
+}
+
+
+XLU_ConfigValue *xlu__cfg_string_mk(CfgParseContext *ctx, char *atom,
+ YYLTYPE *loc)
+{
+ XLU_ConfigValue *value = NULL;
+
+ if (ctx->err) goto x;
+
+ value = malloc(sizeof(*value));
+ if (!value) goto xe;
+ value->type = XLU_STRING;
+ value->u.string = atom;
+ memcpy(&value->loc, loc, sizeof(*loc));
+
+ return value;
+
+ xe:
+ ctx->err= errno;
+ x:
+ free(value);
+ free(atom);
+ return NULL;
+}
+
+XLU_ConfigValue *xlu__cfg_list_mk(CfgParseContext *ctx,
+ XLU_ConfigValue *val,
+ YYLTYPE *loc)
+{
+ XLU_ConfigValue *value = NULL;
+ XLU_ConfigValue **values = NULL;
+
+ if (ctx->err) goto x;
+
+ values = malloc(sizeof(*values));
+ if (!values) goto xe;
+ values[0] = val;
+
+ value = malloc(sizeof(*value));
+ if (!value) goto xe;
+ value->type = XLU_LIST;
+ value->u.list.nvalues = !!val;
+ value->u.list.avalues = 1;
+ value->u.list.values = values;
+ memcpy(&value->loc, loc, sizeof(*loc));
+
+ return value;
+
+ xe:
+ ctx->err= errno;
+ x:
+ free(value);
+ free(values);
+ xlu__cfg_value_free(val);
+ return NULL;
+}
+
+void xlu__cfg_list_append(CfgParseContext *ctx,
+ XLU_ConfigValue *list,
+ XLU_ConfigValue *val)
+{
+ if (ctx->err) return;
+
+ assert(val);
+ assert(list->type == XLU_LIST);
+
+ if (list->u.list.nvalues >= list->u.list.avalues) {
+ int new_avalues;
+ XLU_ConfigValue **new_values = NULL;
+
+ if (list->u.list.avalues > INT_MAX / 100) {
+ ctx->err = ERANGE;
+ xlu__cfg_value_free(val);
+ return;
+ }
+
+ new_avalues = list->u.list.avalues * 4;
+ new_values = realloc(list->u.list.values,
+ sizeof(*new_values) * new_avalues);
+ if (!new_values) {
+ ctx->err = errno;
+ xlu__cfg_value_free(val);
+ return;
+ }
+
+ list->u.list.avalues = new_avalues;
+ list->u.list.values = new_values;
+ }
+
+ list->u.list.values[list->u.list.nvalues] = val;
+ list->u.list.nvalues++;
+}
+
+static int xlu__cfg_concat_vals(CfgParseContext *ctx,
+ XLU_ConfigValue *prev,
+ XLU_ConfigValue *to_add)
+{
+ int r;
+
+ if (prev->type != to_add->type) {
+ xlu__cfgl_lexicalerror(ctx,
+ "can't add [list] to \"string\" or vice versa");
+ return EINVAL;
+ }
+
+ switch (to_add->type) {
+ case XLU_STRING: {
+ char *new_string = NULL;
+
+ r = asprintf(&new_string, "%s%s", prev->u.string,
+ to_add->u.string);
+ if (r < 0) {
+ return errno;
+ }
+ free(to_add->u.string);
+ to_add->u.string = new_string;
+ return 0;
+ }
+ case XLU_LIST: {
+ XLU_ConfigList *const prev_list = &prev->u.list;
+ XLU_ConfigList *const cur_list = &to_add->u.list;
+ int nvalues;
+
+ if (prev->u.list.nvalues > INT_MAX - to_add->u.list.nvalues) {
+ return ERANGE;
+ }
+ nvalues = prev->u.list.nvalues + to_add->u.list.nvalues;
+
+ if (nvalues >= cur_list->avalues) {
+ XLU_ConfigValue **new_vals;
+ new_vals = realloc(cur_list->values,
+ nvalues * sizeof(*new_vals));
+ if (!new_vals) {
+ return ENOMEM;
+ }
+ cur_list->avalues = nvalues;
+ cur_list->values = new_vals;
+ }
+
+ /* make space for `prev' into `to_add' */
+ memmove(cur_list->values + prev_list->nvalues,
+ cur_list->values,
+ cur_list->nvalues * sizeof(XLU_ConfigValue *));
+ /* move values from `prev' to `to_add' as the list in `prev' will
+ * not be reachable by find(). */
+ memcpy(cur_list->values,
+ prev_list->values,
+ prev_list->nvalues * sizeof(XLU_ConfigValue *));
+ cur_list->nvalues = nvalues;
+ prev_list->nvalues = 0;
+ memset(prev_list->values, 0,
+ prev_list->nvalues * sizeof(XLU_ConfigValue *));
+ return 0;
+ }
+ default:
+ abort();
+ }
+ return -1;
+}
+
+void xlu__cfg_set_store(CfgParseContext *ctx, char *name,
+ enum XLU_Operation op,
+ XLU_ConfigValue *val, int lineno) {
+ XLU_ConfigSetting *set;
+ int r;
+
+ if (ctx->err) goto out;
+
+ assert(name);
+
+ if (op == XLU_OP_ADDITION) {
+ /* If we have += concatenate with previous value with same name */
+ XLU_ConfigSetting *prev_set = find(ctx->cfg, name);
+ if (prev_set) {
+ r = xlu__cfg_concat_vals(ctx, prev_set->value, val);
+ if (r) {
+ ctx->err = r;
+ goto out;
+ }
+ }
+ }
+
+ set = malloc(sizeof(*set));
+ if (!set) {
+ ctx->err = errno;
+ goto out;
+ }
+ set->name= name;
+ set->value = val;
+ set->op = op;
+ set->lineno= lineno;
+ set->next= ctx->cfg->settings;
+ ctx->cfg->settings= set;
+ return;
+out:
+ assert(ctx->err);
+ free(name);
+ xlu__cfg_value_free(val);
+}
+
+char *xlu__cfgl_strdup(CfgParseContext *ctx, const char *src) {
+ char *result;
+
+ if (ctx->err) return 0;
+ result= strdup(src);
+ if (!result) ctx->err= errno;
+ return result;
+}
+
+char *xlu__cfgl_dequote(CfgParseContext *ctx, const char *src) {
+ char *result;
+ const char *p;
+ char *q;
+ int len, c, nc;
+
+ if (ctx->err) return 0;
+
+ len= strlen(src);
+ assert(len>=2 && src[0]==src[len-1]);
+
+ result= malloc(len-1);
+ if (!result) { ctx->err= errno; return 0; }
+
+ q= result;
+
+ for (p= src+1;
+ p < src+len-1;
+ ) {
+ c= *p++;
+ if (c=='\\') {
+ assert(p < src+len-1);
+ nc= *p++;
+ if (nc=='"' || nc=='\'' || nc=='\\') {
+ *q++= nc;
+ } else if (nc=='a') { *q++= '\007';
+ } else if (nc=='b') { *q++= '\010';
+ } else if (nc=='f') { *q++= '\014';
+ } else if (nc=='n') { *q++= '\n';
+ } else if (nc=='r') { *q++= '\r';
+ } else if (nc=='t') { *q++= '\t';
+ } else if (nc=='v') { *q++= '\013';
+ } else if (nc=='x') {
+
+#define NUMERIC_CHAR(minlen,maxlen,base,basetext) do{ \
+ char numbuf[(maxlen)+1], *ep; \
+ unsigned long val; \
+ \
+ strncpy(numbuf,p,(maxlen)); \
+ numbuf[(maxlen)]= 0; \
+ val= strtoul(numbuf, &ep, (base)); \
+ if (ep <= numbuf+(minlen)) { \
+ xlu__cfgl_lexicalerror(ctx,"invalid digit after" \
+ " backslash " basetext "numerical character escape" \
+ " in quoted string"); \
+ ctx->err= EINVAL; \
+ goto x; \
+ } \
+ p += (ep - numbuf); \
+ }while(0)
+
+ p++;
+ NUMERIC_CHAR(2,2,16,"hex");
+ } else if (nc>='0' && nc<='7') {
+ NUMERIC_CHAR(1,3,10,"octal");
+ } else {
+ xlu__cfgl_lexicalerror(ctx,
+ "invalid character after backlash in quoted string");
+ ctx->err= EINVAL;
+ goto x;
+ }
+ assert(p <= src+len-1);
+ } else {
+ *q++= c;
+ }
+ }
+
+ x:
+ *q++= 0;
+ return result;
+}
+
+void xlu__cfgl_lexicalerror(CfgParseContext *ctx, char const *msg) {
+ YYLTYPE loc;
+ loc.first_line= xlu__cfg_yyget_lineno(ctx->scanner);
+ xlu__cfg_yyerror(&loc, ctx, msg);
+ ctx->lexerrlineno= loc.first_line;
+}
+
+void xlu__cfg_yyerror(YYLTYPE *loc, CfgParseContext *ctx, char const *msg) {
+ const char *text, *newline;
+ int len, lineno;
+
+ lineno= loc->first_line;
+ if (lineno <= ctx->lexerrlineno) return;
+
+ text= xlu__cfg_yyget_text(ctx->scanner);
+ len= xlu__cfg_yyget_leng(ctx->scanner);
+ newline= "";
+ if (len>0 && text[len-1]=='\n') {
+ len--;
+ lineno--;
+ if (!len) {
+ newline= "<newline>";
+ }
+ }
+ while (len>0 && (text[len-1]=='\t' || text[len-1]==' ')) {
+ len--;
+ }
+
+ fprintf(ctx->cfg->report,
+ "%s:%d: config parsing error near %s%.*s%s%s: %s\n",
+ ctx->cfg->config_source, lineno,
+ len?"`":"", len, text, len?"'":"", newline,
+ msg);
+ if (!ctx->err) ctx->err= EINVAL;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- /dev/null
+/*
+ * libxlu_cfg_i.h - xl configuration file parsing: parser-internal declarations
+ *
+ * Copyright (C) 2010 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+#ifndef LIBXLU_CFG_I_H
+#define LIBXLU_CFG_I_H
+
+#include "libxlu_internal.h"
+#include "libxlu_cfg_y.h"
+
+void xlu__cfg_set_free(XLU_ConfigSetting *set);
+void xlu__cfg_set_store(CfgParseContext*, char *name,
+ enum XLU_Operation op,
+ XLU_ConfigValue *val, int lineno);
+XLU_ConfigValue *xlu__cfg_string_mk(CfgParseContext *ctx,
+ char *atom, YYLTYPE *loc);
+XLU_ConfigValue *xlu__cfg_list_mk(CfgParseContext *ctx,
+ XLU_ConfigValue *val,
+ YYLTYPE *loc);
+void xlu__cfg_list_append(CfgParseContext *ctx,
+ XLU_ConfigValue *list,
+ XLU_ConfigValue *val);
+void xlu__cfg_value_free(XLU_ConfigValue *value);
+char *xlu__cfgl_strdup(CfgParseContext*, const char *src);
+char *xlu__cfgl_dequote(CfgParseContext*, const char *src);
+
+void xlu__cfg_yyerror(YYLTYPE *locp, CfgParseContext*, char const *msg);
+void xlu__cfgl_lexicalerror(CfgParseContext*, char const *msg);
+
+void xlu__cfgl_likely_python(CfgParseContext *ctx);
+
+
+
+/* Why oh why does bison not declare this in its autogenerated .h ? */
+int xlu__cfg_yyparse(CfgParseContext *ctx);
+
+
+#endif /*LIBXLU_CFG_I_H*/
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- /dev/null
+#line 2 "libxlu_cfg_l.c"
+
+#line 4 "libxlu_cfg_l.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 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define xlu__cfg_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer xlu__cfg_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define xlu__cfg_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer xlu__cfg_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define xlu__cfg_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer xlu__cfg_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define xlu__cfg_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string xlu__cfg_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define xlu__cfg_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes xlu__cfg_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define xlu__cfg_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer xlu__cfg_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define xlu__cfg_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer xlu__cfg_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define xlu__cfg_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state xlu__cfg_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define xlu__cfg_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer xlu__cfg_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define xlu__cfg_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state xlu__cfg_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define xlu__cfg_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state xlu__cfg_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define xlu__cfg_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack xlu__cfg_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define xlu__cfg_yylex_ALREADY_DEFINED
+#else
+#define yylex xlu__cfg_yylex
+#endif
+
+#ifdef yyrestart
+#define xlu__cfg_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart xlu__cfg_yyrestart
+#endif
+
+#ifdef yylex_init
+#define xlu__cfg_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init xlu__cfg_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define xlu__cfg_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra xlu__cfg_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define xlu__cfg_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy xlu__cfg_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define xlu__cfg_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug xlu__cfg_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define xlu__cfg_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug xlu__cfg_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define xlu__cfg_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra xlu__cfg_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define xlu__cfg_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra xlu__cfg_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define xlu__cfg_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in xlu__cfg_yyget_in
+#endif
+
+#ifdef yyset_in
+#define xlu__cfg_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in xlu__cfg_yyset_in
+#endif
+
+#ifdef yyget_out
+#define xlu__cfg_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out xlu__cfg_yyget_out
+#endif
+
+#ifdef yyset_out
+#define xlu__cfg_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out xlu__cfg_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define xlu__cfg_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng xlu__cfg_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define xlu__cfg_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text xlu__cfg_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define xlu__cfg_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno xlu__cfg_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define xlu__cfg_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno xlu__cfg_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define xlu__cfg_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column xlu__cfg_yyget_column
+#endif
+
+#ifdef yyset_column
+#define xlu__cfg_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column xlu__cfg_yyset_column
+#endif
+
+#ifdef yywrap
+#define xlu__cfg_yywrap_ALREADY_DEFINED
+#else
+#define yywrap xlu__cfg_yywrap
+#endif
+
+#ifdef yyget_lval
+#define xlu__cfg_yyget_lval_ALREADY_DEFINED
+#else
+#define yyget_lval xlu__cfg_yyget_lval
+#endif
+
+#ifdef yyset_lval
+#define xlu__cfg_yyset_lval_ALREADY_DEFINED
+#else
+#define yyset_lval xlu__cfg_yyset_lval
+#endif
+
+#ifdef yyget_lloc
+#define xlu__cfg_yyget_lloc_ALREADY_DEFINED
+#else
+#define yyget_lloc xlu__cfg_yyget_lloc
+#endif
+
+#ifdef yyset_lloc
+#define xlu__cfg_yyset_lloc_ALREADY_DEFINED
+#else
+#define yyset_lloc xlu__cfg_yyset_lloc
+#endif
+
+#ifdef yyalloc
+#define xlu__cfg_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc xlu__cfg_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define xlu__cfg_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc xlu__cfg_yyrealloc
+#endif
+
+#ifdef yyfree
+#define xlu__cfg_yyfree_ALREADY_DEFINED
+#else
+#define yyfree xlu__cfg_yyfree
+#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
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#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;
+
+/* 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
+
+#ifndef SIZE_MAX
+#define SIZE_MAX (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ * integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+ are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* 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 yyg->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 ((yyg->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 yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+ /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
+ * access to the local variable yy_act. Since yyless() is a macro, it would break
+ * existing scanners that call yyless() from OUTSIDE yylex.
+ * One obvious solution it to make yy_act a global. I tried that, and saw
+ * a 5% performance hit in a non-yylineno scanner, because yy_act is
+ * normally declared as a register variable-- so it is not worth it.
+ */
+ #define YY_LESS_LINENO(n) \
+ do { \
+ int yyl;\
+ for ( yyl = n; yyl < yyleng; ++yyl )\
+ if ( yytext[yyl] == '\n' )\
+ --yylineno;\
+ }while(0)
+ #define YY_LINENO_REWIND_TO(dst) \
+ do {\
+ const char *p;\
+ for ( p = yy_cp-1; p >= (dst); --p)\
+ if ( *p == '\n' )\
+ --yylineno;\
+ }while(0)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ int yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ *yy_cp = yyg->yy_hold_char; \
+ YY_RESTORE_YY_MORE_OFFSET \
+ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+ } \
+ while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#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.
+ */
+ int 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 yyrestart()), so that the user can continue scanning by
+ * just pointing yyin at a new input file.
+ */
+#define YY_BUFFER_EOF_PENDING 2
+
+ };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* 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 ( yyg->yy_buffer_stack \
+ ? yyg->yy_buffer_stack[yyg->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 yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){ \
+ yyensure_buffer_stack (yyscanner); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+ }
+#define yy_set_bol(at_bol) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){\
+ yyensure_buffer_stack (yyscanner); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+ }
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+#define xlu__cfg_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+ yyg->yytext_ptr = yy_bp; \
+ yyg->yytext_ptr -= yyg->yy_more_len; \
+ yyleng = (int) (yy_cp - yyg->yytext_ptr); \
+ yyg->yy_hold_char = *yy_cp; \
+ *yy_cp = '\0'; \
+ yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 17
+#define YY_END_OF_BUFFER 18
+/* 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 const flex_int16_t yy_accept[37] =
+ { 0,
+ 0, 0, 15, 15, 18, 14, 3, 10, 14, 14,
+ 14, 13, 13, 4, 2, 9, 8, 5, 6, 1,
+ 15, 15, 16, 0, 12, 0, 0, 10, 0, 11,
+ 0, 7, 2, 1, 15, 0
+ } ;
+
+static const YY_CHAR 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, 1, 4, 5, 1, 1, 1, 6, 7,
+ 7, 1, 8, 9, 7, 10, 1, 11, 11, 11,
+ 11, 11, 11, 11, 11, 11, 11, 7, 12, 1,
+ 13, 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,
+ 14, 15, 16, 1, 17, 1, 18, 18, 18, 18,
+
+ 18, 18, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 18,
+ 19, 19, 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, 1, 1
+ } ;
+
+static const YY_CHAR yy_meta[20] =
+ { 0,
+ 1, 2, 3, 1, 1, 1, 1, 1, 1, 4,
+ 4, 1, 1, 1, 1, 1, 4, 4, 4
+ } ;
+
+static const flex_int16_t yy_base[43] =
+ { 0,
+ 0, 0, 18, 20, 53, 59, 59, 59, 20, 42,
+ 19, 59, 19, 59, 15, 59, 59, 59, 59, 0,
+ 0, 59, 59, 23, 59, 0, 28, 59, 22, 59,
+ 0, 59, 18, 0, 0, 59, 38, 42, 46, 50,
+ 26, 54
+ } ;
+
+static const flex_int16_t yy_def[43] =
+ { 0,
+ 36, 1, 37, 37, 36, 36, 36, 36, 38, 39,
+ 40, 36, 36, 36, 36, 36, 36, 36, 36, 41,
+ 42, 36, 36, 38, 36, 38, 39, 36, 40, 36,
+ 40, 36, 36, 41, 42, 0, 36, 36, 36, 36,
+ 36, 36
+ } ;
+
+static const flex_int16_t yy_nxt[79] =
+ { 0,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 12,
+ 15, 16, 17, 18, 6, 19, 6, 20, 20, 22,
+ 23, 22, 23, 25, 30, 33, 25, 30, 33, 34,
+ 28, 32, 33, 31, 26, 33, 31, 26, 21, 21,
+ 21, 21, 24, 24, 28, 24, 27, 27, 27, 27,
+ 29, 29, 36, 29, 35, 36, 36, 35, 5, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36
+ } ;
+
+static const flex_int16_t yy_chk[79] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
+ 3, 4, 4, 9, 11, 15, 24, 29, 33, 41,
+ 27, 13, 15, 11, 9, 33, 29, 24, 37, 37,
+ 37, 37, 38, 38, 10, 38, 39, 39, 39, 39,
+ 40, 40, 5, 40, 42, 0, 0, 42, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36
+ } ;
+
+/* Table of booleans, true if rule could match eol. */
+static const flex_int32_t yy_rule_can_match_eol[18] =
+ { 0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 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() (yyg->yy_more_flag = 1)
+#define YY_MORE_ADJ yyg->yy_more_len
+#define YY_RESTORE_YY_MORE_OFFSET
+#line 1 "libxlu_cfg_l.l"
+/* -*- fundamental -*- */
+/*
+ * libxlu_cfg_l.l - xl configuration file parsing: lexer
+ *
+ * Copyright (C) 2010 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+#line 20 "libxlu_cfg_l.l"
+#include "libxlu_cfg_i.h"
+
+#define ctx ((CfgParseContext*)yyextra)
+#define YY_NO_INPUT
+
+#define GOT(x) do{ \
+ yylloc->first_line= yylineno; \
+ return (x); \
+ }while(0)
+
+/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
+ * it to fail to declare these functions, which it defines. So declare
+ * them ourselves. Hopefully we won't have to simultaneously support
+ * a flex version which declares these differently somehow. */
+int xlu__cfg_yyget_column(yyscan_t yyscanner);
+void xlu__cfg_yyset_column(int column_no, yyscan_t yyscanner);
+
+#line 740 "libxlu_cfg_l.c"
+
+#line 742 "libxlu_cfg_l.c"
+
+#define INITIAL 0
+#define lexerr 1
+
+#ifndef YY_NO_UNISTD_H
+/* 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>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+ {
+
+ /* User-defined. Not touched by flex. */
+ YY_EXTRA_TYPE yyextra_r;
+
+ /* The rest are the same as the globals declared in the non-reentrant scanner. */
+ FILE *yyin_r, *yyout_r;
+ size_t yy_buffer_stack_top; /**< index of top of stack. */
+ size_t yy_buffer_stack_max; /**< capacity of stack. */
+ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+ char yy_hold_char;
+ int yy_n_chars;
+ int yyleng_r;
+ char *yy_c_buf_p;
+ int yy_init;
+ int yy_start;
+ int yy_did_buffer_switch_on_eof;
+ int yy_start_stack_ptr;
+ int yy_start_stack_depth;
+ int *yy_start_stack;
+ yy_state_type yy_last_accepting_state;
+ char* yy_last_accepting_cpos;
+
+ int yylineno_r;
+ int yy_flex_debug_r;
+
+ char *yytext_r;
+ int yy_more_flag;
+ int yy_more_len;
+
+ YYSTYPE * yylval_r;
+
+ YYLTYPE * yylloc_r;
+
+ }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+ /* This must go here because YYSTYPE and YYLTYPE are included
+ * from bison output in section 1.*/
+ # define yylval yyg->yylval_r
+
+ # define yylloc yyg->yylloc_r
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+ These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
+
+ int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+YYSTYPE * yyget_lval ( yyscan_t yyscanner );
+
+void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
+
+ YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
+
+ void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#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 do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#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) \
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+ { \
+ int c = '*'; \
+ int n; \
+ for ( n = 0; n < max_size && \
+ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+ buf[n] = (char) c; \
+ if ( c == '\n' ) \
+ buf[n++] = (char) c; \
+ if ( c == EOF && ferror( yyin ) ) \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ result = n; \
+ } \
+ else \
+ { \
+ errno=0; \
+ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+ { \
+ if( errno != EINTR) \
+ { \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ break; \
+ } \
+ errno=0; \
+ clearerr(yyin); \
+ } \
+ }\
+\
+
+#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 , yyscanner)
+#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 yylex \
+ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
+
+#define YY_DECL int yylex \
+ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * 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 /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+ YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+ yy_state_type yy_current_state;
+ char *yy_cp, *yy_bp;
+ int yy_act;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ yylval = yylval_param;
+
+ yylloc = yylloc_param;
+
+ if ( !yyg->yy_init )
+ {
+ yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+ YY_USER_INIT;
+#endif
+
+ if ( ! yyg->yy_start )
+ yyg->yy_start = 1; /* first start state */
+
+ if ( ! yyin )
+ yyin = stdin;
+
+ if ( ! yyout )
+ yyout = stdout;
+
+ if ( ! YY_CURRENT_BUFFER ) {
+ yyensure_buffer_stack (yyscanner);
+ YY_CURRENT_BUFFER_LVALUE =
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+ }
+
+ yy_load_buffer_state( yyscanner );
+ }
+
+ {
+#line 53 "libxlu_cfg_l.l"
+
+
+#line 1028 "libxlu_cfg_l.c"
+
+ while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
+ {
+ yyg->yy_more_len = 0;
+ if ( yyg->yy_more_flag )
+ {
+ yyg->yy_more_len = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+ yyg->yy_more_flag = 0;
+ }
+ yy_cp = yyg->yy_c_buf_p;
+
+ /* Support of yytext. */
+ *yy_cp = yyg->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 = yyg->yy_start;
+yy_match:
+ do
+ {
+ YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+ if ( yy_accept[yy_current_state] )
+ {
+ yyg->yy_last_accepting_state = yy_current_state;
+ yyg->yy_last_accepting_cpos = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 37 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ ++yy_cp;
+ }
+ while ( yy_current_state != 36 );
+ yy_cp = yyg->yy_last_accepting_cpos;
+ yy_current_state = yyg->yy_last_accepting_state;
+
+yy_find_action:
+ yy_act = yy_accept[yy_current_state];
+
+ YY_DO_BEFORE_ACTION;
+
+ if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
+ {
+ int yyl;
+ for ( yyl = yyg->yy_more_len; yyl < yyleng; ++yyl )
+ if ( yytext[yyl] == '\n' )
+
+ do{ yylineno++;
+ yycolumn=0;
+ }while(0)
+;
+ }
+
+do_action: /* This label is used only to access EOF actions. */
+
+ switch ( yy_act )
+ { /* beginning of action switch */
+ case 0: /* must back up */
+ /* undo the effects of YY_DO_BEFORE_ACTION */
+ *yy_cp = yyg->yy_hold_char;
+ yy_cp = yyg->yy_last_accepting_cpos;
+ yy_current_state = yyg->yy_last_accepting_state;
+ goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 55 "libxlu_cfg_l.l"
+{
+ yylval->string= xlu__cfgl_strdup(ctx,yytext);
+ GOT(IDENT);
+ }
+ YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 59 "libxlu_cfg_l.l"
+{
+ yylval->string= xlu__cfgl_strdup(ctx,yytext);
+ GOT(NUMBER);
+ }
+ YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 64 "libxlu_cfg_l.l"
+
+ YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 66 "libxlu_cfg_l.l"
+{ GOT(','); }
+ YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 67 "libxlu_cfg_l.l"
+{ GOT('['); }
+ YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 68 "libxlu_cfg_l.l"
+{ GOT(']'); }
+ YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 69 "libxlu_cfg_l.l"
+{ GOT(OP_ADD); }
+ YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 70 "libxlu_cfg_l.l"
+{ GOT('='); }
+ YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 71 "libxlu_cfg_l.l"
+{ GOT(';'); }
+ YY_BREAK
+case 10:
+/* rule 10 can match eol */
+YY_RULE_SETUP
+#line 73 "libxlu_cfg_l.l"
+{ yylloc->first_line= yylineno-1; return NEWLINE; }
+ YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 75 "libxlu_cfg_l.l"
+{
+ yylval->string= xlu__cfgl_dequote(ctx,yytext);
+ GOT(STRING);
+ }
+ YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 79 "libxlu_cfg_l.l"
+{
+ yylval->string= xlu__cfgl_dequote(ctx,yytext);
+ GOT(STRING);
+ }
+ YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 84 "libxlu_cfg_l.l"
+{
+ ctx->likely_python= 1;
+ BEGIN(lexerr);
+ yymore();
+ }
+ YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 90 "libxlu_cfg_l.l"
+{
+ BEGIN(lexerr);
+ yymore();
+ }
+ YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 95 "libxlu_cfg_l.l"
+{
+ xlu__cfgl_lexicalerror(ctx,"lexical error");
+ BEGIN(0);
+ }
+ YY_BREAK
+case 16:
+/* rule 16 can match eol */
+YY_RULE_SETUP
+#line 100 "libxlu_cfg_l.l"
+{
+ xlu__cfgl_lexicalerror(ctx,"lexical error");
+ BEGIN(0);
+ GOT(NEWLINE);
+ }
+ YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 105 "libxlu_cfg_l.l"
+YY_FATAL_ERROR( "flex scanner jammed" );
+ YY_BREAK
+#line 1212 "libxlu_cfg_l.c"
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(lexerr):
+ yyterminate();
+
+ case YY_END_OF_BUFFER:
+ {
+ /* Amount of text matched not including the EOB char. */
+ int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+ /* Undo the effects of YY_DO_BEFORE_ACTION. */
+ *yy_cp = yyg->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 yyin at a new source and called
+ * yylex(). 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.
+ */
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+ 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 ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+ { /* This was really a NUL. */
+ yy_state_type yy_next_state;
+
+ yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ /* 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 , yyscanner);
+
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+ if ( yy_next_state )
+ {
+ /* Consume the NUL. */
+ yy_cp = ++yyg->yy_c_buf_p;
+ yy_current_state = yy_next_state;
+ goto yy_match;
+ }
+
+ else
+ {
+ yy_cp = yyg->yy_last_accepting_cpos;
+ yy_current_state = yyg->yy_last_accepting_state;
+ goto yy_find_action;
+ }
+ }
+
+ else switch ( yy_get_next_buffer( yyscanner ) )
+ {
+ case EOB_ACT_END_OF_FILE:
+ {
+ yyg->yy_did_buffer_switch_on_eof = 0;
+
+ if ( yywrap( yyscanner ) )
+ {
+ /* Note: because we've taken care in
+ * yy_get_next_buffer() to have set up
+ * yytext, 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.
+ */
+ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+ yy_act = YY_STATE_EOF(YY_START);
+ goto do_action;
+ }
+
+ else
+ {
+ if ( ! yyg->yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+ }
+ break;
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yyg->yy_c_buf_p =
+ yyg->yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ yy_cp = yyg->yy_c_buf_p;
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+ goto yy_match;
+
+ case EOB_ACT_LAST_MATCH:
+ yyg->yy_c_buf_p =
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ yy_cp = yyg->yy_c_buf_p;
+ yy_bp = yyg->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 user's declarations */
+} /* end of yylex */
+
+/* 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 (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+ char *source = yyg->yytext_ptr;
+ int number_to_move, i;
+ int ret_val;
+
+ if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->yy_n_chars = 0;
+
+ else
+ {
+ int 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_LVALUE;
+
+ int yy_c_buf_p_offset =
+ (int) (yyg->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. */
+ yyrealloc( (void *) b->yy_ch_buf,
+ (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+ }
+ else
+ /* Can't grow it, we don't own it. */
+ b->yy_ch_buf = NULL;
+
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR(
+ "fatal error - scanner input buffer overflow" );
+
+ yyg->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]),
+ yyg->yy_n_chars, num_to_read );
+
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ if ( yyg->yy_n_chars == 0 )
+ {
+ if ( number_to_move == YY_MORE_ADJ )
+ {
+ ret_val = EOB_ACT_END_OF_FILE;
+ yyrestart( yyin , yyscanner);
+ }
+
+ 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;
+
+ if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+ /* Extend the array by 50%, plus the number we really need. */
+ int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+ (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+ /* "- 2" to take care of EOB's */
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+ }
+
+ yyg->yy_n_chars += number_to_move;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+ yyg->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 (yyscan_t yyscanner)
+{
+ yy_state_type yy_current_state;
+ char *yy_cp;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ yy_current_state = yyg->yy_start;
+
+ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+ {
+ YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+ if ( yy_accept[yy_current_state] )
+ {
+ yyg->yy_last_accepting_state = yy_current_state;
+ yyg->yy_last_accepting_cpos = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 37 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ }
+
+ 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 , yyscan_t yyscanner)
+{
+ int yy_is_jam;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+ char *yy_cp = yyg->yy_c_buf_p;
+
+ YY_CHAR yy_c = 1;
+ if ( yy_accept[yy_current_state] )
+ {
+ yyg->yy_last_accepting_state = yy_current_state;
+ yyg->yy_last_accepting_cpos = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 37 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ yy_is_jam = (yy_current_state == 36);
+
+ (void)yyg;
+ return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+ static int yyinput (yyscan_t yyscanner)
+#else
+ static int input (yyscan_t yyscanner)
+#endif
+
+{
+ int c;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+ if ( *yyg->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 ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+ /* This was really a NUL. */
+ *yyg->yy_c_buf_p = '\0';
+
+ else
+ { /* need more input */
+ int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+ ++yyg->yy_c_buf_p;
+
+ switch ( yy_get_next_buffer( yyscanner ) )
+ {
+ 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. */
+ yyrestart( yyin , yyscanner);
+
+ /*FALLTHROUGH*/
+
+ case EOB_ACT_END_OF_FILE:
+ {
+ if ( yywrap( yyscanner ) )
+ return 0;
+
+ if ( ! yyg->yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+#ifdef __cplusplus
+ return yyinput(yyscanner);
+#else
+ return input(yyscanner);
+#endif
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+ break;
+ }
+ }
+ }
+
+ c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
+ *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
+ yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+ if ( c == '\n' )
+
+ do{ yylineno++;
+ yycolumn=0;
+ }while(0)
+;
+
+ return c;
+}
+#endif /* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+ void yyrestart (FILE * input_file , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if ( ! YY_CURRENT_BUFFER ){
+ yyensure_buffer_stack (yyscanner);
+ YY_CURRENT_BUFFER_LVALUE =
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+ }
+
+ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+ yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* TODO. We should be able to replace this entire function body
+ * with
+ * yypop_buffer_state();
+ * yypush_buffer_state(new_buffer);
+ */
+ yyensure_buffer_stack (yyscanner);
+ if ( YY_CURRENT_BUFFER == new_buffer )
+ return;
+
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+ yy_load_buffer_state( yyscanner );
+
+ /* We don't actually know whether we did this switch during
+ * EOF (yywrap()) processing, but the only time this flag
+ * is looked at is after yywrap() is called, so it's safe
+ * to go ahead and always set it.
+ */
+ yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+ yyg->yy_hold_char = *yyg->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.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
+{
+ YY_BUFFER_STATE b;
+
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_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 *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+ b->yy_is_our_buffer = 1;
+
+ yy_init_buffer( b, file , yyscanner);
+
+ return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+ void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ 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 )
+ yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+ yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
+
+{
+ int oerrno = errno;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ yy_flush_buffer( b , yyscanner);
+
+ b->yy_input_file = file;
+ b->yy_fill_buffer = 1;
+
+ /* If b is the current buffer, then yy_init_buffer was _probably_
+ * called from yyrestart() 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 = file ? (isatty( fileno(file) ) > 0) : 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.
+ * @param yyscanner The scanner object.
+ */
+ void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ 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 )
+ yy_load_buffer_state( yyscanner );
+}
+
+/** 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.
+ * @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ if (new_buffer == NULL)
+ return;
+
+ yyensure_buffer_stack(yyscanner);
+
+ /* This block is copied from yy_switch_to_buffer. */
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ /* Only push if top exists. Otherwise, replace top. */
+ if (YY_CURRENT_BUFFER)
+ yyg->yy_buffer_stack_top++;
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+ /* copied from yy_switch_to_buffer. */
+ yy_load_buffer_state( yyscanner );
+ yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ * The next element becomes the new top.
+ * @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ if (!YY_CURRENT_BUFFER)
+ return;
+
+ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ if (yyg->yy_buffer_stack_top > 0)
+ --yyg->yy_buffer_stack_top;
+
+ if (YY_CURRENT_BUFFER) {
+ yy_load_buffer_state( yyscanner );
+ yyg->yy_did_buffer_switch_on_eof = 1;
+ }
+}
+
+/* Allocates the stack if it does not exist.
+ * Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+ yy_size_t num_to_alloc;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (!yyg->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; /* After all that talk, this was set to 1 anyways... */
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+ (num_to_alloc * sizeof(struct yy_buffer_state*)
+ , yyscanner);
+ if ( ! yyg->yy_buffer_stack )
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+ memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+ yyg->yy_buffer_stack_max = num_to_alloc;
+ yyg->yy_buffer_stack_top = 0;
+ return;
+ }
+
+ if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+ /* Increase the buffer to prepare for a possible push. */
+ yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+ num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+ (yyg->yy_buffer_stack,
+ num_to_alloc * sizeof(struct yy_buffer_state*)
+ , yyscanner);
+ if ( ! yyg->yy_buffer_stack )
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+ /* zero only the new slots.*/
+ memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+ yyg->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
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
+{
+ 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 NULL;
+
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+ b->yy_buf_size = (int) (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 = NULL;
+ 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;
+
+ yy_switch_to_buffer( b , yyscanner );
+
+ return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ * yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+
+ return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
+{
+ YY_BUFFER_STATE b;
+ char *buf;
+ yy_size_t n;
+ int i;
+
+ /* Get memory for full buffer, including space for trailing EOB's. */
+ n = (yy_size_t) (_yybytes_len + 2);
+ buf = (char *) yyalloc( n , yyscanner );
+ if ( ! buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+ for ( i = 0; i < _yybytes_len; ++i )
+ buf[i] = yybytes[i];
+
+ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+ b = yy_scan_buffer( buf, n , yyscanner);
+ if ( ! b )
+ YY_FATAL_ERROR( "bad buffer in yy_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 yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ 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 yytext. */ \
+ int yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ yytext[yyleng] = yyg->yy_hold_char; \
+ yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+ yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+ *yyg->yy_c_buf_p = '\0'; \
+ yyleng = yyless_macro_arg; \
+ } \
+ while ( 0 )
+
+/* Accessor methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (! YY_CURRENT_BUFFER)
+ return 0;
+
+ return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (! YY_CURRENT_BUFFER)
+ return 0;
+
+ return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int _line_number , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* lineno is only valid if an input buffer exists. */
+ if (! YY_CURRENT_BUFFER )
+ YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+
+ yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int _column_no , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* column is only valid if an input buffer exists. */
+ if (! YY_CURRENT_BUFFER )
+ YY_FATAL_ERROR( "yyset_column called with no buffer" );
+
+ yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE * _in_str , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyin = _in_str ;
+}
+
+void yyset_out (FILE * _out_str , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyout = _out_str ;
+}
+
+int yyget_debug (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yy_flex_debug;
+}
+
+void yyset_debug (int _bdebug , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+YYSTYPE * yyget_lval (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yylval;
+}
+
+void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yylval = yylval_param;
+}
+
+YYLTYPE *yyget_lloc (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yylloc;
+}
+
+void yyset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yylloc = yylloc_param;
+}
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+ if (ptr_yy_globals == NULL){
+ errno = EINVAL;
+ return 1;
+ }
+
+ *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+ if (*ptr_yy_globals == NULL){
+ errno = ENOMEM;
+ return 1;
+ }
+
+ /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+ return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+ struct yyguts_t dummy_yyguts;
+
+ yyset_extra (yy_user_defined, &dummy_yyguts);
+
+ if (ptr_yy_globals == NULL){
+ errno = EINVAL;
+ return 1;
+ }
+
+ *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+ if (*ptr_yy_globals == NULL){
+ errno = ENOMEM;
+ return 1;
+ }
+
+ /* By setting to 0xAA, we expose bugs in
+ yy_init_globals. Leave at 0x00 for releases. */
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+ yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+ return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ /* Initialization is the same as for the non-reentrant scanner.
+ * This function is called from yylex_destroy(), so don't allocate here.
+ */
+
+ yyg->yy_buffer_stack = NULL;
+ yyg->yy_buffer_stack_top = 0;
+ yyg->yy_buffer_stack_max = 0;
+ yyg->yy_c_buf_p = NULL;
+ yyg->yy_init = 0;
+ yyg->yy_start = 0;
+
+ yyg->yy_start_stack_ptr = 0;
+ yyg->yy_start_stack_depth = 0;
+ yyg->yy_start_stack = NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+ yyin = stdin;
+ yyout = stdout;
+#else
+ yyin = NULL;
+ yyout = NULL;
+#endif
+
+ /* For future reference: Set errno on error, since we are called by
+ * yylex_init()
+ */
+ return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* Pop the buffer stack, destroying each element. */
+ while(YY_CURRENT_BUFFER){
+ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ yypop_buffer_state(yyscanner);
+ }
+
+ /* Destroy the stack itself. */
+ yyfree(yyg->yy_buffer_stack , yyscanner);
+ yyg->yy_buffer_stack = NULL;
+
+ /* Destroy the start condition stack. */
+ yyfree( yyg->yy_start_stack , yyscanner );
+ yyg->yy_start_stack = NULL;
+
+ /* Reset the globals. This is important in a non-reentrant scanner so the next time
+ * yylex() is called, initialization will occur. */
+ yy_init_globals( yyscanner);
+
+ /* Destroy the main struct (reentrant only). */
+ yyfree ( yyscanner , yyscanner );
+ yyscanner = NULL;
+ return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+
+ int i;
+ for ( i = 0; i < n; ++i )
+ s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+ int n;
+ for ( n = 0; s[n]; ++n )
+ ;
+
+ return n;
+}
+#endif
+
+void *yyalloc (yy_size_t size , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ return malloc(size);
+}
+
+void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+
+ /* 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 realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 105 "libxlu_cfg_l.l"
--- /dev/null
+#ifndef xlu__cfg_yyHEADER_H
+#define xlu__cfg_yyHEADER_H 1
+#define xlu__cfg_yyIN_HEADER 1
+
+#line 6 "libxlu_cfg_l.h"
+
+#line 8 "libxlu_cfg_l.h"
+
+#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 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define xlu__cfg_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer xlu__cfg_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define xlu__cfg_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer xlu__cfg_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define xlu__cfg_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer xlu__cfg_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define xlu__cfg_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string xlu__cfg_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define xlu__cfg_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes xlu__cfg_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define xlu__cfg_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer xlu__cfg_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define xlu__cfg_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer xlu__cfg_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define xlu__cfg_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state xlu__cfg_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define xlu__cfg_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer xlu__cfg_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define xlu__cfg_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state xlu__cfg_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define xlu__cfg_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state xlu__cfg_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define xlu__cfg_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack xlu__cfg_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define xlu__cfg_yylex_ALREADY_DEFINED
+#else
+#define yylex xlu__cfg_yylex
+#endif
+
+#ifdef yyrestart
+#define xlu__cfg_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart xlu__cfg_yyrestart
+#endif
+
+#ifdef yylex_init
+#define xlu__cfg_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init xlu__cfg_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define xlu__cfg_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra xlu__cfg_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define xlu__cfg_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy xlu__cfg_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define xlu__cfg_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug xlu__cfg_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define xlu__cfg_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug xlu__cfg_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define xlu__cfg_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra xlu__cfg_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define xlu__cfg_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra xlu__cfg_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define xlu__cfg_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in xlu__cfg_yyget_in
+#endif
+
+#ifdef yyset_in
+#define xlu__cfg_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in xlu__cfg_yyset_in
+#endif
+
+#ifdef yyget_out
+#define xlu__cfg_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out xlu__cfg_yyget_out
+#endif
+
+#ifdef yyset_out
+#define xlu__cfg_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out xlu__cfg_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define xlu__cfg_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng xlu__cfg_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define xlu__cfg_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text xlu__cfg_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define xlu__cfg_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno xlu__cfg_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define xlu__cfg_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno xlu__cfg_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define xlu__cfg_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column xlu__cfg_yyget_column
+#endif
+
+#ifdef yyset_column
+#define xlu__cfg_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column xlu__cfg_yyset_column
+#endif
+
+#ifdef yywrap
+#define xlu__cfg_yywrap_ALREADY_DEFINED
+#else
+#define yywrap xlu__cfg_yywrap
+#endif
+
+#ifdef yyget_lval
+#define xlu__cfg_yyget_lval_ALREADY_DEFINED
+#else
+#define yyget_lval xlu__cfg_yyget_lval
+#endif
+
+#ifdef yyset_lval
+#define xlu__cfg_yyset_lval_ALREADY_DEFINED
+#else
+#define yyset_lval xlu__cfg_yyset_lval
+#endif
+
+#ifdef yyget_lloc
+#define xlu__cfg_yyget_lloc_ALREADY_DEFINED
+#else
+#define yyget_lloc xlu__cfg_yyget_lloc
+#endif
+
+#ifdef yyset_lloc
+#define xlu__cfg_yyset_lloc_ALREADY_DEFINED
+#else
+#define yyset_lloc xlu__cfg_yyset_lloc
+#endif
+
+#ifdef yyalloc
+#define xlu__cfg_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc xlu__cfg_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define xlu__cfg_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc xlu__cfg_yyrealloc
+#endif
+
+#ifdef yyfree
+#define xlu__cfg_yyfree_ALREADY_DEFINED
+#else
+#define yyfree xlu__cfg_yyfree
+#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
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#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;
+
+/* 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
+
+#ifndef SIZE_MAX
+#define SIZE_MAX (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+ are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t 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.
+ */
+ int 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;
+
+ };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define xlu__cfg_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define lexerr 1
+
+#endif
+
+#ifndef YY_NO_UNISTD_H
+/* 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>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+ These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
+
+ int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+YYSTYPE * yyget_lval ( yyscan_t yyscanner );
+
+void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
+
+ YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
+
+ void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* 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 yylex \
+ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
+
+#define YY_DECL int yylex \
+ (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#ifndef xlu__cfg_yy_create_buffer_ALREADY_DEFINED
+#undef yy_create_buffer
+#endif
+#ifndef xlu__cfg_yy_delete_buffer_ALREADY_DEFINED
+#undef yy_delete_buffer
+#endif
+#ifndef xlu__cfg_yy_scan_buffer_ALREADY_DEFINED
+#undef yy_scan_buffer
+#endif
+#ifndef xlu__cfg_yy_scan_string_ALREADY_DEFINED
+#undef yy_scan_string
+#endif
+#ifndef xlu__cfg_yy_scan_bytes_ALREADY_DEFINED
+#undef yy_scan_bytes
+#endif
+#ifndef xlu__cfg_yy_init_buffer_ALREADY_DEFINED
+#undef yy_init_buffer
+#endif
+#ifndef xlu__cfg_yy_flush_buffer_ALREADY_DEFINED
+#undef yy_flush_buffer
+#endif
+#ifndef xlu__cfg_yy_load_buffer_state_ALREADY_DEFINED
+#undef yy_load_buffer_state
+#endif
+#ifndef xlu__cfg_yy_switch_to_buffer_ALREADY_DEFINED
+#undef yy_switch_to_buffer
+#endif
+#ifndef xlu__cfg_yypush_buffer_state_ALREADY_DEFINED
+#undef yypush_buffer_state
+#endif
+#ifndef xlu__cfg_yypop_buffer_state_ALREADY_DEFINED
+#undef yypop_buffer_state
+#endif
+#ifndef xlu__cfg_yyensure_buffer_stack_ALREADY_DEFINED
+#undef yyensure_buffer_stack
+#endif
+#ifndef xlu__cfg_yylex_ALREADY_DEFINED
+#undef yylex
+#endif
+#ifndef xlu__cfg_yyrestart_ALREADY_DEFINED
+#undef yyrestart
+#endif
+#ifndef xlu__cfg_yylex_init_ALREADY_DEFINED
+#undef yylex_init
+#endif
+#ifndef xlu__cfg_yylex_init_extra_ALREADY_DEFINED
+#undef yylex_init_extra
+#endif
+#ifndef xlu__cfg_yylex_destroy_ALREADY_DEFINED
+#undef yylex_destroy
+#endif
+#ifndef xlu__cfg_yyget_debug_ALREADY_DEFINED
+#undef yyget_debug
+#endif
+#ifndef xlu__cfg_yyset_debug_ALREADY_DEFINED
+#undef yyset_debug
+#endif
+#ifndef xlu__cfg_yyget_extra_ALREADY_DEFINED
+#undef yyget_extra
+#endif
+#ifndef xlu__cfg_yyset_extra_ALREADY_DEFINED
+#undef yyset_extra
+#endif
+#ifndef xlu__cfg_yyget_in_ALREADY_DEFINED
+#undef yyget_in
+#endif
+#ifndef xlu__cfg_yyset_in_ALREADY_DEFINED
+#undef yyset_in
+#endif
+#ifndef xlu__cfg_yyget_out_ALREADY_DEFINED
+#undef yyget_out
+#endif
+#ifndef xlu__cfg_yyset_out_ALREADY_DEFINED
+#undef yyset_out
+#endif
+#ifndef xlu__cfg_yyget_leng_ALREADY_DEFINED
+#undef yyget_leng
+#endif
+#ifndef xlu__cfg_yyget_text_ALREADY_DEFINED
+#undef yyget_text
+#endif
+#ifndef xlu__cfg_yyget_lineno_ALREADY_DEFINED
+#undef yyget_lineno
+#endif
+#ifndef xlu__cfg_yyset_lineno_ALREADY_DEFINED
+#undef yyset_lineno
+#endif
+#ifndef xlu__cfg_yyget_column_ALREADY_DEFINED
+#undef yyget_column
+#endif
+#ifndef xlu__cfg_yyset_column_ALREADY_DEFINED
+#undef yyset_column
+#endif
+#ifndef xlu__cfg_yywrap_ALREADY_DEFINED
+#undef yywrap
+#endif
+#ifndef xlu__cfg_yyget_lval_ALREADY_DEFINED
+#undef yyget_lval
+#endif
+#ifndef xlu__cfg_yyset_lval_ALREADY_DEFINED
+#undef yyset_lval
+#endif
+#ifndef xlu__cfg_yyget_lloc_ALREADY_DEFINED
+#undef yyget_lloc
+#endif
+#ifndef xlu__cfg_yyset_lloc_ALREADY_DEFINED
+#undef yyset_lloc
+#endif
+#ifndef xlu__cfg_yyalloc_ALREADY_DEFINED
+#undef yyalloc
+#endif
+#ifndef xlu__cfg_yyrealloc_ALREADY_DEFINED
+#undef yyrealloc
+#endif
+#ifndef xlu__cfg_yyfree_ALREADY_DEFINED
+#undef yyfree
+#endif
+#ifndef xlu__cfg_yytext_ALREADY_DEFINED
+#undef yytext
+#endif
+#ifndef xlu__cfg_yyleng_ALREADY_DEFINED
+#undef yyleng
+#endif
+#ifndef xlu__cfg_yyin_ALREADY_DEFINED
+#undef yyin
+#endif
+#ifndef xlu__cfg_yyout_ALREADY_DEFINED
+#undef yyout
+#endif
+#ifndef xlu__cfg_yy_flex_debug_ALREADY_DEFINED
+#undef yy_flex_debug
+#endif
+#ifndef xlu__cfg_yylineno_ALREADY_DEFINED
+#undef yylineno
+#endif
+#ifndef xlu__cfg_yytables_fload_ALREADY_DEFINED
+#undef yytables_fload
+#endif
+#ifndef xlu__cfg_yytables_destroy_ALREADY_DEFINED
+#undef yytables_destroy
+#endif
+#ifndef xlu__cfg_yyTABLES_NAME_ALREADY_DEFINED
+#undef yyTABLES_NAME
+#endif
+
+#line 105 "libxlu_cfg_l.l"
+
+#line 733 "libxlu_cfg_l.h"
+#undef xlu__cfg_yyIN_HEADER
+#endif /* xlu__cfg_yyHEADER_H */
--- /dev/null
+/* -*- fundamental -*- */
+/*
+ * libxlu_cfg_l.l - xl configuration file parsing: lexer
+ *
+ * Copyright (C) 2010 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+%{
+#include "libxlu_cfg_i.h"
+
+#define ctx ((CfgParseContext*)yyextra)
+#define YY_NO_INPUT
+
+#define GOT(x) do{ \
+ yylloc->first_line= yylineno; \
+ return (x); \
+ }while(0)
+
+/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
+ * it to fail to declare these functions, which it defines. So declare
+ * them ourselves. Hopefully we won't have to simultaneously support
+ * a flex version which declares these differently somehow. */
+int xlu__cfg_yyget_column(yyscan_t yyscanner);
+void xlu__cfg_yyset_column(int column_no, yyscan_t yyscanner);
+
+%}
+
+%option warn
+%option nodefault
+%option batch
+%option 8bit
+%option yylineno
+%option noyywrap
+%option bison-bridge
+%option bison-locations
+%option reentrant
+%option prefix="xlu__cfg_yy"
+%option nounput
+
+%x lexerr
+
+%%
+
+[a-z][._0-9a-z]* {
+ yylval->string= xlu__cfgl_strdup(ctx,yytext);
+ GOT(IDENT);
+ }
+[0-9][0-9a-fx]* {
+ yylval->string= xlu__cfgl_strdup(ctx,yytext);
+ GOT(NUMBER);
+ }
+
+[ \t]
+
+, { GOT(','); }
+\[ { GOT('['); }
+\] { GOT(']'); }
+\+\= { GOT(OP_ADD); }
+\= { GOT('='); }
+\; { GOT(';'); }
+
+\n|\#.*\n { yylloc->first_line= yylineno-1; return NEWLINE; }
+
+\'([^\'\\\n]|\\.)*\' {
+ yylval->string= xlu__cfgl_dequote(ctx,yytext);
+ GOT(STRING);
+ }
+\"([^\"\\\n]|\\.)*\" {
+ yylval->string= xlu__cfgl_dequote(ctx,yytext);
+ GOT(STRING);
+ }
+
+[+-.():] {
+ ctx->likely_python= 1;
+ BEGIN(lexerr);
+ yymore();
+ }
+
+. {
+ BEGIN(lexerr);
+ yymore();
+ }
+
+<lexerr>[^ \t\n]*|[ \t] {
+ xlu__cfgl_lexicalerror(ctx,"lexical error");
+ BEGIN(0);
+ }
+
+<lexerr>\n {
+ xlu__cfgl_lexicalerror(ctx,"lexical error");
+ BEGIN(0);
+ GOT(NEWLINE);
+ }
--- /dev/null
+/* A Bison parser, made by GNU Bison 3.3.2. */
+
+/* Bison implementation for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* C LALR(1) parser skeleton 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. */
+
+/* Undocumented macros, especially those whose name start with YY_,
+ are private implementation details. Do not rely on them. */
+
+/* Identify Bison output. */
+#define YYBISON 1
+
+/* Bison version. */
+#define YYBISON_VERSION "3.3.2"
+
+/* Skeleton name. */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers. */
+#define YYPURE 1
+
+/* Push parsers. */
+#define YYPUSH 0
+
+/* Pull parsers. */
+#define YYPULL 1
+
+
+/* Substitute the variable and function names. */
+#define yyparse xlu__cfg_yyparse
+#define yylex xlu__cfg_yylex
+#define yyerror xlu__cfg_yyerror
+#define yydebug xlu__cfg_yydebug
+#define yynerrs xlu__cfg_yynerrs
+
+
+/* First part of user prologue. */
+#line 19 "libxlu_cfg_y.y" /* yacc.c:337 */
+
+#define ctx_scanner ctx->scanner
+#include "libxlu_cfg_i.h"
+#include "libxlu_cfg_l.h"
+
+#line 82 "libxlu_cfg_y.c" /* yacc.c:337 */
+# ifndef YY_NULLPTR
+# if defined __cplusplus
+# if 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
+# else
+# define YY_NULLPTR ((void*)0)
+# endif
+# endif
+
+/* Enabling verbose error messages. */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 1
+#endif
+
+/* In a future release of Bison, this section will be replaced
+ by #include "libxlu_cfg_y.h". */
+#ifndef YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
+# define YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int xlu__cfg_yydebug;
+#endif
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ IDENT = 258,
+ STRING = 259,
+ NUMBER = 260,
+ NEWLINE = 261,
+ OP_ADD = 262
+ };
+#endif
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 25 "libxlu_cfg_y.y" /* yacc.c:352 */
+
+ char *string;
+ XLU_ConfigValue *value;
+
+#line 138 "libxlu_cfg_y.c" /* yacc.c:352 */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+/* Location type. */
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE YYLTYPE;
+struct YYLTYPE
+{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+};
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+int xlu__cfg_yyparse (CfgParseContext *ctx);
+
+#endif /* !YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED */
+
+
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+# if ENABLE_NLS
+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+# endif
+# endif
+# ifndef YY_
+# define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__ \
+ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
+ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+# define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+ _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# ifdef YYSTACK_USE_ALLOCA
+# if YYSTACK_USE_ALLOCA
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# elif defined __BUILTIN_VA_ARG_INCR
+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+# elif defined _AIX
+# define YYSTACK_ALLOC __alloca
+# elif defined _MSC_VER
+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+# define alloca _alloca
+# else
+# define YYSTACK_ALLOC alloca
+# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's 'empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# ifndef YYSTACK_ALLOC_MAXIMUM
+ /* The OS might guarantee only one guard page at the bottom of the stack,
+ and a page size can be as small as 4096 bytes. So we cannot safely
+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
+ to allow for a few compiler-allocated temporary stack slots. */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+# endif
+# else
+# define YYSTACK_ALLOC YYMALLOC
+# define YYSTACK_FREE YYFREE
+# ifndef YYSTACK_ALLOC_MAXIMUM
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+# endif
+# if (defined __cplusplus && ! defined EXIT_SUCCESS \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+ && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ yytype_int16 yyss_alloc;
+ YYSTYPE yyvs_alloc;
+ YYLTYPE yyls_alloc;
+};
+
+/* 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 (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ + 2 * YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* 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_alloc, Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if defined __GNUC__ && 1 < __GNUC__
+# define YYCOPY(Dst, Src, Count) \
+ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+# else
+# define YYCOPY(Dst, Src, Count) \
+ do \
+ { \
+ YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (Dst)[yyi] = (Src)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 3
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 27
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 13
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 11
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 23
+/* YYNSTATES -- Number of states. */
+#define YYNSTATES 32
+
+#define YYUNDEFTOK 2
+#define YYMAXUTOK 262
+
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, with out-of-bounds checking. */
+#define YYTRANSLATE(YYX) \
+ ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex. */
+static const yytype_uint8 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, 12, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 9,
+ 2, 8, 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, 10, 2, 11, 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
+};
+
+#if YYDEBUG
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
+static const yytype_uint8 yyrline[] =
+{
+ 0, 48, 48, 49, 51, 52, 54, 55, 56, 58,
+ 59, 61, 62, 64, 65, 67, 68, 70, 71, 72,
+ 74, 75, 77, 79
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 1
+/* YYTNAME[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", "IDENT", "STRING", "NUMBER", "NEWLINE",
+ "\"+=\"", "'='", "';'", "'['", "']'", "','", "$accept", "file", "stmts",
+ "stmt", "assignment", "endstmt", "value", "atom", "valuelist", "values",
+ "nlok", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+ (internal) symbol number NUM (which must be that of a token). */
+static const yytype_uint16 yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 61, 59,
+ 91, 93, 44
+};
+# endif
+
+#define YYPACT_NINF -18
+
+#define yypact_value_is_default(Yystate) \
+ (!!((Yystate) == (-18)))
+
+#define YYTABLE_NINF -3
+
+#define yytable_value_is_error(Yytable_value) \
+ 0
+
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+static const yytype_int8 yypact[] =
+{
+ -18, 5, 1, -18, -3, 14, -18, -18, -18, 3,
+ -18, -18, 10, 10, -18, -18, -18, -18, -18, -18,
+ -18, 13, -18, -18, 15, 12, 19, -18, -18, 13,
+ -18, 19
+};
+
+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+ Performed when YYTABLE does not specify something else to do. Zero
+ means the default is an error. */
+static const yytype_uint8 yydefact[] =
+{
+ 4, 0, 0, 1, 0, 0, 11, 12, 5, 3,
+ 7, 8, 0, 0, 6, 15, 16, 22, 10, 13,
+ 9, 17, 23, 22, 0, 18, 20, 14, 22, 19,
+ 22, 21
+};
+
+ /* YYPGOTO[NTERM-NUM]. */
+static const yytype_int8 yypgoto[] =
+{
+ -18, -18, -18, -18, -18, 18, -13, -18, -18, -18,
+ -17
+};
+
+ /* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int8 yydefgoto[] =
+{
+ -1, 1, 2, 8, 9, 10, 18, 19, 24, 25,
+ 21
+};
+
+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule whose
+ number is the opposite. If YYTABLE_NINF, syntax error. */
+static const yytype_int8 yytable[] =
+{
+ 20, -2, 4, 11, 5, 3, 26, 6, 23, 6,
+ 7, 29, 7, 31, 15, 16, 30, 15, 16, 22,
+ 17, 12, 13, 17, 28, 22, 27, 14
+};
+
+static const yytype_uint8 yycheck[] =
+{
+ 13, 0, 1, 6, 3, 0, 23, 6, 21, 6,
+ 9, 28, 9, 30, 4, 5, 29, 4, 5, 6,
+ 10, 7, 8, 10, 12, 6, 11, 9
+};
+
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const yytype_uint8 yystos[] =
+{
+ 0, 14, 15, 0, 1, 3, 6, 9, 16, 17,
+ 18, 6, 7, 8, 18, 4, 5, 10, 19, 20,
+ 19, 23, 6, 19, 21, 22, 23, 11, 12, 23,
+ 19, 23
+};
+
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_uint8 yyr1[] =
+{
+ 0, 13, 14, 14, 15, 15, 16, 16, 16, 17,
+ 17, 18, 18, 19, 19, 20, 20, 21, 21, 21,
+ 22, 22, 23, 23
+};
+
+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
+static const yytype_uint8 yyr2[] =
+{
+ 0, 2, 1, 2, 0, 2, 2, 1, 2, 3,
+ 3, 1, 1, 1, 4, 1, 1, 0, 1, 3,
+ 2, 5, 0, 2
+};
+
+
+#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 yyerrorlab
+
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+ do \
+ if (yychar == YYEMPTY) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ YYPOPSTACK (yylen); \
+ yystate = *yyssp; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (&yylloc, ctx, YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+ while (0)
+
+/* Error token number */
+#define YYTERROR 1
+#define YYERRCODE 256
+
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+ If N is 0, then set CURRENT to the empty location which ends
+ the previous symbol: RHS[0] (always defined). */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+ do \
+ if (N) \
+ { \
+ (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
+ (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
+ (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
+ (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
+ } \
+ else \
+ { \
+ (Current).first_line = (Current).last_line = \
+ YYRHSLOC (Rhs, 0).last_line; \
+ (Current).first_column = (Current).last_column = \
+ YYRHSLOC (Rhs, 0).last_column; \
+ } \
+ while (0)
+#endif
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+
+
+/* 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)
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+ This macro was not mandated originally: define only if we know
+ we won't break user code: when these are the locations we know. */
+
+#ifndef YY_LOCATION_PRINT
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+
+/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
+
+YY_ATTRIBUTE_UNUSED
+static int
+yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
+{
+ int res = 0;
+ int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
+ if (0 <= yylocp->first_line)
+ {
+ res += YYFPRINTF (yyo, "%d", yylocp->first_line);
+ if (0 <= yylocp->first_column)
+ res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
+ }
+ if (0 <= yylocp->last_line)
+ {
+ if (yylocp->first_line < yylocp->last_line)
+ {
+ res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
+ if (0 <= end_col)
+ res += YYFPRINTF (yyo, ".%d", end_col);
+ }
+ else if (0 <= end_col && yylocp->first_column < end_col)
+ res += YYFPRINTF (yyo, "-%d", end_col);
+ }
+ return res;
+ }
+
+# define YY_LOCATION_PRINT(File, Loc) \
+ yy_location_print_ (File, &(Loc))
+
+# else
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value, Location, ctx); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
+
+/*-----------------------------------.
+| Print this symbol's value on YYO. |
+`-----------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, CfgParseContext *ctx)
+{
+ FILE *yyoutput = yyo;
+ YYUSE (yyoutput);
+ YYUSE (yylocationp);
+ YYUSE (ctx);
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
+# endif
+ YYUSE (yytype);
+}
+
+
+/*---------------------------.
+| Print this symbol on YYO. |
+`---------------------------*/
+
+static void
+yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, CfgParseContext *ctx)
+{
+ YYFPRINTF (yyo, "%s %s (",
+ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+ YY_LOCATION_PRINT (yyo, *yylocationp);
+ YYFPRINTF (yyo, ": ");
+ yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, ctx);
+ YYFPRINTF (yyo, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included). |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
+ 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. |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, CfgParseContext *ctx)
+{
+ unsigned long yylno = yyrline[yyrule];
+ int yynrhs = yyr2[yyrule];
+ int yyi;
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr,
+ yystos[yyssp[yyi + 1 - yynrhs]],
+ &yyvsp[(yyi + 1) - (yynrhs)]
+ , &(yylsp[(yyi + 1) - (yynrhs)]) , ctx);
+ YYFPRINTF (stderr, "\n");
+ }
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyssp, yyvsp, yylsp, Rule, ctx); \
+} 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 YY_SYMBOL_PRINT(Title, Type, 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
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#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
+yystrlen (const char *yystr)
+{
+ YYSIZE_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
+ continue;
+ return yylen;
+}
+# 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 *
+yystpcpy (char *yydest, const char *yysrc)
+{
+ char *yyd = yydest;
+ const char *yys = yysrc;
+
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
+}
+# endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+ quotes and backslashes, so that it's suitable for yyerror. The
+ heuristic is that double-quoting is unnecessary unless the string
+ contains an apostrophe, a comma, or backslash (other than
+ backslash-backslash). YYSTR is taken from yytname. If YYRES is
+ null, do not copy; instead, return the length of what the result
+ would have been. */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+ if (*yystr == '"')
+ {
+ YYSIZE_T yyn = 0;
+ char const *yyp = yystr;
+
+ for (;;)
+ switch (*++yyp)
+ {
+ case '\'':
+ case ',':
+ goto do_not_strip_quotes;
+
+ case '\\':
+ if (*++yyp != '\\')
+ goto do_not_strip_quotes;
+ else
+ goto append;
+
+ append:
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
+ do_not_strip_quotes: ;
+ }
+
+ if (! yyres)
+ return yystrlen (yystr);
+
+ return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+ about the unexpected token YYTOKEN for the state stack whose top is
+ YYSSP.
+
+ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
+ not large enough to hold the message. In that case, also set
+ *YYMSG_ALLOC to the required number of bytes. Return 2 if the
+ required number of bytes is too large to store. */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+ yytype_int16 *yyssp, int yytoken)
+{
+ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+ YYSIZE_T yysize = yysize0;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ /* Internationalized format string. */
+ const char *yyformat = YY_NULLPTR;
+ /* Arguments of yyformat. */
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
+
+ /* There are many possibilities here to consider:
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yychar) is if
+ this state is a consistent state with a default action. Thus,
+ detecting the absence of a lookahead is sufficient to determine
+ that there is no unexpected or expected token to report. In that
+ case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is a
+ consistent state with a default action. There might have been a
+ previous inconsistent state, consistent state with a non-default
+ action, or user semantic action that manipulated yychar.
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state merging
+ (from LALR or IELR) and default reductions corrupt the expected
+ token list. However, the list is correct for canonical LR with
+ one exception: it will still contain any token that will not be
+ accepted due to an error action in a later state.
+ */
+ if (yytoken != YYEMPTY)
+ {
+ int yyn = yypact[*yyssp];
+ yyarg[yycount++] = yytname[yytoken];
+ if (!yypact_value_is_default (yyn))
+ {
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for
+ this state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ int yyx;
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+ && !yytable_value_is_error (yytable[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ {
+ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+ if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+ yysize = yysize1;
+ else
+ return 2;
+ }
+ }
+ }
+ }
+
+ switch (yycount)
+ {
+# define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ default: /* Avoid compiler warnings. */
+ YYCASE_(0, YY_("syntax error"));
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+ }
+
+ {
+ YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+ if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+ yysize = yysize1;
+ else
+ return 2;
+ }
+
+ if (*yymsg_alloc < yysize)
+ {
+ *yymsg_alloc = 2 * yysize;
+ if (! (yysize <= *yymsg_alloc
+ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+ return 1;
+ }
+
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ {
+ char *yyp = *yymsg;
+ int yyi = 0;
+ while ((*yyp = *yyformat) != '\0')
+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyformat += 2;
+ }
+ else
+ {
+ yyp++;
+ yyformat++;
+ }
+ }
+ return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol. |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, CfgParseContext *ctx)
+{
+ YYUSE (yyvaluep);
+ YYUSE (yylocationp);
+ YYUSE (ctx);
+ if (!yymsg)
+ yymsg = "Deleting";
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ switch (yytype)
+ {
+ case 3: /* IDENT */
+#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
+ { free(((*yyvaluep).string)); }
+#line 1072 "libxlu_cfg_y.c" /* yacc.c:1257 */
+ break;
+
+ case 4: /* STRING */
+#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
+ { free(((*yyvaluep).string)); }
+#line 1078 "libxlu_cfg_y.c" /* yacc.c:1257 */
+ break;
+
+ case 5: /* NUMBER */
+#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
+ { free(((*yyvaluep).string)); }
+#line 1084 "libxlu_cfg_y.c" /* yacc.c:1257 */
+ break;
+
+ case 19: /* value */
+#line 44 "libxlu_cfg_y.y" /* yacc.c:1257 */
+ { xlu__cfg_value_free(((*yyvaluep).value)); }
+#line 1090 "libxlu_cfg_y.c" /* yacc.c:1257 */
+ break;
+
+ case 20: /* atom */
+#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
+ { free(((*yyvaluep).string)); }
+#line 1096 "libxlu_cfg_y.c" /* yacc.c:1257 */
+ break;
+
+ case 21: /* valuelist */
+#line 44 "libxlu_cfg_y.y" /* yacc.c:1257 */
+ { xlu__cfg_value_free(((*yyvaluep).value)); }
+#line 1102 "libxlu_cfg_y.c" /* yacc.c:1257 */
+ break;
+
+ case 22: /* values */
+#line 44 "libxlu_cfg_y.y" /* yacc.c:1257 */
+ { xlu__cfg_value_free(((*yyvaluep).value)); }
+#line 1108 "libxlu_cfg_y.c" /* yacc.c:1257 */
+ break;
+
+ default:
+ break;
+ }
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/*----------.
+| yyparse. |
+`----------*/
+
+int
+yyparse (CfgParseContext *ctx)
+{
+/* The lookahead symbol. */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol. */
+/* Default value used for initialization, for pacifying older GCCs
+ or non-GCC compilers. */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+/* Location data for the lookahead symbol. */
+static YYLTYPE yyloc_default
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+ = { 1, 1, 1, 1 }
+# endif
+;
+YYLTYPE yylloc = yyloc_default;
+
+ /* Number of syntax errors so far. */
+ int yynerrs;
+
+ int yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+
+ /* The stacks and their tools:
+ 'yyss': related to states.
+ 'yyvs': related to semantic values.
+ 'yyls': related to locations.
+
+ Refer to the stacks through separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss;
+ yytype_int16 *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
+
+ /* The location stack. */
+ YYLTYPE yylsa[YYINITDEPTH];
+ YYLTYPE *yyls;
+ YYLTYPE *yylsp;
+
+ /* The locations where the error started and ended. */
+ YYLTYPE yyerror_range[3];
+
+ YYSIZE_T yystacksize;
+
+ int yyn;
+ int yyresult;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken = 0;
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+ YYLTYPE yyloc;
+
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
+
+ yyssp = yyss = yyssa;
+ yyvsp = yyvs = yyvsa;
+ yylsp = yyls = yylsa;
+ yystacksize = YYINITDEPTH;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+ yylsp[0] = yylloc;
+ 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++;
+
+
+/*--------------------------------------------------------------------.
+| yynewstate -- set current state (the top of the stack) to yystate. |
+`--------------------------------------------------------------------*/
+yysetstate:
+ *yyssp = (yytype_int16) yystate;
+
+ if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+ goto yyexhaustedlab;
+#else
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
+
+# if defined 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;
+ yytype_int16 *yyss1 = yyss;
+ YYLTYPE *yyls1 = yyls;
+
+ /* 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 (YY_("memory exhausted"),
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yyls1, yysize * sizeof (*yylsp),
+ &yystacksize);
+ yyss = yyss1;
+ yyvs = yyvs1;
+ yyls = yyls1;
+ }
+# else /* defined YYSTACK_RELOCATE */
+ /* Extend the stack our own way. */
+ if (YYMAXDEPTH <= yystacksize)
+ goto yyexhaustedlab;
+ yystacksize *= 2;
+ if (YYMAXDEPTH < yystacksize)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ yytype_int16 *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+ YYSTACK_RELOCATE (yyls_alloc, yyls);
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+ yylsp = yyls + yysize - 1;
+
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long) yystacksize));
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ YYABORT;
+ }
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
+
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
+ 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. */
+
+ /* First try to decide what to do without reference to lookahead token. */
+ yyn = yypact[yystate];
+ if (yypact_value_is_default (yyn))
+ 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 (&yylval, &yylloc, ctx_scanner);
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("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 (yytable_value_is_error (yyn))
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ /* Shift the lookahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+
+ yystate = yyn;
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+ *++yylsp = yylloc;
+ 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];
+
+ /* Default location. */
+ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+ yyerror_range[1] = yyloc;
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 9:
+#line 58 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { xlu__cfg_set_store(ctx,(yyvsp[-2].string),XLU_OP_ASSIGNMENT,(yyvsp[0].value),(yylsp[0]).first_line); }
+#line 1406 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 10:
+#line 59 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { xlu__cfg_set_store(ctx,(yyvsp[-2].string),XLU_OP_ADDITION,(yyvsp[0].value),(yylsp[0]).first_line); }
+#line 1412 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 13:
+#line 64 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.value)= xlu__cfg_string_mk(ctx,(yyvsp[0].string),&(yylsp[0])); }
+#line 1418 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 14:
+#line 65 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.value)= (yyvsp[-1].value); }
+#line 1424 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 15:
+#line 67 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.string)= (yyvsp[0].string); }
+#line 1430 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 16:
+#line 68 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.string)= (yyvsp[0].string); }
+#line 1436 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 17:
+#line 70 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.value)= xlu__cfg_list_mk(ctx,NULL,&yylloc); }
+#line 1442 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 18:
+#line 71 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.value)= (yyvsp[0].value); }
+#line 1448 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 19:
+#line 72 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.value)= (yyvsp[-2].value); }
+#line 1454 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 20:
+#line 74 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { (yyval.value)= xlu__cfg_list_mk(ctx,(yyvsp[-1].value),&(yylsp[-1])); }
+#line 1460 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+ case 21:
+#line 75 "libxlu_cfg_y.y" /* yacc.c:1652 */
+ { xlu__cfg_list_append(ctx,(yyvsp[-4].value),(yyvsp[-1].value)); (yyval.value)= (yyvsp[-4].value); }
+#line 1466 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ break;
+
+
+#line 1470 "libxlu_cfg_y.c" /* yacc.c:1652 */
+ default: break;
+ }
+ /* User semantic actions sometimes alter yychar, and that requires
+ that yytoken be updated with the new translation. We take the
+ approach of translating immediately before every use of yytoken.
+ One alternative is translating here after every semantic action,
+ but that translation would be missed if the semantic action invokes
+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
+ incorrect destructor might then be invoked immediately. In the
+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
+ to an incorrect destructor call or verbose syntax error message
+ before the lookahead is translated. */
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+
+ *++yyvsp = yyval;
+ *++yylsp = yyloc;
+
+ /* 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. */
+ {
+ const int yylhs = yyr1[yyn] - YYNTOKENS;
+ const int yyi = yypgoto[yylhs] + *yyssp;
+ yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+ ? yytable[yyi]
+ : yydefgoto[yylhs]);
+ }
+
+ goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error. |
+`--------------------------------------*/
+yyerrlab:
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+#if ! YYERROR_VERBOSE
+ yyerror (&yylloc, ctx, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+ yyssp, yytoken)
+ {
+ char const *yymsgp = YY_("syntax error");
+ int yysyntax_error_status;
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ if (yysyntax_error_status == 0)
+ yymsgp = yymsg;
+ else if (yysyntax_error_status == 1)
+ {
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+ if (!yymsg)
+ {
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
+ yysyntax_error_status = 2;
+ }
+ else
+ {
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ yymsgp = yymsg;
+ }
+ }
+ yyerror (&yylloc, ctx, yymsgp);
+ if (yysyntax_error_status == 2)
+ goto yyexhaustedlab;
+ }
+# undef YYSYNTAX_ERROR
+#endif
+ }
+
+ yyerror_range[1] = yylloc;
+
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ if (yychar <= YYEOF)
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
+ else
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval, &yylloc, ctx);
+ yychar = YYEMPTY;
+ }
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+ /* Pacify compilers when the user code never invokes YYERROR and the
+ label yyerrorlab therefore never appears in user code. */
+ if (0)
+ YYERROR;
+
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+ yystate = *yyssp;
+ goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
+
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (!yypact_value_is_default (yyn))
+ {
+ 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;
+
+ yyerror_range[1] = *yylsp;
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp, yylsp, ctx);
+ YYPOPSTACK (1);
+ yystate = *yyssp;
+ YY_STACK_PRINT (yyss, yyssp);
+ }
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+ yyerror_range[2] = yylloc;
+ /* Using YYLLOC is tempting, but would change the location of
+ the lookahead. YYLOC is available though. */
+ YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
+ *++yylsp = yyloc;
+
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (&yylloc, ctx, YY_("memory exhausted"));
+ yyresult = 2;
+ /* Fall through. */
+#endif
+
+
+/*-----------------------------------------------------.
+| yyreturn -- parsing is finished, return the result. |
+`-----------------------------------------------------*/
+yyreturn:
+ if (yychar != YYEMPTY)
+ {
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = YYTRANSLATE (yychar);
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval, &yylloc, ctx);
+ }
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
+ {
+ yydestruct ("Cleanup: popping",
+ yystos[*yyssp], yyvsp, yylsp, ctx);
+ YYPOPSTACK (1);
+ }
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ return yyresult;
+}
--- /dev/null
+/* A Bison parser, made by GNU Bison 3.3.2. */
+
+/* Bison interface for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 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 3 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, see <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* Undocumented macros, especially those whose name start with YY_,
+ are private implementation details. Do not rely on them. */
+
+#ifndef YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
+# define YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int xlu__cfg_yydebug;
+#endif
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ IDENT = 258,
+ STRING = 259,
+ NUMBER = 260,
+ NEWLINE = 261,
+ OP_ADD = 262
+ };
+#endif
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 25 "libxlu_cfg_y.y" /* yacc.c:1921 */
+
+ char *string;
+ XLU_ConfigValue *value;
+
+#line 71 "libxlu_cfg_y.h" /* yacc.c:1921 */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+/* Location type. */
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE YYLTYPE;
+struct YYLTYPE
+{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+};
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+int xlu__cfg_yyparse (CfgParseContext *ctx);
+
+#endif /* !YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED */
--- /dev/null
+/* -*- fundamental -*- */
+/*
+ * libxlu_cfg_l.y - xl configuration file parsing: parser
+ *
+ * Copyright (C) 2010 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+%{
+#define ctx_scanner ctx->scanner
+#include "libxlu_cfg_i.h"
+#include "libxlu_cfg_l.h"
+%}
+
+%union {
+ char *string;
+ XLU_ConfigValue *value;
+}
+
+%locations
+%pure-parser
+%defines
+%error-verbose
+%name-prefix "xlu__cfg_yy"
+%parse-param { CfgParseContext *ctx }
+%lex-param { ctx_scanner }
+
+%token <string> IDENT STRING NUMBER NEWLINE
+%type <string> atom
+%destructor { free($$); } atom IDENT STRING NUMBER
+%token OP_ADD "+="
+
+%type <value> value valuelist values
+%destructor { xlu__cfg_value_free($$); } value valuelist values
+
+%%
+
+file: stmts
+ | stmts assignment
+
+stmts: /* empty */
+ | stmts stmt
+
+stmt: assignment endstmt
+ | endstmt
+ | error NEWLINE
+
+assignment: IDENT '=' value { xlu__cfg_set_store(ctx,$1,XLU_OP_ASSIGNMENT,$3,@3.first_line); }
+ | IDENT "+=" value { xlu__cfg_set_store(ctx,$1,XLU_OP_ADDITION,$3,@3.first_line); }
+
+endstmt: NEWLINE
+ | ';'
+
+value: atom { $$= xlu__cfg_string_mk(ctx,$1,&@1); }
+ | '[' nlok valuelist ']' { $$= $3; }
+
+atom: STRING { $$= $1; }
+ | NUMBER { $$= $1; }
+
+valuelist: /* empty */ { $$= xlu__cfg_list_mk(ctx,NULL,&yylloc); }
+ | values { $$= $1; }
+ | values ',' nlok { $$= $1; }
+
+values: value nlok { $$= xlu__cfg_list_mk(ctx,$1,&@1); }
+ | values ',' nlok value nlok { xlu__cfg_list_append(ctx,$1,$4); $$= $1; }
+
+nlok:
+ /* nothing */
+ | nlok NEWLINE
--- /dev/null
+#include "libxlu_internal.h"
+#include "libxlu_disk_l.h"
+#include "libxlu_disk_i.h"
+#include "libxlu_cfg_i.h"
+
+void xlu__disk_err(DiskParseContext *dpc, const char *erroneous,
+ const char *message) {
+ fprintf(dpc->cfg->report,
+ "%s: config parsing error in disk specification: %s"
+ "%s%s%s"
+ " in `%s'\n",
+ dpc->cfg->config_source, message,
+ erroneous?": near `":"", erroneous?erroneous:"", erroneous?"'":"",
+ dpc->spec);
+ if (!dpc->err) dpc->err= EINVAL;
+}
+
+static int dpc_prep(DiskParseContext *dpc, const char *spec) {
+ int e;
+
+ dpc->spec = spec;
+
+ e = xlu__disk_yylex_init_extra(dpc, &dpc->scanner);
+ if (e) goto fail;
+
+ dpc->buf = xlu__disk_yy_scan_bytes(spec, strlen(spec), dpc->scanner);
+ if (!dpc->buf) { e = ENOMEM; goto fail; }
+
+ return 0;
+
+ fail:
+ fprintf(dpc->cfg->report, "cannot init disk scanner: %s\n",
+ strerror(errno));
+ return e;
+}
+
+static void dpc_dispose(DiskParseContext *dpc) {
+ if (dpc->buf) {
+ xlu__disk_yy_delete_buffer(dpc->buf, dpc->scanner);
+ dpc->buf = 0;
+ }
+ if (dpc->scanner) {
+ xlu__disk_yylex_destroy(dpc->scanner);
+ dpc->scanner = 0;
+ }
+}
+
+int xlu_disk_parse(XLU_Config *cfg,
+ int nspecs, const char *const *specs,
+ libxl_device_disk *disk) {
+ DiskParseContext dpc;
+ int i, e;
+
+ memset(&dpc,0,sizeof(dpc));
+ dpc.cfg = cfg;
+ dpc.scanner = 0;
+ dpc.disk = disk;
+
+ disk->readwrite = 1;
+
+ for (i=0; i<nspecs; i++) {
+ e = dpc_prep(&dpc, specs[i]);
+ if (e) { dpc.err = e; goto x_err; }
+
+ xlu__disk_yylex(dpc.scanner);
+ assert(!e);
+ if (dpc.err) goto x_err;
+
+ dpc_dispose(&dpc);
+ }
+
+ if (disk->format == LIBXL_DISK_FORMAT_UNKNOWN) {
+ disk->format = LIBXL_DISK_FORMAT_RAW;
+ }
+ if (disk->is_cdrom) {
+ disk->removable = 1;
+ disk->readwrite = 0;
+ if (!disk->pdev_path || !strcmp(disk->pdev_path, ""))
+ disk->format = LIBXL_DISK_FORMAT_EMPTY;
+ }
+
+ if (!disk->vdev) {
+ xlu__disk_err(&dpc,0, "no vdev specified");
+ goto x_err;
+ }
+ if (!disk->pdev_path && !disk->removable) {
+ xlu__disk_err(&dpc,0,"no target specified (and device not removable)");
+ goto x_err;
+ }
+
+ x_err:
+ dpc_dispose(&dpc);
+ return dpc.err;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- /dev/null
+#ifndef LIBXLU_DISK_I_H
+#define LIBXLU_DISK_I_H
+
+#include "libxlu_internal.h"
+
+
+typedef struct {
+ XLU_Config *cfg;
+ int err;
+ void *scanner;
+ YY_BUFFER_STATE buf;
+ libxl_device_disk *disk;
+ int access_set, had_depr_prefix;
+ const char *spec;
+} DiskParseContext;
+
+void xlu__disk_err(DiskParseContext *dpc, const char *erroneous,
+ const char *message);
+
+
+#endif /*LIBXLU_DISK_I_H*/
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- /dev/null
+#line 1 "libxlu_disk_l.c"
+#define _GNU_SOURCE
+
+#line 4 "libxlu_disk_l.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 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define xlu__disk_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer xlu__disk_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define xlu__disk_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer xlu__disk_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define xlu__disk_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer xlu__disk_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define xlu__disk_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string xlu__disk_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define xlu__disk_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes xlu__disk_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define xlu__disk_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer xlu__disk_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define xlu__disk_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer xlu__disk_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define xlu__disk_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state xlu__disk_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define xlu__disk_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer xlu__disk_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define xlu__disk_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state xlu__disk_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define xlu__disk_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state xlu__disk_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define xlu__disk_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack xlu__disk_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define xlu__disk_yylex_ALREADY_DEFINED
+#else
+#define yylex xlu__disk_yylex
+#endif
+
+#ifdef yyrestart
+#define xlu__disk_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart xlu__disk_yyrestart
+#endif
+
+#ifdef yylex_init
+#define xlu__disk_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init xlu__disk_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define xlu__disk_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra xlu__disk_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define xlu__disk_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy xlu__disk_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define xlu__disk_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug xlu__disk_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define xlu__disk_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug xlu__disk_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define xlu__disk_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra xlu__disk_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define xlu__disk_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra xlu__disk_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define xlu__disk_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in xlu__disk_yyget_in
+#endif
+
+#ifdef yyset_in
+#define xlu__disk_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in xlu__disk_yyset_in
+#endif
+
+#ifdef yyget_out
+#define xlu__disk_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out xlu__disk_yyget_out
+#endif
+
+#ifdef yyset_out
+#define xlu__disk_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out xlu__disk_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define xlu__disk_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng xlu__disk_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define xlu__disk_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text xlu__disk_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define xlu__disk_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno xlu__disk_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define xlu__disk_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno xlu__disk_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define xlu__disk_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column xlu__disk_yyget_column
+#endif
+
+#ifdef yyset_column
+#define xlu__disk_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column xlu__disk_yyset_column
+#endif
+
+#ifdef yywrap
+#define xlu__disk_yywrap_ALREADY_DEFINED
+#else
+#define yywrap xlu__disk_yywrap
+#endif
+
+#ifdef yyalloc
+#define xlu__disk_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc xlu__disk_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define xlu__disk_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc xlu__disk_yyrealloc
+#endif
+
+#ifdef yyfree
+#define xlu__disk_yyfree_ALREADY_DEFINED
+#else
+#define yyfree xlu__disk_yyfree
+#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
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#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;
+
+/* 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
+
+#ifndef SIZE_MAX
+#define SIZE_MAX (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an
+ * integer in range [0..255] for use as an array index.
+ */
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+ are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* 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 yyg->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 ((yyg->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 yyrestart( yyin , yyscanner )
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+ #define YY_LESS_LINENO(n)
+ #define YY_LINENO_REWIND_TO(ptr)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ int yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ *yy_cp = yyg->yy_hold_char; \
+ YY_RESTORE_YY_MORE_OFFSET \
+ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+ } \
+ while ( 0 )
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#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.
+ */
+ int 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 yyrestart()), so that the user can continue scanning by
+ * just pointing yyin at a new input file.
+ */
+#define YY_BUFFER_EOF_PENDING 2
+
+ };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* 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 ( yyg->yy_buffer_stack \
+ ? yyg->yy_buffer_stack[yyg->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 yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+static void yyensure_buffer_stack ( yyscan_t yyscanner );
+static void yy_load_buffer_state ( yyscan_t yyscanner );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){ \
+ yyensure_buffer_stack (yyscanner); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+ }
+#define yy_set_bol(at_bol) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){\
+ yyensure_buffer_stack (yyscanner); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+ }
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+#define xlu__disk_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+typedef flex_uint8_t YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
+static int yy_get_next_buffer ( yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+ yyg->yytext_ptr = yy_bp; \
+ yyg->yytext_ptr -= yyg->yy_more_len; \
+ yyleng = (int) (yy_cp - yyg->yytext_ptr); \
+ yyg->yy_hold_char = *yy_cp; \
+ *yy_cp = '\0'; \
+ yyg->yy_c_buf_p = yy_cp;
+#define YY_NUM_RULES 36
+#define YY_END_OF_BUFFER 37
+/* 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 const flex_int16_t yy_acclist[575] =
+ { 0,
+ 35, 35, 37, 33, 34, 36, 8193, 33, 34, 36,
+ 16385, 8193, 33, 36,16385, 33, 34, 36, 34, 36,
+ 33, 34, 36, 33, 34, 36, 33, 34, 36, 33,
+ 34, 36, 33, 34, 36, 33, 34, 36, 33, 34,
+ 36, 33, 34, 36, 33, 34, 36, 33, 34, 36,
+ 33, 34, 36, 33, 34, 36, 33, 34, 36, 33,
+ 34, 36, 33, 34, 36, 33, 34, 36, 35, 36,
+ 36, 33, 33, 8193, 33, 8193, 33,16385, 8193, 33,
+ 8193, 33, 33, 8224, 33,16416, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 35,
+ 8193, 33, 8193, 33, 8193, 8224, 33, 8224, 33, 8224,
+ 23, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 8224, 33, 8224, 33, 8224,
+ 23, 33, 33, 28, 8224, 33,16416, 33, 33, 15,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 8217,
+ 8224, 33,16409,16416, 33, 33, 31, 8224, 33,16416,
+ 33, 8216, 8224, 33,16408,16416, 33, 33, 8219, 8224,
+ 33,16411,16416, 33, 33, 33, 33, 33, 28, 8224,
+
+ 33, 28, 8224, 33, 28, 33, 28, 8224, 33, 3,
+ 33, 15, 33, 33, 33, 33, 33, 30, 8224, 33,
+ 16416, 33, 33, 33, 8217, 8224, 33, 8217, 8224, 33,
+ 8217, 33, 8217, 8224, 33, 33, 31, 8224, 33, 31,
+ 8224, 33, 31, 33, 31, 8224, 8216, 8224, 33, 8216,
+ 8224, 33, 8216, 33, 8216, 8224, 33, 8219, 8224, 33,
+ 8219, 8224, 33, 8219, 33, 8219, 8224, 33, 33, 10,
+ 33, 33, 28, 8224, 33, 28, 8224, 33, 28, 8224,
+ 28, 33, 28, 33, 3, 33, 33, 33, 33, 33,
+ 33, 33, 30, 8224, 33, 30, 8224, 33, 30, 33,
+
+ 30, 8224, 33, 33, 29, 8224, 33,16416, 8217, 8224,
+ 33, 8217, 8224, 33, 8217, 8224, 8217, 33, 8217, 33,
+ 33, 31, 8224, 33, 31, 8224, 33, 31, 8224, 31,
+ 33, 31, 8216, 8224, 33, 8216, 8224, 33, 8216, 8224,
+ 8216, 33, 8216, 33, 8219, 8224, 33, 8219, 8224, 33,
+ 8219, 8224, 8219, 33, 8219, 33, 33, 10, 23, 10,
+ 7, 33, 33, 33, 33, 33, 33, 33, 13, 33,
+ 30, 8224, 33, 30, 8224, 33, 30, 8224, 30, 33,
+ 30, 2, 33, 29, 8224, 33, 29, 8224, 33, 29,
+ 33, 29, 8224, 16, 33, 33, 11, 33, 22, 10,
+
+ 10, 23, 7, 23, 7, 33, 8, 33, 33, 33,
+ 33, 6, 33, 13, 33, 2, 23, 2, 33, 29,
+ 8224, 33, 29, 8224, 33, 29, 8224, 29, 33, 29,
+ 16, 33, 33, 11, 23, 11, 26, 8224, 33,16416,
+ 22, 23, 22, 7, 7, 23, 33, 8, 23, 8,
+ 33, 33, 33, 33, 6, 23, 6, 6, 23, 6,
+ 23, 33, 2, 2, 23, 33, 33, 11, 11, 23,
+ 26, 8224, 33, 26, 8224, 33, 26, 33, 26, 8224,
+ 22, 23, 33, 8, 8, 23, 33, 33, 17, 18,
+ 6, 6, 23, 6, 6, 33, 33, 14, 33, 26,
+
+ 8224, 33, 26, 8224, 33, 26, 8224, 26, 33, 26,
+ 33, 33, 33, 17, 23, 17, 18, 23, 18, 6,
+ 6, 33, 33, 14, 33, 20, 9, 19, 17, 17,
+ 23, 18, 18, 23, 6, 5, 6, 33, 21, 20,
+ 23, 20, 9, 23, 9, 19, 23, 19, 4, 6,
+ 5, 6, 33, 21, 23, 21, 20, 20, 23, 9,
+ 9, 23, 19, 19, 23, 4, 6, 12, 33, 21,
+ 21, 23, 12, 33
+ } ;
+
+static const flex_int16_t yy_accept[356] =
+ { 0,
+ 1, 1, 1, 2, 3, 4, 7, 12, 16, 19,
+ 21, 24, 27, 30, 33, 36, 39, 42, 45, 48,
+ 51, 54, 57, 60, 63, 66, 69, 71, 72, 73,
+ 74, 76, 79, 81, 82, 83, 84, 87, 87, 88,
+ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
+ 109, 110, 111, 113, 115, 116, 118, 120, 121, 122,
+ 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
+ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
+ 143, 144, 145, 146, 148, 150, 151, 152, 153, 154,
+
+ 158, 159, 160, 162, 163, 164, 165, 166, 167, 168,
+ 169, 170, 175, 176, 177, 181, 182, 187, 188, 189,
+ 194, 195, 196, 197, 198, 199, 202, 205, 207, 209,
+ 210, 212, 214, 215, 216, 217, 218, 222, 223, 224,
+ 225, 228, 231, 233, 235, 236, 237, 240, 243, 245,
+ 247, 250, 253, 255, 257, 258, 261, 264, 266, 268,
+ 269, 270, 271, 272, 273, 276, 279, 281, 283, 284,
+ 285, 287, 288, 289, 290, 291, 292, 293, 296, 299,
+ 301, 303, 304, 305, 309, 312, 315, 317, 319, 320,
+ 321, 322, 325, 328, 330, 332, 333, 336, 339, 341,
+
+ 343, 344, 345, 348, 351, 353, 355, 356, 357, 358,
+ 360, 361, 362, 363, 364, 365, 366, 367, 368, 369,
+ 371, 374, 377, 379, 381, 382, 383, 384, 387, 390,
+ 392, 394, 396, 397, 398, 399, 400, 401, 403, 405,
+ 406, 407, 408, 409, 410, 411, 412, 413, 414, 416,
+ 418, 419, 420, 423, 426, 428, 430, 431, 433, 434,
+ 436, 437, 441, 443, 444, 445, 447, 448, 450, 451,
+ 452, 453, 454, 455, 457, 458, 460, 462, 463, 464,
+ 466, 467, 468, 469, 471, 474, 477, 479, 481, 483,
+ 484, 485, 487, 488, 489, 490, 491, 492, 494, 495,
+
+ 496, 497, 498, 500, 503, 506, 508, 510, 511, 512,
+ 513, 514, 516, 517, 519, 520, 521, 522, 523, 524,
+ 526, 527, 528, 529, 530, 532, 533, 535, 536, 538,
+ 539, 540, 542, 543, 545, 546, 548, 549, 551, 553,
+ 554, 556, 557, 558, 560, 561, 563, 564, 566, 568,
+ 570, 571, 573, 575, 575
+ } ;
+
+static const YY_CHAR 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, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 4, 5, 1, 1, 6, 6, 7,
+ 6, 6, 6, 6, 6, 6, 6, 8, 1, 1,
+ 9, 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, 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, 19, 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, 1, 1
+ } ;
+
+static const YY_CHAR yy_meta[35] =
+ { 0,
+ 1, 1, 2, 3, 1, 1, 1, 1, 4, 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
+ } ;
+
+static const flex_int16_t yy_base[424] =
+ { 0,
+ 0, 0, 901, 900, 902, 897, 33, 36, 905, 905,
+ 45, 63, 31, 42, 51, 52, 890, 33, 65, 67,
+ 69, 70, 889, 71, 888, 75, 0, 905, 893, 905,
+ 91, 94, 0, 0, 103, 886, 112, 0, 89, 98,
+ 113, 92, 114, 99, 100, 48, 121, 116, 119, 74,
+ 124, 129, 123, 135, 132, 133, 137, 134, 138, 139,
+ 141, 0, 155, 0, 0, 164, 0, 0, 849, 142,
+ 152, 164, 140, 161, 165, 166, 167, 168, 169, 173,
+ 174, 178, 176, 180, 184, 208, 189, 183, 192, 195,
+ 215, 191, 193, 223, 0, 0, 905, 208, 204, 236,
+
+ 219, 209, 238, 196, 237, 831, 242, 815, 241, 224,
+ 243, 261, 244, 259, 277, 266, 286, 250, 288, 298,
+ 249, 283, 274, 282, 294, 308, 0, 310, 0, 295,
+ 305, 905, 308, 306, 313, 314, 342, 319, 316, 320,
+ 331, 0, 349, 0, 342, 344, 356, 0, 358, 0,
+ 365, 0, 367, 0, 354, 375, 0, 377, 0, 363,
+ 356, 809, 327, 322, 384, 0, 0, 0, 0, 379,
+ 905, 382, 384, 386, 390, 372, 392, 403, 0, 410,
+ 0, 407, 413, 423, 426, 0, 0, 0, 0, 409,
+ 424, 435, 0, 0, 0, 0, 437, 0, 0, 0,
+
+ 0, 433, 444, 0, 0, 0, 0, 391, 440, 781,
+ 905, 769, 439, 445, 444, 447, 449, 454, 453, 399,
+ 464, 0, 0, 0, 0, 757, 465, 476, 0, 478,
+ 0, 479, 476, 753, 462, 490, 749, 905, 745, 905,
+ 483, 737, 424, 485, 487, 490, 500, 493, 905, 729,
+ 905, 502, 518, 0, 0, 0, 0, 905, 498, 721,
+ 905, 527, 713, 0, 705, 905, 495, 697, 905, 365,
+ 521, 528, 530, 685, 905, 534, 540, 540, 657, 905,
+ 537, 542, 650, 905, 553, 0, 557, 0, 0, 551,
+ 641, 905, 558, 557, 633, 614, 613, 905, 547, 555,
+
+ 563, 565, 569, 584, 0, 0, 0, 0, 583, 570,
+ 585, 612, 905, 601, 905, 522, 580, 589, 594, 905,
+ 600, 585, 563, 520, 905, 514, 905, 586, 486, 597,
+ 480, 441, 905, 416, 905, 345, 905, 334, 905, 601,
+ 254, 905, 242, 905, 200, 905, 151, 905, 905, 607,
+ 86, 905, 905, 905, 620, 624, 627, 631, 635, 639,
+ 643, 647, 651, 655, 659, 663, 667, 671, 675, 679,
+ 683, 687, 691, 695, 699, 703, 707, 711, 715, 719,
+ 723, 727, 731, 735, 739, 743, 747, 751, 755, 759,
+ 763, 767, 771, 775, 779, 783, 787, 791, 795, 799,
+
+ 803, 807, 811, 815, 819, 823, 827, 831, 835, 839,
+ 843, 847, 851, 855, 859, 863, 867, 871, 875, 879,
+ 883, 887, 891
+ } ;
+
+static const flex_int16_t yy_def[424] =
+ { 0,
+ 354, 1, 355, 355, 354, 356, 357, 357, 354, 354,
+ 358, 358, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12, 12, 12, 12, 12, 12, 359, 354, 356, 354,
+ 360, 357, 361, 361, 362, 12, 356, 363, 12, 12,
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12, 359, 360, 361, 361, 364, 365, 365, 354, 12,
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12, 12, 12, 12, 12, 362, 12, 12, 12, 12,
+ 12, 12, 12, 364, 365, 365, 354, 12, 12, 366,
+
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12, 367, 86, 86, 368, 12, 369, 12, 12, 370,
+ 12, 12, 12, 12, 12, 371, 372, 366, 372, 12,
+ 12, 354, 86, 12, 12, 12, 373, 12, 12, 12,
+ 374, 375, 367, 375, 86, 86, 376, 377, 368, 377,
+ 378, 379, 369, 379, 12, 380, 381, 370, 381, 12,
+ 12, 382, 12, 12, 371, 372, 372, 383, 383, 12,
+ 354, 86, 86, 86, 12, 12, 12, 384, 385, 373,
+ 385, 12, 12, 386, 374, 375, 375, 387, 387, 86,
+ 86, 376, 377, 377, 388, 388, 378, 379, 379, 389,
+
+ 389, 12, 380, 381, 381, 390, 390, 12, 12, 391,
+ 354, 392, 86, 12, 86, 86, 86, 12, 86, 12,
+ 384, 385, 385, 393, 393, 394, 86, 395, 396, 386,
+ 396, 86, 86, 397, 12, 398, 391, 354, 399, 354,
+ 86, 400, 12, 86, 86, 86, 401, 86, 354, 402,
+ 354, 86, 395, 396, 396, 403, 403, 354, 86, 404,
+ 354, 405, 406, 406, 399, 354, 86, 407, 354, 12,
+ 86, 86, 86, 408, 354, 408, 408, 86, 402, 354,
+ 86, 86, 404, 354, 409, 410, 405, 410, 406, 86,
+ 407, 354, 12, 86, 411, 412, 408, 354, 408, 408,
+
+ 86, 86, 86, 409, 410, 410, 413, 413, 86, 12,
+ 86, 414, 354, 415, 354, 408, 408, 86, 86, 354,
+ 416, 417, 418, 414, 354, 415, 354, 408, 408, 86,
+ 419, 420, 354, 421, 354, 422, 354, 408, 354, 86,
+ 423, 354, 420, 354, 421, 354, 422, 354, 354, 86,
+ 423, 354, 354, 0, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354
+ } ;
+
+static const flex_int16_t yy_nxt[940] =
+ { 0,
+ 6, 7, 8, 9, 6, 6, 6, 6, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19, 17, 17,
+ 17, 17, 20, 17, 21, 22, 23, 24, 25, 17,
+ 26, 17, 17, 17, 32, 32, 33, 32, 32, 33,
+ 36, 34, 36, 42, 34, 29, 29, 29, 30, 35,
+ 50, 36, 37, 38, 43, 44, 39, 36, 79, 45,
+ 36, 36, 40, 29, 29, 29, 30, 35, 46, 48,
+ 37, 38, 41, 47, 36, 49, 36, 53, 36, 36,
+ 36, 56, 58, 36, 36, 55, 82, 60, 51, 342,
+ 54, 61, 52, 29, 64, 32, 32, 33, 36, 65,
+
+ 70, 36, 34, 29, 29, 29, 30, 36, 36, 36,
+ 29, 38, 66, 66, 66, 67, 66, 71, 74, 66,
+ 68, 72, 36, 36, 73, 36, 77, 78, 36, 76,
+ 36, 53, 36, 36, 75, 85, 80, 83, 36, 86,
+ 84, 36, 36, 36, 36, 81, 36, 36, 36, 36,
+ 36, 36, 93, 89, 337, 98, 88, 29, 64, 101,
+ 90, 36, 91, 65, 92, 87, 29, 95, 89, 99,
+ 36, 100, 96, 36, 36, 36, 36, 36, 36, 106,
+ 105, 85, 36, 36, 102, 36, 107, 36, 103, 36,
+ 109, 112, 36, 36, 104, 108, 115, 110, 36, 117,
+
+ 36, 36, 36, 335, 36, 36, 122, 111, 29, 29,
+ 29, 30, 118, 36, 116, 29, 38, 36, 36, 113,
+ 114, 119, 120, 123, 36, 29, 95, 121, 36, 134,
+ 131, 96, 130, 36, 125, 124, 126, 126, 66, 127,
+ 126, 132, 133, 126, 129, 333, 36, 36, 135, 137,
+ 36, 36, 36, 140, 139, 35, 35, 352, 36, 36,
+ 85, 141, 141, 66, 142, 141, 160, 145, 141, 144,
+ 35, 35, 89, 117, 155, 36, 146, 147, 147, 66,
+ 148, 147, 162, 36, 147, 150, 151, 151, 66, 152,
+ 151, 36, 36, 151, 154, 120, 161, 36, 156, 156,
+
+ 66, 157, 156, 36, 36, 156, 159, 164, 171, 163,
+ 29, 166, 29, 168, 36, 36, 167, 170, 169, 35,
+ 35, 172, 36, 36, 173, 36, 213, 184, 36, 36,
+ 175, 36, 174, 29, 186, 212, 36, 349, 183, 187,
+ 177, 176, 178, 178, 66, 179, 178, 182, 348, 178,
+ 181, 29, 188, 35, 35, 35, 35, 189, 29, 193,
+ 29, 195, 190, 36, 194, 36, 196, 29, 198, 29,
+ 200, 191, 36, 199, 36, 201, 219, 29, 204, 29,
+ 206, 36, 202, 205, 209, 207, 29, 166, 36, 293,
+ 208, 214, 167, 35, 35, 35, 35, 35, 35, 36,
+
+ 36, 36, 249, 218, 220, 29, 222, 216, 36, 217,
+ 235, 223, 29, 224, 215, 226, 36, 227, 225, 346,
+ 35, 35, 36, 228, 228, 66, 229, 228, 29, 186,
+ 228, 231, 232, 36, 187, 233, 35, 29, 193, 29,
+ 198, 234, 36, 194, 344, 199, 29, 204, 236, 36,
+ 35, 241, 205, 242, 36, 35, 35, 270, 35, 35,
+ 35, 35, 247, 36, 35, 35, 29, 222, 244, 262,
+ 248, 36, 223, 243, 245, 246, 35, 252, 29, 254,
+ 29, 256, 258, 342, 255, 259, 257, 35, 35, 339,
+ 35, 35, 69, 264, 35, 35, 35, 35, 35, 35,
+
+ 267, 35, 35, 275, 35, 35, 35, 35, 271, 35,
+ 35, 276, 277, 35, 35, 272, 278, 315, 273, 281,
+ 29, 254, 290, 313, 282, 275, 255, 285, 285, 66,
+ 286, 285, 35, 35, 285, 288, 295, 298, 296, 35,
+ 35, 35, 35, 298, 301, 328, 299, 294, 35, 35,
+ 275, 35, 35, 35, 303, 29, 305, 300, 275, 29,
+ 307, 306, 35, 35, 302, 308, 337, 36, 35, 35,
+ 309, 310, 320, 316, 35, 35, 35, 35, 322, 36,
+ 35, 35, 317, 275, 319, 311, 29, 305, 335, 275,
+ 318, 321, 306, 323, 35, 35, 35, 35, 330, 329,
+
+ 35, 35, 331, 333, 327, 35, 35, 338, 35, 35,
+ 353, 340, 35, 35, 350, 325, 275, 315, 35, 35,
+ 27, 27, 27, 27, 29, 29, 29, 31, 31, 31,
+ 31, 36, 36, 36, 36, 62, 313, 62, 62, 63,
+ 63, 63, 63, 65, 269, 65, 65, 35, 35, 35,
+ 35, 69, 69, 261, 69, 94, 94, 94, 94, 96,
+ 251, 96, 96, 128, 128, 128, 128, 143, 143, 143,
+ 143, 149, 149, 149, 149, 153, 153, 153, 153, 158,
+ 158, 158, 158, 165, 165, 165, 165, 167, 298, 167,
+ 167, 180, 180, 180, 180, 185, 185, 185, 185, 187,
+
+ 292, 187, 187, 192, 192, 192, 192, 194, 240, 194,
+ 194, 197, 197, 197, 197, 199, 289, 199, 199, 203,
+ 203, 203, 203, 205, 284, 205, 205, 210, 210, 210,
+ 210, 169, 280, 169, 169, 221, 221, 221, 221, 223,
+ 269, 223, 223, 230, 230, 230, 230, 189, 266, 189,
+ 189, 196, 211, 196, 196, 201, 261, 201, 201, 207,
+ 251, 207, 207, 237, 237, 237, 237, 239, 239, 239,
+ 239, 225, 240, 225, 225, 250, 250, 250, 250, 253,
+ 253, 253, 253, 255, 238, 255, 255, 260, 260, 260,
+ 260, 263, 263, 263, 263, 265, 265, 265, 265, 268,
+
+ 268, 268, 268, 274, 274, 274, 274, 279, 279, 279,
+ 279, 257, 211, 257, 257, 283, 283, 283, 283, 287,
+ 287, 287, 287, 264, 138, 264, 264, 291, 291, 291,
+ 291, 297, 297, 297, 297, 304, 304, 304, 304, 306,
+ 136, 306, 306, 312, 312, 312, 312, 314, 314, 314,
+ 314, 308, 97, 308, 308, 324, 324, 324, 324, 326,
+ 326, 326, 326, 332, 332, 332, 332, 334, 334, 334,
+ 334, 336, 336, 336, 336, 341, 341, 341, 341, 343,
+ 343, 343, 343, 345, 345, 345, 345, 347, 347, 347,
+ 347, 351, 351, 351, 351, 36, 30, 59, 57, 36,
+
+ 30, 354, 28, 28, 5, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354
+ } ;
+
+static const flex_int16_t yy_chk[940] =
+ { 0,
+ 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, 7, 7, 7, 8, 8, 8,
+ 13, 7, 18, 13, 8, 11, 11, 11, 11, 11,
+ 18, 14, 11, 11, 13, 14, 11, 46, 46, 14,
+ 15, 16, 11, 12, 12, 12, 12, 12, 14, 16,
+ 12, 12, 12, 15, 19, 16, 20, 20, 21, 22,
+ 24, 22, 24, 50, 26, 21, 50, 26, 19, 351,
+ 20, 26, 19, 31, 31, 32, 32, 32, 39, 31,
+
+ 39, 42, 32, 35, 35, 35, 35, 40, 44, 45,
+ 35, 35, 37, 37, 37, 37, 37, 39, 42, 37,
+ 37, 40, 41, 43, 41, 48, 45, 45, 49, 44,
+ 47, 47, 53, 51, 43, 53, 48, 51, 52, 54,
+ 52, 55, 56, 58, 54, 49, 57, 59, 60, 73,
+ 61, 70, 60, 61, 347, 70, 56, 63, 63, 73,
+ 58, 71, 59, 63, 59, 55, 66, 66, 57, 71,
+ 74, 72, 66, 72, 75, 76, 77, 78, 79, 78,
+ 77, 79, 80, 81, 74, 83, 80, 82, 75, 84,
+ 82, 85, 88, 85, 76, 81, 87, 83, 87, 89,
+
+ 92, 89, 93, 345, 90, 104, 92, 84, 86, 86,
+ 86, 86, 90, 99, 88, 86, 86, 98, 102, 86,
+ 86, 91, 91, 93, 91, 94, 94, 91, 101, 104,
+ 102, 94, 101, 110, 99, 98, 100, 100, 100, 100,
+ 100, 103, 103, 100, 100, 343, 105, 103, 105, 107,
+ 109, 107, 111, 110, 109, 113, 113, 341, 121, 118,
+ 111, 112, 112, 112, 112, 112, 121, 113, 112, 112,
+ 114, 114, 116, 116, 118, 116, 114, 115, 115, 115,
+ 115, 115, 123, 123, 115, 115, 117, 117, 117, 117,
+ 117, 124, 122, 117, 117, 119, 122, 119, 120, 120,
+
+ 120, 120, 120, 125, 130, 120, 120, 125, 131, 124,
+ 126, 126, 128, 128, 131, 134, 126, 130, 128, 133,
+ 133, 133, 135, 136, 133, 139, 164, 140, 138, 140,
+ 134, 164, 133, 141, 141, 163, 163, 338, 139, 141,
+ 136, 135, 137, 137, 137, 137, 137, 138, 336, 137,
+ 137, 143, 143, 145, 145, 146, 146, 143, 147, 147,
+ 149, 149, 145, 155, 147, 161, 149, 151, 151, 153,
+ 153, 146, 160, 151, 270, 153, 176, 156, 156, 158,
+ 158, 176, 155, 156, 161, 158, 165, 165, 170, 270,
+ 160, 170, 165, 172, 172, 173, 173, 174, 174, 175,
+
+ 208, 177, 220, 175, 177, 178, 178, 173, 220, 174,
+ 208, 178, 180, 180, 172, 182, 182, 183, 180, 334,
+ 190, 190, 183, 184, 184, 184, 184, 184, 185, 185,
+ 184, 184, 190, 243, 185, 191, 191, 192, 192, 197,
+ 197, 202, 202, 192, 332, 197, 203, 203, 209, 209,
+ 213, 213, 203, 214, 214, 215, 215, 243, 216, 216,
+ 217, 217, 218, 218, 219, 219, 221, 221, 215, 235,
+ 219, 235, 221, 214, 216, 217, 227, 227, 228, 228,
+ 230, 230, 232, 331, 228, 233, 230, 233, 233, 329,
+ 232, 232, 236, 236, 241, 241, 244, 244, 245, 245,
+
+ 241, 246, 246, 247, 248, 248, 267, 267, 244, 259,
+ 259, 247, 247, 252, 252, 245, 248, 326, 246, 252,
+ 253, 253, 267, 324, 259, 316, 253, 262, 262, 262,
+ 262, 262, 271, 271, 262, 262, 272, 276, 273, 272,
+ 272, 273, 273, 277, 278, 316, 276, 271, 281, 281,
+ 299, 278, 278, 282, 282, 285, 285, 277, 300, 287,
+ 287, 285, 290, 290, 281, 287, 323, 293, 294, 294,
+ 290, 293, 303, 299, 301, 301, 302, 302, 310, 310,
+ 303, 303, 300, 317, 302, 294, 304, 304, 322, 328,
+ 301, 309, 304, 311, 309, 309, 311, 311, 318, 317,
+
+ 318, 318, 319, 321, 314, 319, 319, 328, 330, 330,
+ 350, 330, 340, 340, 340, 312, 297, 296, 350, 350,
+ 355, 355, 355, 355, 356, 356, 356, 357, 357, 357,
+ 357, 358, 358, 358, 358, 359, 295, 359, 359, 360,
+ 360, 360, 360, 361, 291, 361, 361, 362, 362, 362,
+ 362, 363, 363, 283, 363, 364, 364, 364, 364, 365,
+ 279, 365, 365, 366, 366, 366, 366, 367, 367, 367,
+ 367, 368, 368, 368, 368, 369, 369, 369, 369, 370,
+ 370, 370, 370, 371, 371, 371, 371, 372, 274, 372,
+ 372, 373, 373, 373, 373, 374, 374, 374, 374, 375,
+
+ 268, 375, 375, 376, 376, 376, 376, 377, 265, 377,
+ 377, 378, 378, 378, 378, 379, 263, 379, 379, 380,
+ 380, 380, 380, 381, 260, 381, 381, 382, 382, 382,
+ 382, 383, 250, 383, 383, 384, 384, 384, 384, 385,
+ 242, 385, 385, 386, 386, 386, 386, 387, 239, 387,
+ 387, 388, 237, 388, 388, 389, 234, 389, 389, 390,
+ 226, 390, 390, 391, 391, 391, 391, 392, 392, 392,
+ 392, 393, 212, 393, 393, 394, 394, 394, 394, 395,
+ 395, 395, 395, 396, 210, 396, 396, 397, 397, 397,
+ 397, 398, 398, 398, 398, 399, 399, 399, 399, 400,
+
+ 400, 400, 400, 401, 401, 401, 401, 402, 402, 402,
+ 402, 403, 162, 403, 403, 404, 404, 404, 404, 405,
+ 405, 405, 405, 406, 108, 406, 406, 407, 407, 407,
+ 407, 408, 408, 408, 408, 409, 409, 409, 409, 410,
+ 106, 410, 410, 411, 411, 411, 411, 412, 412, 412,
+ 412, 413, 69, 413, 413, 414, 414, 414, 414, 415,
+ 415, 415, 415, 416, 416, 416, 416, 417, 417, 417,
+ 417, 418, 418, 418, 418, 419, 419, 419, 419, 420,
+ 420, 420, 420, 421, 421, 421, 421, 422, 422, 422,
+ 422, 423, 423, 423, 423, 36, 29, 25, 23, 17,
+
+ 6, 5, 4, 3, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354
+ } ;
+
+#define YY_TRAILING_MASK 0x2000
+#define YY_TRAILING_HEAD_MASK 0x4000
+#define REJECT \
+{ \
+*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ \
+yy_cp = yyg->yy_full_match; /* restore poss. backed-over text */ \
+yyg->yy_lp = yyg->yy_full_lp; /* restore orig. accepting pos. */ \
+yyg->yy_state_ptr = yyg->yy_full_state; /* restore orig. state */ \
+yy_current_state = *yyg->yy_state_ptr; /* restore curr. state */ \
+++yyg->yy_lp; \
+goto find_rule; \
+}
+
+#define yymore() (yyg->yy_more_flag = 1)
+#define YY_MORE_ADJ yyg->yy_more_len
+#define YY_RESTORE_YY_MORE_OFFSET
+#line 1 "libxlu_disk_l.l"
+/* -*- fundamental -*- */
+/*
+ * libxlu_disk_l.l - parser for disk specification strings
+ *
+ * Copyright (C) 2011 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+/*
+ * Parsing the old xm/xend/xl-4.1 disk specs is a tricky problem,
+ * because the target string might in theory contain "," which is the
+ * delimiter we use for stripping off things on the RHS, and ":",
+ * which is the delimiter we use for stripping off things on the LHS.
+ *
+ * In this parser we do not support such target strings in the old
+ * syntax; if the target string has to contain "," or ":" the new
+ * syntax's "target=" should be used.
+ */
+
+#line 35 "libxlu_disk_l.l"
+#include "libxlu_disk_i.h"
+
+#define YY_NO_INPUT
+
+/* The code generated by flex is missing braces in single line expressions and
+ * is not properly indented, which triggers the clang misleading-indentation
+ * check that has been made part of -Wall since clang 10. In order to safely
+ * disable it on clang versions that don't have the diagnostic implemented
+ * also disable the unknown option and pragma warning. */
+#ifdef __clang__
+# pragma clang diagnostic ignored "-Wunknown-pragmas"
+# pragma clang diagnostic ignored "-Wunknown-warning-option"
+# pragma clang diagnostic ignored "-Wmisleading-indentation"
+#endif
+
+/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
+ * it to fail to declare these functions, which it defines. So declare
+ * them ourselves. Hopefully we won't have to simultaneously support
+ * a flex version which declares these differently somehow. */
+int xlu__disk_yyget_column(yyscan_t yyscanner);
+void xlu__disk_yyset_column(int column_no, yyscan_t yyscanner);
+
+
+/*----- useful macros and functions used in actions -----
+ * we use macros in the actual rules to keep the actions short
+ * and particularly to avoid repeating boilerplate values such as
+ * DPC->disk, yytext, etc. */
+
+/* Sets an enum, checking it hasn't already been set to a different value */
+#define DSET(dpc,member,enumname,str,valname) do{ \
+ if (dpc->disk->member != LIBXL_DISK_##enumname##_UNKNOWN && \
+ dpc->disk->member != LIBXL_DISK_##enumname##_##valname) { \
+ xlu__disk_err(dpc, str, TOSTRING(member) " respecified"); \
+ } else { \
+ dpc->disk->member = LIBXL_DISK_##enumname##_##valname; \
+ } \
+ }while(0)
+
+/* For actions whose patterns contain '=', finds the start of the value */
+#define FROMEQUALS (strchr(yytext,'=')+1)
+
+/* Chops the delimiter off, modifying yytext and yyleng. */
+#define STRIP(delim) do{ \
+ if (yyleng>0 && yytext[yyleng-1]==(delim)) \
+ yytext[--yyleng] = 0; \
+ }while(0)
+
+/* Sets a string value, checking it hasn't been set already. */
+#define SAVESTRING(what,loc,val) do{ \
+ savestring(DPC, what " respecified", &DPC->disk->loc, (val)); \
+ }while(0)
+static void savestring(DiskParseContext *dpc, const char *what_respecified,
+ char **update, const char *value) {
+ if (*update) {
+ if (**update) { xlu__disk_err(dpc,value,what_respecified); return; }
+ free(*update); /* do not complain about overwriting empty strings */
+ }
+ *update = strdup(value);
+}
+
+#define DPC dpc /* our convention in lexer helper functions */
+
+/* Sets ->readwrite from the string. This ought to be an enum, perhaps. */
+static void setaccess(DiskParseContext *dpc, const char *str) {
+ if (!strcmp(str, "r") || !strcmp(str, "ro")) {
+ dpc->disk->readwrite = 0;
+ } else if (!strcmp(str, "rw") || !strcmp(str, "w") || !strcmp(str,"")) {
+ dpc->disk->readwrite = 1;
+ } else {
+ xlu__disk_err(dpc,str,"unknown value for access");
+ }
+}
+
+/* Sets ->format from the string. IDL should provide something for this. */
+static void setformat(DiskParseContext *dpc, const char *str) {
+ if (!strcmp(str,"")) DSET(dpc,format,FORMAT,str,RAW);
+ else if (!strcmp(str,"raw")) DSET(dpc,format,FORMAT,str,RAW);
+ else if (!strcmp(str,"qcow")) DSET(dpc,format,FORMAT,str,QCOW);
+ else if (!strcmp(str,"qcow2")) DSET(dpc,format,FORMAT,str,QCOW2);
+ else if (!strcmp(str,"vhd")) DSET(dpc,format,FORMAT,str,VHD);
+ else if (!strcmp(str,"empty")) DSET(dpc,format,FORMAT,str,EMPTY);
+ else if (!strcmp(str,"qed")) DSET(dpc,format,FORMAT,str,QED);
+ else xlu__disk_err(dpc,str,"unknown value for format");
+}
+
+/* Sets ->backend from the string. IDL should provide something for this. */
+static void setbackendtype(DiskParseContext *dpc, const char *str) {
+ if ( !strcmp(str,"phy")) DSET(dpc,backend,BACKEND,str,PHY);
+ else if (!strcmp(str,"tap")) DSET(dpc,backend,BACKEND,str,TAP);
+ else if (!strcmp(str,"qdisk")) DSET(dpc,backend,BACKEND,str,QDISK);
+ else xlu__disk_err(dpc,str,"unknown value for backendtype");
+}
+
+/* Sets ->colo-port from the string. COLO need this. */
+static void setcoloport(DiskParseContext *dpc, const char *str) {
+ int port = atoi(str);
+ if (port) {
+ dpc->disk->colo_port = port;
+ } else {
+ xlu__disk_err(dpc,str,"unknown value for colo_port");
+ }
+}
+
+#define DEPRECATE(usewhatinstead) /* not currently reported */
+
+/* Handles a vdev positional parameter which includes a devtype. */
+static int vdev_and_devtype(DiskParseContext *dpc, char *str) {
+ /* returns 1 if it was <vdev>:<devtype>, 0 (doing nothing) otherwise */
+ char *colon = strrchr(str, ':');
+ if (!colon)
+ return 0;
+
+ DEPRECATE("use `devtype=...'");
+ *colon++ = 0;
+ SAVESTRING("vdev", vdev, str);
+
+ if (!strcmp(colon,"cdrom")) {
+ DPC->disk->is_cdrom = 1;
+ } else if (!strcmp(colon,"disk")) {
+ DPC->disk->is_cdrom = 0;
+ } else {
+ xlu__disk_err(DPC,colon,"unknown deprecated type");
+ }
+ return 1;
+}
+
+#undef DPC /* needs to be defined differently the actual lexer */
+#define DPC ((DiskParseContext*)yyextra)
+
+#line 1202 "libxlu_disk_l.c"
+
+#line 1204 "libxlu_disk_l.c"
+
+#define INITIAL 0
+#define LEXERR 1
+
+#ifndef YY_NO_UNISTD_H
+/* 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>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+ {
+
+ /* User-defined. Not touched by flex. */
+ YY_EXTRA_TYPE yyextra_r;
+
+ /* The rest are the same as the globals declared in the non-reentrant scanner. */
+ FILE *yyin_r, *yyout_r;
+ size_t yy_buffer_stack_top; /**< index of top of stack. */
+ size_t yy_buffer_stack_max; /**< capacity of stack. */
+ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+ char yy_hold_char;
+ int yy_n_chars;
+ int yyleng_r;
+ char *yy_c_buf_p;
+ int yy_init;
+ int yy_start;
+ int yy_did_buffer_switch_on_eof;
+ int yy_start_stack_ptr;
+ int yy_start_stack_depth;
+ int *yy_start_stack;
+ yy_state_type yy_last_accepting_state;
+ char* yy_last_accepting_cpos;
+
+ int yylineno_r;
+ int yy_flex_debug_r;
+
+ yy_state_type *yy_state_buf;
+ yy_state_type *yy_state_ptr;
+ char *yy_full_match;
+ int yy_lp;
+
+ /* These are only needed for trailing context rules,
+ * but there's no conditional variable for that yet. */
+ int yy_looking_for_trail_begin;
+ int yy_full_lp;
+ int *yy_full_state;
+
+ char *yytext_r;
+ int yy_more_flag;
+ int yy_more_len;
+
+ }; /* end struct yyguts_t */
+
+static int yy_init_globals ( yyscan_t yyscanner );
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+ These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
+
+ int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput ( yyscan_t yyscanner );
+#else
+static int input ( yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#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 do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#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) \
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+ { \
+ int c = '*'; \
+ int n; \
+ for ( n = 0; n < max_size && \
+ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+ buf[n] = (char) c; \
+ if ( c == '\n' ) \
+ buf[n++] = (char) c; \
+ if ( c == EOF && ferror( yyin ) ) \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ result = n; \
+ } \
+ else \
+ { \
+ errno=0; \
+ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+ { \
+ if( errno != EINTR) \
+ { \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ break; \
+ } \
+ errno=0; \
+ clearerr(yyin); \
+ } \
+ }\
+\
+
+#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 , yyscanner)
+#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 yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * 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 /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+ YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+ yy_state_type yy_current_state;
+ char *yy_cp, *yy_bp;
+ int yy_act;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if ( !yyg->yy_init )
+ {
+ yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+ YY_USER_INIT;
+#endif
+
+ /* Create the reject buffer large enough to save one state per allowed character. */
+ if ( ! yyg->yy_state_buf )
+ yyg->yy_state_buf = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE , yyscanner);
+ if ( ! yyg->yy_state_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
+
+ if ( ! yyg->yy_start )
+ yyg->yy_start = 1; /* first start state */
+
+ if ( ! yyin )
+ yyin = stdin;
+
+ if ( ! yyout )
+ yyout = stdout;
+
+ if ( ! YY_CURRENT_BUFFER ) {
+ yyensure_buffer_stack (yyscanner);
+ YY_CURRENT_BUFFER_LVALUE =
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+ }
+
+ yy_load_buffer_state( yyscanner );
+ }
+
+ {
+#line 177 "libxlu_disk_l.l"
+
+
+#line 180 "libxlu_disk_l.l"
+ /*----- the scanner rules which do the parsing -----*/
+
+#line 1486 "libxlu_disk_l.c"
+
+ while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
+ {
+ yyg->yy_more_len = 0;
+ if ( yyg->yy_more_flag )
+ {
+ yyg->yy_more_len = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+ yyg->yy_more_flag = 0;
+ }
+ yy_cp = yyg->yy_c_buf_p;
+
+ /* Support of yytext. */
+ *yy_cp = yyg->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 = yyg->yy_start;
+
+ yyg->yy_state_ptr = yyg->yy_state_buf;
+ *yyg->yy_state_ptr++ = yy_current_state;
+
+yy_match:
+ do
+ {
+ YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 355 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ *yyg->yy_state_ptr++ = yy_current_state;
+ ++yy_cp;
+ }
+ while ( yy_current_state != 354 );
+
+yy_find_action:
+ yy_current_state = *--yyg->yy_state_ptr;
+ yyg->yy_lp = yy_accept[yy_current_state];
+find_rule: /* we branch to this label when backing up */
+ for ( ; ; ) /* until we find what rule we matched */
+ {
+ if ( yyg->yy_lp && yyg->yy_lp < yy_accept[yy_current_state + 1] )
+ {
+ yy_act = yy_acclist[yyg->yy_lp];
+ if ( yy_act & YY_TRAILING_HEAD_MASK ||
+ yyg->yy_looking_for_trail_begin )
+ {
+ if ( yy_act == yyg->yy_looking_for_trail_begin )
+ {
+ yyg->yy_looking_for_trail_begin = 0;
+ yy_act &= ~YY_TRAILING_HEAD_MASK;
+ break;
+ }
+ }
+ else if ( yy_act & YY_TRAILING_MASK )
+ {
+ yyg->yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
+ yyg->yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
+ }
+ else
+ {
+ yyg->yy_full_match = yy_cp;
+ yyg->yy_full_state = yyg->yy_state_ptr;
+ yyg->yy_full_lp = yyg->yy_lp;
+ break;
+ }
+ ++yyg->yy_lp;
+ goto find_rule;
+ }
+ --yy_cp;
+ yy_current_state = *--yyg->yy_state_ptr;
+ yyg->yy_lp = 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
+#line 182 "libxlu_disk_l.l"
+{ /* ignore whitespace before parameters */ }
+ YY_BREAK
+/* ordinary parameters setting enums or strings */
+case 2:
+/* rule 2 can match eol */
+YY_RULE_SETUP
+#line 186 "libxlu_disk_l.l"
+{ STRIP(','); setformat(DPC, FROMEQUALS); }
+ YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 188 "libxlu_disk_l.l"
+{ DPC->disk->is_cdrom = 1; }
+ YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 189 "libxlu_disk_l.l"
+{ DPC->disk->is_cdrom = 1; }
+ YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 190 "libxlu_disk_l.l"
+{ DPC->disk->is_cdrom = 0; }
+ YY_BREAK
+case 6:
+/* rule 6 can match eol */
+YY_RULE_SETUP
+#line 191 "libxlu_disk_l.l"
+{ xlu__disk_err(DPC,yytext,"unknown value for type"); }
+ YY_BREAK
+case 7:
+/* rule 7 can match eol */
+YY_RULE_SETUP
+#line 193 "libxlu_disk_l.l"
+{ STRIP(','); setaccess(DPC, FROMEQUALS); }
+ YY_BREAK
+case 8:
+/* rule 8 can match eol */
+YY_RULE_SETUP
+#line 194 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("backend", backend_domname, FROMEQUALS); }
+ YY_BREAK
+case 9:
+/* rule 9 can match eol */
+YY_RULE_SETUP
+#line 195 "libxlu_disk_l.l"
+{ STRIP(','); setbackendtype(DPC,FROMEQUALS); }
+ YY_BREAK
+case 10:
+/* rule 10 can match eol */
+YY_RULE_SETUP
+#line 197 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("vdev", vdev, FROMEQUALS); }
+ YY_BREAK
+case 11:
+/* rule 11 can match eol */
+YY_RULE_SETUP
+#line 198 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("script", script, FROMEQUALS); }
+ YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 199 "libxlu_disk_l.l"
+{ DPC->disk->direct_io_safe = 1; }
+ YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 200 "libxlu_disk_l.l"
+{ libxl_defbool_set(&DPC->disk->discard_enable, true); }
+ YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 201 "libxlu_disk_l.l"
+{ libxl_defbool_set(&DPC->disk->discard_enable, false); }
+ YY_BREAK
+/* Note that the COLO configuration settings should be considered unstable.
+ * They may change incompatibly in future versions of Xen. */
+case 15:
+YY_RULE_SETUP
+#line 204 "libxlu_disk_l.l"
+{ libxl_defbool_set(&DPC->disk->colo_enable, true); }
+ YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 205 "libxlu_disk_l.l"
+{ libxl_defbool_set(&DPC->disk->colo_enable, false); }
+ YY_BREAK
+case 17:
+/* rule 17 can match eol */
+YY_RULE_SETUP
+#line 206 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("colo-host", colo_host, FROMEQUALS); }
+ YY_BREAK
+case 18:
+/* rule 18 can match eol */
+YY_RULE_SETUP
+#line 207 "libxlu_disk_l.l"
+{ STRIP(','); setcoloport(DPC, FROMEQUALS); }
+ YY_BREAK
+case 19:
+/* rule 19 can match eol */
+YY_RULE_SETUP
+#line 208 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("colo-export", colo_export, FROMEQUALS); }
+ YY_BREAK
+case 20:
+/* rule 20 can match eol */
+YY_RULE_SETUP
+#line 209 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("active-disk", active_disk, FROMEQUALS); }
+ YY_BREAK
+case 21:
+/* rule 21 can match eol */
+YY_RULE_SETUP
+#line 210 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("hidden-disk", hidden_disk, FROMEQUALS); }
+ YY_BREAK
+/* the target magic parameter, eats the rest of the string */
+case 22:
+YY_RULE_SETUP
+#line 214 "libxlu_disk_l.l"
+{ STRIP(','); SAVESTRING("target", pdev_path, FROMEQUALS); }
+ YY_BREAK
+/* unknown parameters */
+case 23:
+/* rule 23 can match eol */
+YY_RULE_SETUP
+#line 218 "libxlu_disk_l.l"
+{ xlu__disk_err(DPC,yytext,"unknown parameter"); }
+ YY_BREAK
+/* deprecated prefixes */
+/* the "/.*" in these patterns ensures that they count as if they
+ * matched the whole string, so these patterns take precedence */
+case 24:
+YY_RULE_SETUP
+#line 225 "libxlu_disk_l.l"
+{
+ STRIP(':');
+ DPC->had_depr_prefix=1; DEPRECATE("use `[format=]...,'");
+ setformat(DPC, yytext);
+ }
+ YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 231 "libxlu_disk_l.l"
+{
+ char *newscript;
+ STRIP(':');
+ DPC->had_depr_prefix=1; DEPRECATE("use `script=...'");
+ if (asprintf(&newscript, "block-%s", yytext) < 0) {
+ xlu__disk_err(DPC,yytext,"unable to format script");
+ return 0;
+ }
+ savestring(DPC, "script respecified",
+ &DPC->disk->script, newscript);
+ free(newscript);
+ }
+ YY_BREAK
+case 26:
+*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
+yyg->yy_c_buf_p = yy_cp = yy_bp + 8;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 244 "libxlu_disk_l.l"
+{ DPC->had_depr_prefix=1; DEPRECATE(0); }
+ YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 245 "libxlu_disk_l.l"
+{ DPC->had_depr_prefix=1; DEPRECATE(0); }
+ YY_BREAK
+case 28:
+*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
+yyg->yy_c_buf_p = yy_cp = yy_bp + 4;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 246 "libxlu_disk_l.l"
+{ DPC->had_depr_prefix=1; DEPRECATE(0); }
+ YY_BREAK
+case 29:
+*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
+yyg->yy_c_buf_p = yy_cp = yy_bp + 6;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 247 "libxlu_disk_l.l"
+{ DPC->had_depr_prefix=1; DEPRECATE(0); }
+ YY_BREAK
+case 30:
+*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
+yyg->yy_c_buf_p = yy_cp = yy_bp + 5;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 248 "libxlu_disk_l.l"
+{ DPC->had_depr_prefix=1; DEPRECATE(0); }
+ YY_BREAK
+case 31:
+*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
+yyg->yy_c_buf_p = yy_cp = yy_bp + 4;
+YY_DO_BEFORE_ACTION; /* set up yytext again */
+YY_RULE_SETUP
+#line 249 "libxlu_disk_l.l"
+{ DPC->had_depr_prefix=1; DEPRECATE(0); }
+ YY_BREAK
+case 32:
+/* rule 32 can match eol */
+YY_RULE_SETUP
+#line 251 "libxlu_disk_l.l"
+{
+ xlu__disk_err(DPC,yytext,"unknown deprecated disk prefix");
+ return 0;
+ }
+ YY_BREAK
+/* positional parameters */
+case 33:
+/* rule 33 can match eol */
+YY_RULE_SETUP
+#line 258 "libxlu_disk_l.l"
+{
+ STRIP(',');
+
+ if (DPC->err) {
+ /* previous errors may just lead to subsequent ones */
+ } else if (!DPC->disk->pdev_path) {
+ SAVESTRING("target", pdev_path, yytext);
+ } else if (!DPC->had_depr_prefix &&
+ DPC->disk->format == LIBXL_DISK_FORMAT_UNKNOWN) {
+ if (!*DPC->disk->pdev_path && vdev_and_devtype(DPC,yytext)) {
+ DPC->disk->format = LIBXL_DISK_FORMAT_EMPTY;
+ } else {
+ setformat(DPC,yytext);
+ }
+ } else if (!DPC->disk->vdev) {
+ if (!vdev_and_devtype(DPC,yytext))
+ SAVESTRING("vdev", vdev, yytext);
+ } else if (!DPC->access_set) {
+ DPC->access_set = 1;
+ setaccess(DPC,yytext);
+ } else {
+ xlu__disk_err(DPC,yytext,"too many positional parameters");
+ return 0; /* don't print any more errors */
+ }
+}
+ YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 284 "libxlu_disk_l.l"
+{
+ BEGIN(LEXERR);
+ yymore();
+}
+ YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 288 "libxlu_disk_l.l"
+{
+ xlu__disk_err(DPC,yytext,"bad disk syntax"); return 0;
+}
+ YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 291 "libxlu_disk_l.l"
+YY_FATAL_ERROR( "flex scanner jammed" );
+ YY_BREAK
+#line 1839 "libxlu_disk_l.c"
+ case YY_STATE_EOF(INITIAL):
+ case YY_STATE_EOF(LEXERR):
+ yyterminate();
+
+ case YY_END_OF_BUFFER:
+ {
+ /* Amount of text matched not including the EOB char. */
+ int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+ /* Undo the effects of YY_DO_BEFORE_ACTION. */
+ *yy_cp = yyg->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 yyin at a new source and called
+ * yylex(). 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.
+ */
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+ 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 ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+ { /* This was really a NUL. */
+ yy_state_type yy_next_state;
+
+ yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ /* 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 , yyscanner);
+
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+ if ( yy_next_state )
+ {
+ /* Consume the NUL. */
+ yy_cp = ++yyg->yy_c_buf_p;
+ yy_current_state = yy_next_state;
+ goto yy_match;
+ }
+
+ else
+ {
+ yy_cp = yyg->yy_c_buf_p;
+ goto yy_find_action;
+ }
+ }
+
+ else switch ( yy_get_next_buffer( yyscanner ) )
+ {
+ case EOB_ACT_END_OF_FILE:
+ {
+ yyg->yy_did_buffer_switch_on_eof = 0;
+
+ if ( yywrap( yyscanner ) )
+ {
+ /* Note: because we've taken care in
+ * yy_get_next_buffer() to have set up
+ * yytext, 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.
+ */
+ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+ yy_act = YY_STATE_EOF(YY_START);
+ goto do_action;
+ }
+
+ else
+ {
+ if ( ! yyg->yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+ }
+ break;
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yyg->yy_c_buf_p =
+ yyg->yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ yy_cp = yyg->yy_c_buf_p;
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+ goto yy_match;
+
+ case EOB_ACT_LAST_MATCH:
+ yyg->yy_c_buf_p =
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ yy_cp = yyg->yy_c_buf_p;
+ yy_bp = yyg->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 user's declarations */
+} /* end of yylex */
+
+/* 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 (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+ char *source = yyg->yytext_ptr;
+ int number_to_move, i;
+ int ret_val;
+
+ if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->yy_n_chars = 0;
+
+ else
+ {
+ int 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. */
+
+ YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+
+ }
+
+ 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]),
+ yyg->yy_n_chars, num_to_read );
+
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ if ( yyg->yy_n_chars == 0 )
+ {
+ if ( number_to_move == YY_MORE_ADJ )
+ {
+ ret_val = EOB_ACT_END_OF_FILE;
+ yyrestart( yyin , yyscanner);
+ }
+
+ 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;
+
+ if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+ /* Extend the array by 50%, plus the number we really need. */
+ int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+ (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
+ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+ /* "- 2" to take care of EOB's */
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+ }
+
+ yyg->yy_n_chars += number_to_move;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+ yyg->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 (yyscan_t yyscanner)
+{
+ yy_state_type yy_current_state;
+ char *yy_cp;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ yy_current_state = yyg->yy_start;
+
+ yyg->yy_state_ptr = yyg->yy_state_buf;
+ *yyg->yy_state_ptr++ = yy_current_state;
+
+ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+ {
+ YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 355 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ *yyg->yy_state_ptr++ = yy_current_state;
+ }
+
+ 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 , yyscan_t yyscanner)
+{
+ int yy_is_jam;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+
+ YY_CHAR yy_c = 1;
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 355 )
+ yy_c = yy_meta[yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+ yy_is_jam = (yy_current_state == 354);
+ if ( ! yy_is_jam )
+ *yyg->yy_state_ptr++ = yy_current_state;
+
+ (void)yyg;
+ return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+ static int yyinput (yyscan_t yyscanner)
+#else
+ static int input (yyscan_t yyscanner)
+#endif
+
+{
+ int c;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+ if ( *yyg->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 ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+ /* This was really a NUL. */
+ *yyg->yy_c_buf_p = '\0';
+
+ else
+ { /* need more input */
+ int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
+ ++yyg->yy_c_buf_p;
+
+ switch ( yy_get_next_buffer( yyscanner ) )
+ {
+ 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. */
+ yyrestart( yyin , yyscanner);
+
+ /*FALLTHROUGH*/
+
+ case EOB_ACT_END_OF_FILE:
+ {
+ if ( yywrap( yyscanner ) )
+ return 0;
+
+ if ( ! yyg->yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+#ifdef __cplusplus
+ return yyinput(yyscanner);
+#else
+ return input(yyscanner);
+#endif
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+ break;
+ }
+ }
+ }
+
+ c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
+ *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
+ yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+ return c;
+}
+#endif /* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+ void yyrestart (FILE * input_file , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if ( ! YY_CURRENT_BUFFER ){
+ yyensure_buffer_stack (yyscanner);
+ YY_CURRENT_BUFFER_LVALUE =
+ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
+ }
+
+ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
+ yy_load_buffer_state( yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* TODO. We should be able to replace this entire function body
+ * with
+ * yypop_buffer_state();
+ * yypush_buffer_state(new_buffer);
+ */
+ yyensure_buffer_stack (yyscanner);
+ if ( YY_CURRENT_BUFFER == new_buffer )
+ return;
+
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+ yy_load_buffer_state( yyscanner );
+
+ /* We don't actually know whether we did this switch during
+ * EOF (yywrap()) processing, but the only time this flag
+ * is looked at is after yywrap() is called, so it's safe
+ * to go ahead and always set it.
+ */
+ yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void yy_load_buffer_state (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+ yyg->yy_hold_char = *yyg->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.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
+{
+ YY_BUFFER_STATE b;
+
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_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 *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+ b->yy_is_our_buffer = 1;
+
+ yy_init_buffer( b, file , yyscanner);
+
+ return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * @param yyscanner The scanner object.
+ */
+ void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ 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 )
+ yyfree( (void *) b->yy_ch_buf , yyscanner );
+
+ yyfree( (void *) b , yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a yyrestart() or at EOF.
+ */
+ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
+
+{
+ int oerrno = errno;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ yy_flush_buffer( b , yyscanner);
+
+ b->yy_input_file = file;
+ b->yy_fill_buffer = 1;
+
+ /* If b is the current buffer, then yy_init_buffer was _probably_
+ * called from yyrestart() 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 = file ? (isatty( fileno(file) ) > 0) : 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.
+ * @param yyscanner The scanner object.
+ */
+ void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ 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 )
+ yy_load_buffer_state( yyscanner );
+}
+
+/** 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.
+ * @param yyscanner The scanner object.
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ if (new_buffer == NULL)
+ return;
+
+ yyensure_buffer_stack(yyscanner);
+
+ /* This block is copied from yy_switch_to_buffer. */
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ /* Only push if top exists. Otherwise, replace top. */
+ if (YY_CURRENT_BUFFER)
+ yyg->yy_buffer_stack_top++;
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+ /* copied from yy_switch_to_buffer. */
+ yy_load_buffer_state( yyscanner );
+ yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ * The next element becomes the new top.
+ * @param yyscanner The scanner object.
+ */
+void yypop_buffer_state (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ if (!YY_CURRENT_BUFFER)
+ return;
+
+ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ if (yyg->yy_buffer_stack_top > 0)
+ --yyg->yy_buffer_stack_top;
+
+ if (YY_CURRENT_BUFFER) {
+ yy_load_buffer_state( yyscanner );
+ yyg->yy_did_buffer_switch_on_eof = 1;
+ }
+}
+
+/* Allocates the stack if it does not exist.
+ * Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (yyscan_t yyscanner)
+{
+ yy_size_t num_to_alloc;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (!yyg->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; /* After all that talk, this was set to 1 anyways... */
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
+ (num_to_alloc * sizeof(struct yy_buffer_state*)
+ , yyscanner);
+ if ( ! yyg->yy_buffer_stack )
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+ memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+ yyg->yy_buffer_stack_max = num_to_alloc;
+ yyg->yy_buffer_stack_top = 0;
+ return;
+ }
+
+ if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+ /* Increase the buffer to prepare for a possible push. */
+ yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+ num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
+ (yyg->yy_buffer_stack,
+ num_to_alloc * sizeof(struct yy_buffer_state*)
+ , yyscanner);
+ if ( ! yyg->yy_buffer_stack )
+ YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
+
+ /* zero only the new slots.*/
+ memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
+ yyg->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
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
+{
+ 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 NULL;
+
+ b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+ b->yy_buf_size = (int) (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 = NULL;
+ 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;
+
+ yy_switch_to_buffer( b , yyscanner );
+
+ return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ * yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
+{
+
+ return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
+{
+ YY_BUFFER_STATE b;
+ char *buf;
+ yy_size_t n;
+ int i;
+
+ /* Get memory for full buffer, including space for trailing EOB's. */
+ n = (yy_size_t) (_yybytes_len + 2);
+ buf = (char *) yyalloc( n , yyscanner );
+ if ( ! buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+ for ( i = 0; i < _yybytes_len; ++i )
+ buf[i] = yybytes[i];
+
+ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+ b = yy_scan_buffer( buf, n , yyscanner);
+ if ( ! b )
+ YY_FATAL_ERROR( "bad buffer in yy_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 yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ 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 yytext. */ \
+ int yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ yytext[yyleng] = yyg->yy_hold_char; \
+ yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+ yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+ *yyg->yy_c_buf_p = '\0'; \
+ yyleng = yyless_macro_arg; \
+ } \
+ while ( 0 )
+
+/* Accessor methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_lineno (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (! YY_CURRENT_BUFFER)
+ return 0;
+
+ return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int yyget_column (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (! YY_CURRENT_BUFFER)
+ return 0;
+
+ return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_in (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *yyget_out (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int yyget_leng (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *yyget_text (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void yyset_lineno (int _line_number , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* lineno is only valid if an input buffer exists. */
+ if (! YY_CURRENT_BUFFER )
+ YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
+
+ yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void yyset_column (int _column_no , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* column is only valid if an input buffer exists. */
+ if (! YY_CURRENT_BUFFER )
+ YY_FATAL_ERROR( "yyset_column called with no buffer" );
+
+ yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE * _in_str , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyin = _in_str ;
+}
+
+void yyset_out (FILE * _out_str , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyout = _out_str ;
+}
+
+int yyget_debug (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yy_flex_debug;
+}
+
+void yyset_debug (int _bdebug , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* yylex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+int yylex_init(yyscan_t* ptr_yy_globals)
+{
+ if (ptr_yy_globals == NULL){
+ errno = EINVAL;
+ return 1;
+ }
+
+ *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
+
+ if (*ptr_yy_globals == NULL){
+ errno = ENOMEM;
+ return 1;
+ }
+
+ /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+ return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* yylex_init_extra has the same functionality as yylex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to yyalloc in
+ * the yyextra field.
+ */
+int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
+{
+ struct yyguts_t dummy_yyguts;
+
+ yyset_extra (yy_user_defined, &dummy_yyguts);
+
+ if (ptr_yy_globals == NULL){
+ errno = EINVAL;
+ return 1;
+ }
+
+ *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+ if (*ptr_yy_globals == NULL){
+ errno = ENOMEM;
+ return 1;
+ }
+
+ /* By setting to 0xAA, we expose bugs in
+ yy_init_globals. Leave at 0x00 for releases. */
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+ yyset_extra (yy_user_defined, *ptr_yy_globals);
+
+ return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ /* Initialization is the same as for the non-reentrant scanner.
+ * This function is called from yylex_destroy(), so don't allocate here.
+ */
+
+ yyg->yy_buffer_stack = NULL;
+ yyg->yy_buffer_stack_top = 0;
+ yyg->yy_buffer_stack_max = 0;
+ yyg->yy_c_buf_p = NULL;
+ yyg->yy_init = 0;
+ yyg->yy_start = 0;
+
+ yyg->yy_start_stack_ptr = 0;
+ yyg->yy_start_stack_depth = 0;
+ yyg->yy_start_stack = NULL;
+
+ yyg->yy_state_buf = 0;
+ yyg->yy_state_ptr = 0;
+ yyg->yy_full_match = 0;
+ yyg->yy_lp = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+ yyin = stdin;
+ yyout = stdout;
+#else
+ yyin = NULL;
+ yyout = NULL;
+#endif
+
+ /* For future reference: Set errno on error, since we are called by
+ * yylex_init()
+ */
+ return 0;
+}
+
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* Pop the buffer stack, destroying each element. */
+ while(YY_CURRENT_BUFFER){
+ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ yypop_buffer_state(yyscanner);
+ }
+
+ /* Destroy the stack itself. */
+ yyfree(yyg->yy_buffer_stack , yyscanner);
+ yyg->yy_buffer_stack = NULL;
+
+ /* Destroy the start condition stack. */
+ yyfree( yyg->yy_start_stack , yyscanner );
+ yyg->yy_start_stack = NULL;
+
+ yyfree ( yyg->yy_state_buf , yyscanner);
+ yyg->yy_state_buf = NULL;
+
+ /* Reset the globals. This is important in a non-reentrant scanner so the next time
+ * yylex() is called, initialization will occur. */
+ yy_init_globals( yyscanner);
+
+ /* Destroy the main struct (reentrant only). */
+ yyfree ( yyscanner , yyscanner );
+ yyscanner = NULL;
+ return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+
+ int i;
+ for ( i = 0; i < n; ++i )
+ s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
+{
+ int n;
+ for ( n = 0; s[n]; ++n )
+ ;
+
+ return n;
+}
+#endif
+
+void *yyalloc (yy_size_t size , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ return malloc(size);
+}
+
+void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+
+ /* 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 realloc(ptr, size);
+}
+
+void yyfree (void * ptr , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 291 "libxlu_disk_l.l"
--- /dev/null
+#ifndef xlu__disk_yyHEADER_H
+#define xlu__disk_yyHEADER_H 1
+#define xlu__disk_yyIN_HEADER 1
+
+#line 5 "libxlu_disk_l.h"
+#define _GNU_SOURCE
+
+#line 8 "libxlu_disk_l.h"
+
+#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 6
+#define YY_FLEX_SUBMINOR_VERSION 4
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+#ifdef yy_create_buffer
+#define xlu__disk_yy_create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer xlu__disk_yy_create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define xlu__disk_yy_delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer xlu__disk_yy_delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define xlu__disk_yy_scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer xlu__disk_yy_scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define xlu__disk_yy_scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string xlu__disk_yy_scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define xlu__disk_yy_scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes xlu__disk_yy_scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define xlu__disk_yy_init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer xlu__disk_yy_init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define xlu__disk_yy_flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer xlu__disk_yy_flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define xlu__disk_yy_load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state xlu__disk_yy_load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define xlu__disk_yy_switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer xlu__disk_yy_switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define xlu__disk_yypush_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state xlu__disk_yypush_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define xlu__disk_yypop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state xlu__disk_yypop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define xlu__disk_yyensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack xlu__disk_yyensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define xlu__disk_yylex_ALREADY_DEFINED
+#else
+#define yylex xlu__disk_yylex
+#endif
+
+#ifdef yyrestart
+#define xlu__disk_yyrestart_ALREADY_DEFINED
+#else
+#define yyrestart xlu__disk_yyrestart
+#endif
+
+#ifdef yylex_init
+#define xlu__disk_yylex_init_ALREADY_DEFINED
+#else
+#define yylex_init xlu__disk_yylex_init
+#endif
+
+#ifdef yylex_init_extra
+#define xlu__disk_yylex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra xlu__disk_yylex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define xlu__disk_yylex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy xlu__disk_yylex_destroy
+#endif
+
+#ifdef yyget_debug
+#define xlu__disk_yyget_debug_ALREADY_DEFINED
+#else
+#define yyget_debug xlu__disk_yyget_debug
+#endif
+
+#ifdef yyset_debug
+#define xlu__disk_yyset_debug_ALREADY_DEFINED
+#else
+#define yyset_debug xlu__disk_yyset_debug
+#endif
+
+#ifdef yyget_extra
+#define xlu__disk_yyget_extra_ALREADY_DEFINED
+#else
+#define yyget_extra xlu__disk_yyget_extra
+#endif
+
+#ifdef yyset_extra
+#define xlu__disk_yyset_extra_ALREADY_DEFINED
+#else
+#define yyset_extra xlu__disk_yyset_extra
+#endif
+
+#ifdef yyget_in
+#define xlu__disk_yyget_in_ALREADY_DEFINED
+#else
+#define yyget_in xlu__disk_yyget_in
+#endif
+
+#ifdef yyset_in
+#define xlu__disk_yyset_in_ALREADY_DEFINED
+#else
+#define yyset_in xlu__disk_yyset_in
+#endif
+
+#ifdef yyget_out
+#define xlu__disk_yyget_out_ALREADY_DEFINED
+#else
+#define yyget_out xlu__disk_yyget_out
+#endif
+
+#ifdef yyset_out
+#define xlu__disk_yyset_out_ALREADY_DEFINED
+#else
+#define yyset_out xlu__disk_yyset_out
+#endif
+
+#ifdef yyget_leng
+#define xlu__disk_yyget_leng_ALREADY_DEFINED
+#else
+#define yyget_leng xlu__disk_yyget_leng
+#endif
+
+#ifdef yyget_text
+#define xlu__disk_yyget_text_ALREADY_DEFINED
+#else
+#define yyget_text xlu__disk_yyget_text
+#endif
+
+#ifdef yyget_lineno
+#define xlu__disk_yyget_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno xlu__disk_yyget_lineno
+#endif
+
+#ifdef yyset_lineno
+#define xlu__disk_yyset_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno xlu__disk_yyset_lineno
+#endif
+
+#ifdef yyget_column
+#define xlu__disk_yyget_column_ALREADY_DEFINED
+#else
+#define yyget_column xlu__disk_yyget_column
+#endif
+
+#ifdef yyset_column
+#define xlu__disk_yyset_column_ALREADY_DEFINED
+#else
+#define yyset_column xlu__disk_yyset_column
+#endif
+
+#ifdef yywrap
+#define xlu__disk_yywrap_ALREADY_DEFINED
+#else
+#define yywrap xlu__disk_yywrap
+#endif
+
+#ifdef yyalloc
+#define xlu__disk_yyalloc_ALREADY_DEFINED
+#else
+#define yyalloc xlu__disk_yyalloc
+#endif
+
+#ifdef yyrealloc
+#define xlu__disk_yyrealloc_ALREADY_DEFINED
+#else
+#define yyrealloc xlu__disk_yyrealloc
+#endif
+
+#ifdef yyfree
+#define xlu__disk_yyfree_ALREADY_DEFINED
+#else
+#define yyfree xlu__disk_yyfree
+#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
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#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;
+
+/* 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
+
+#ifndef SIZE_MAX
+#define SIZE_MAX (~(size_t)0)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* begin standard C++ headers. */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+ are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t 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.
+ */
+ int 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;
+
+ };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+void yyrestart ( FILE *input_file , yyscan_t yyscanner );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
+void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
+void yypop_buffer_state ( yyscan_t yyscanner );
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
+
+void *yyalloc ( yy_size_t , yyscan_t yyscanner );
+void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
+void yyfree ( void * , yyscan_t yyscanner );
+
+#define xlu__disk_yywrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+#define yytext_ptr yytext_r
+
+#ifdef YY_HEADER_EXPORT_START_CONDITIONS
+#define INITIAL 0
+#define LEXERR 1
+
+#endif
+
+#ifndef YY_NO_UNISTD_H
+/* 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>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+int yylex_init (yyscan_t* scanner);
+
+int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
+
+/* Accessor methods to globals.
+ These are made visible to non-reentrant scanners for convenience. */
+
+int yylex_destroy ( yyscan_t yyscanner );
+
+int yyget_debug ( yyscan_t yyscanner );
+
+void yyset_debug ( int debug_flag , yyscan_t yyscanner );
+
+YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
+
+void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
+
+FILE *yyget_in ( yyscan_t yyscanner );
+
+void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
+
+FILE *yyget_out ( yyscan_t yyscanner );
+
+void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
+
+ int yyget_leng ( yyscan_t yyscanner );
+
+char *yyget_text ( yyscan_t yyscanner );
+
+int yyget_lineno ( yyscan_t yyscanner );
+
+void yyset_lineno ( int _line_number , yyscan_t yyscanner );
+
+int yyget_column ( yyscan_t yyscanner );
+
+void yyset_column ( int _column_no , yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap ( yyscan_t yyscanner );
+#else
+extern int yywrap ( yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* 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 yylex (yyscan_t yyscanner);
+
+#define YY_DECL int yylex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+#undef YY_NEW_FILE
+#undef YY_FLUSH_BUFFER
+#undef yy_set_bol
+#undef yy_new_buffer
+#undef yy_set_interactive
+#undef YY_DO_BEFORE_ACTION
+
+#ifdef YY_DECL_IS_OURS
+#undef YY_DECL_IS_OURS
+#undef YY_DECL
+#endif
+
+#ifndef xlu__disk_yy_create_buffer_ALREADY_DEFINED
+#undef yy_create_buffer
+#endif
+#ifndef xlu__disk_yy_delete_buffer_ALREADY_DEFINED
+#undef yy_delete_buffer
+#endif
+#ifndef xlu__disk_yy_scan_buffer_ALREADY_DEFINED
+#undef yy_scan_buffer
+#endif
+#ifndef xlu__disk_yy_scan_string_ALREADY_DEFINED
+#undef yy_scan_string
+#endif
+#ifndef xlu__disk_yy_scan_bytes_ALREADY_DEFINED
+#undef yy_scan_bytes
+#endif
+#ifndef xlu__disk_yy_init_buffer_ALREADY_DEFINED
+#undef yy_init_buffer
+#endif
+#ifndef xlu__disk_yy_flush_buffer_ALREADY_DEFINED
+#undef yy_flush_buffer
+#endif
+#ifndef xlu__disk_yy_load_buffer_state_ALREADY_DEFINED
+#undef yy_load_buffer_state
+#endif
+#ifndef xlu__disk_yy_switch_to_buffer_ALREADY_DEFINED
+#undef yy_switch_to_buffer
+#endif
+#ifndef xlu__disk_yypush_buffer_state_ALREADY_DEFINED
+#undef yypush_buffer_state
+#endif
+#ifndef xlu__disk_yypop_buffer_state_ALREADY_DEFINED
+#undef yypop_buffer_state
+#endif
+#ifndef xlu__disk_yyensure_buffer_stack_ALREADY_DEFINED
+#undef yyensure_buffer_stack
+#endif
+#ifndef xlu__disk_yylex_ALREADY_DEFINED
+#undef yylex
+#endif
+#ifndef xlu__disk_yyrestart_ALREADY_DEFINED
+#undef yyrestart
+#endif
+#ifndef xlu__disk_yylex_init_ALREADY_DEFINED
+#undef yylex_init
+#endif
+#ifndef xlu__disk_yylex_init_extra_ALREADY_DEFINED
+#undef yylex_init_extra
+#endif
+#ifndef xlu__disk_yylex_destroy_ALREADY_DEFINED
+#undef yylex_destroy
+#endif
+#ifndef xlu__disk_yyget_debug_ALREADY_DEFINED
+#undef yyget_debug
+#endif
+#ifndef xlu__disk_yyset_debug_ALREADY_DEFINED
+#undef yyset_debug
+#endif
+#ifndef xlu__disk_yyget_extra_ALREADY_DEFINED
+#undef yyget_extra
+#endif
+#ifndef xlu__disk_yyset_extra_ALREADY_DEFINED
+#undef yyset_extra
+#endif
+#ifndef xlu__disk_yyget_in_ALREADY_DEFINED
+#undef yyget_in
+#endif
+#ifndef xlu__disk_yyset_in_ALREADY_DEFINED
+#undef yyset_in
+#endif
+#ifndef xlu__disk_yyget_out_ALREADY_DEFINED
+#undef yyget_out
+#endif
+#ifndef xlu__disk_yyset_out_ALREADY_DEFINED
+#undef yyset_out
+#endif
+#ifndef xlu__disk_yyget_leng_ALREADY_DEFINED
+#undef yyget_leng
+#endif
+#ifndef xlu__disk_yyget_text_ALREADY_DEFINED
+#undef yyget_text
+#endif
+#ifndef xlu__disk_yyget_lineno_ALREADY_DEFINED
+#undef yyget_lineno
+#endif
+#ifndef xlu__disk_yyset_lineno_ALREADY_DEFINED
+#undef yyset_lineno
+#endif
+#ifndef xlu__disk_yyget_column_ALREADY_DEFINED
+#undef yyget_column
+#endif
+#ifndef xlu__disk_yyset_column_ALREADY_DEFINED
+#undef yyset_column
+#endif
+#ifndef xlu__disk_yywrap_ALREADY_DEFINED
+#undef yywrap
+#endif
+#ifndef xlu__disk_yyget_lval_ALREADY_DEFINED
+#undef yyget_lval
+#endif
+#ifndef xlu__disk_yyset_lval_ALREADY_DEFINED
+#undef yyset_lval
+#endif
+#ifndef xlu__disk_yyget_lloc_ALREADY_DEFINED
+#undef yyget_lloc
+#endif
+#ifndef xlu__disk_yyset_lloc_ALREADY_DEFINED
+#undef yyset_lloc
+#endif
+#ifndef xlu__disk_yyalloc_ALREADY_DEFINED
+#undef yyalloc
+#endif
+#ifndef xlu__disk_yyrealloc_ALREADY_DEFINED
+#undef yyrealloc
+#endif
+#ifndef xlu__disk_yyfree_ALREADY_DEFINED
+#undef yyfree
+#endif
+#ifndef xlu__disk_yytext_ALREADY_DEFINED
+#undef yytext
+#endif
+#ifndef xlu__disk_yyleng_ALREADY_DEFINED
+#undef yyleng
+#endif
+#ifndef xlu__disk_yyin_ALREADY_DEFINED
+#undef yyin
+#endif
+#ifndef xlu__disk_yyout_ALREADY_DEFINED
+#undef yyout
+#endif
+#ifndef xlu__disk_yy_flex_debug_ALREADY_DEFINED
+#undef yy_flex_debug
+#endif
+#ifndef xlu__disk_yylineno_ALREADY_DEFINED
+#undef yylineno
+#endif
+#ifndef xlu__disk_yytables_fload_ALREADY_DEFINED
+#undef yytables_fload
+#endif
+#ifndef xlu__disk_yytables_destroy_ALREADY_DEFINED
+#undef yytables_destroy
+#endif
+#ifndef xlu__disk_yyTABLES_NAME_ALREADY_DEFINED
+#undef yyTABLES_NAME
+#endif
+
+#line 291 "libxlu_disk_l.l"
+
+#line 699 "libxlu_disk_l.h"
+#undef xlu__disk_yyIN_HEADER
+#endif /* xlu__disk_yyHEADER_H */
--- /dev/null
+/* -*- fundamental -*- */
+/*
+ * libxlu_disk_l.l - parser for disk specification strings
+ *
+ * Copyright (C) 2011 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+/*
+ * Parsing the old xm/xend/xl-4.1 disk specs is a tricky problem,
+ * because the target string might in theory contain "," which is the
+ * delimiter we use for stripping off things on the RHS, and ":",
+ * which is the delimiter we use for stripping off things on the LHS.
+ *
+ * In this parser we do not support such target strings in the old
+ * syntax; if the target string has to contain "," or ":" the new
+ * syntax's "target=" should be used.
+ */
+
+%top{
+#define _GNU_SOURCE
+}
+
+%{
+#include "libxlu_disk_i.h"
+
+#define YY_NO_INPUT
+
+/* The code generated by flex is missing braces in single line expressions and
+ * is not properly indented, which triggers the clang misleading-indentation
+ * check that has been made part of -Wall since clang 10. In order to safely
+ * disable it on clang versions that don't have the diagnostic implemented
+ * also disable the unknown option and pragma warning. */
+#ifdef __clang__
+# pragma clang diagnostic ignored "-Wunknown-pragmas"
+# pragma clang diagnostic ignored "-Wunknown-warning-option"
+# pragma clang diagnostic ignored "-Wmisleading-indentation"
+#endif
+
+/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
+ * it to fail to declare these functions, which it defines. So declare
+ * them ourselves. Hopefully we won't have to simultaneously support
+ * a flex version which declares these differently somehow. */
+int xlu__disk_yyget_column(yyscan_t yyscanner);
+void xlu__disk_yyset_column(int column_no, yyscan_t yyscanner);
+
+
+/*----- useful macros and functions used in actions -----
+ * we use macros in the actual rules to keep the actions short
+ * and particularly to avoid repeating boilerplate values such as
+ * DPC->disk, yytext, etc. */
+
+/* Sets an enum, checking it hasn't already been set to a different value */
+#define DSET(dpc,member,enumname,str,valname) do{ \
+ if (dpc->disk->member != LIBXL_DISK_##enumname##_UNKNOWN && \
+ dpc->disk->member != LIBXL_DISK_##enumname##_##valname) { \
+ xlu__disk_err(dpc, str, TOSTRING(member) " respecified"); \
+ } else { \
+ dpc->disk->member = LIBXL_DISK_##enumname##_##valname; \
+ } \
+ }while(0)
+
+/* For actions whose patterns contain '=', finds the start of the value */
+#define FROMEQUALS (strchr(yytext,'=')+1)
+
+/* Chops the delimiter off, modifying yytext and yyleng. */
+#define STRIP(delim) do{ \
+ if (yyleng>0 && yytext[yyleng-1]==(delim)) \
+ yytext[--yyleng] = 0; \
+ }while(0)
+
+/* Sets a string value, checking it hasn't been set already. */
+#define SAVESTRING(what,loc,val) do{ \
+ savestring(DPC, what " respecified", &DPC->disk->loc, (val)); \
+ }while(0)
+static void savestring(DiskParseContext *dpc, const char *what_respecified,
+ char **update, const char *value) {
+ if (*update) {
+ if (**update) { xlu__disk_err(dpc,value,what_respecified); return; }
+ free(*update); /* do not complain about overwriting empty strings */
+ }
+ *update = strdup(value);
+}
+
+#define DPC dpc /* our convention in lexer helper functions */
+
+/* Sets ->readwrite from the string. This ought to be an enum, perhaps. */
+static void setaccess(DiskParseContext *dpc, const char *str) {
+ if (!strcmp(str, "r") || !strcmp(str, "ro")) {
+ dpc->disk->readwrite = 0;
+ } else if (!strcmp(str, "rw") || !strcmp(str, "w") || !strcmp(str,"")) {
+ dpc->disk->readwrite = 1;
+ } else {
+ xlu__disk_err(dpc,str,"unknown value for access");
+ }
+}
+
+/* Sets ->format from the string. IDL should provide something for this. */
+static void setformat(DiskParseContext *dpc, const char *str) {
+ if (!strcmp(str,"")) DSET(dpc,format,FORMAT,str,RAW);
+ else if (!strcmp(str,"raw")) DSET(dpc,format,FORMAT,str,RAW);
+ else if (!strcmp(str,"qcow")) DSET(dpc,format,FORMAT,str,QCOW);
+ else if (!strcmp(str,"qcow2")) DSET(dpc,format,FORMAT,str,QCOW2);
+ else if (!strcmp(str,"vhd")) DSET(dpc,format,FORMAT,str,VHD);
+ else if (!strcmp(str,"empty")) DSET(dpc,format,FORMAT,str,EMPTY);
+ else if (!strcmp(str,"qed")) DSET(dpc,format,FORMAT,str,QED);
+ else xlu__disk_err(dpc,str,"unknown value for format");
+}
+
+/* Sets ->backend from the string. IDL should provide something for this. */
+static void setbackendtype(DiskParseContext *dpc, const char *str) {
+ if ( !strcmp(str,"phy")) DSET(dpc,backend,BACKEND,str,PHY);
+ else if (!strcmp(str,"tap")) DSET(dpc,backend,BACKEND,str,TAP);
+ else if (!strcmp(str,"qdisk")) DSET(dpc,backend,BACKEND,str,QDISK);
+ else xlu__disk_err(dpc,str,"unknown value for backendtype");
+}
+
+/* Sets ->colo-port from the string. COLO need this. */
+static void setcoloport(DiskParseContext *dpc, const char *str) {
+ int port = atoi(str);
+ if (port) {
+ dpc->disk->colo_port = port;
+ } else {
+ xlu__disk_err(dpc,str,"unknown value for colo_port");
+ }
+}
+
+#define DEPRECATE(usewhatinstead) /* not currently reported */
+
+/* Handles a vdev positional parameter which includes a devtype. */
+static int vdev_and_devtype(DiskParseContext *dpc, char *str) {
+ /* returns 1 if it was <vdev>:<devtype>, 0 (doing nothing) otherwise */
+ char *colon = strrchr(str, ':');
+ if (!colon)
+ return 0;
+
+ DEPRECATE("use `devtype=...'");
+ *colon++ = 0;
+ SAVESTRING("vdev", vdev, str);
+
+ if (!strcmp(colon,"cdrom")) {
+ DPC->disk->is_cdrom = 1;
+ } else if (!strcmp(colon,"disk")) {
+ DPC->disk->is_cdrom = 0;
+ } else {
+ xlu__disk_err(DPC,colon,"unknown deprecated type");
+ }
+ return 1;
+}
+
+#undef DPC /* needs to be defined differently the actual lexer */
+#define DPC ((DiskParseContext*)yyextra)
+
+%}
+
+%option warn
+%option nodefault
+%option batch
+%option 8bit
+%option noyywrap
+%option reentrant
+%option prefix="xlu__disk_yy"
+%option nounput
+
+%x LEXERR
+
+%%
+
+ /*----- the scanner rules which do the parsing -----*/
+
+[ \t\n]+/([^ \t\n].*)? { /* ignore whitespace before parameters */ }
+
+ /* ordinary parameters setting enums or strings */
+
+format=[^,]*,? { STRIP(','); setformat(DPC, FROMEQUALS); }
+
+cdrom,? { DPC->disk->is_cdrom = 1; }
+devtype=cdrom,? { DPC->disk->is_cdrom = 1; }
+devtype=disk,? { DPC->disk->is_cdrom = 0; }
+devtype=[^,]*,? { xlu__disk_err(DPC,yytext,"unknown value for type"); }
+
+access=[^,]*,? { STRIP(','); setaccess(DPC, FROMEQUALS); }
+backend=[^,]*,? { STRIP(','); SAVESTRING("backend", backend_domname, FROMEQUALS); }
+backendtype=[^,]*,? { STRIP(','); setbackendtype(DPC,FROMEQUALS); }
+
+vdev=[^,]*,? { STRIP(','); SAVESTRING("vdev", vdev, FROMEQUALS); }
+script=[^,]*,? { STRIP(','); SAVESTRING("script", script, FROMEQUALS); }
+direct-io-safe,? { DPC->disk->direct_io_safe = 1; }
+discard,? { libxl_defbool_set(&DPC->disk->discard_enable, true); }
+no-discard,? { libxl_defbool_set(&DPC->disk->discard_enable, false); }
+ /* Note that the COLO configuration settings should be considered unstable.
+ * They may change incompatibly in future versions of Xen. */
+colo,? { libxl_defbool_set(&DPC->disk->colo_enable, true); }
+no-colo,? { libxl_defbool_set(&DPC->disk->colo_enable, false); }
+colo-host=[^,]*,? { STRIP(','); SAVESTRING("colo-host", colo_host, FROMEQUALS); }
+colo-port=[^,]*,? { STRIP(','); setcoloport(DPC, FROMEQUALS); }
+colo-export=[^,]*,? { STRIP(','); SAVESTRING("colo-export", colo_export, FROMEQUALS); }
+active-disk=[^,]*,? { STRIP(','); SAVESTRING("active-disk", active_disk, FROMEQUALS); }
+hidden-disk=[^,]*,? { STRIP(','); SAVESTRING("hidden-disk", hidden_disk, FROMEQUALS); }
+
+ /* the target magic parameter, eats the rest of the string */
+
+target=.* { STRIP(','); SAVESTRING("target", pdev_path, FROMEQUALS); }
+
+ /* unknown parameters */
+
+[a-z][-a-z0-9]*=[^,],? { xlu__disk_err(DPC,yytext,"unknown parameter"); }
+
+ /* deprecated prefixes */
+
+ /* the "/.*" in these patterns ensures that they count as if they
+ * matched the whole string, so these patterns take precedence */
+
+(raw|qcow2?|vhd):/.* {
+ STRIP(':');
+ DPC->had_depr_prefix=1; DEPRECATE("use `[format=]...,'");
+ setformat(DPC, yytext);
+ }
+
+(iscsi|e?nbd|drbd):/.* {
+ char *newscript;
+ STRIP(':');
+ DPC->had_depr_prefix=1; DEPRECATE("use `script=...'");
+ if (asprintf(&newscript, "block-%s", yytext) < 0) {
+ xlu__disk_err(DPC,yytext,"unable to format script");
+ return 0;
+ }
+ savestring(DPC, "script respecified",
+ &DPC->disk->script, newscript);
+ free(newscript);
+ }
+
+tapdisk:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
+tap2?:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
+aio:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
+ioemu:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
+file:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
+phy:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
+
+[a-z][a-z0-9]*:/([^a-z0-9].*)? {
+ xlu__disk_err(DPC,yytext,"unknown deprecated disk prefix");
+ return 0;
+ }
+
+ /* positional parameters */
+
+[^=,]*,|[^=,]+,? {
+ STRIP(',');
+
+ if (DPC->err) {
+ /* previous errors may just lead to subsequent ones */
+ } else if (!DPC->disk->pdev_path) {
+ SAVESTRING("target", pdev_path, yytext);
+ } else if (!DPC->had_depr_prefix &&
+ DPC->disk->format == LIBXL_DISK_FORMAT_UNKNOWN) {
+ if (!*DPC->disk->pdev_path && vdev_and_devtype(DPC,yytext)) {
+ DPC->disk->format = LIBXL_DISK_FORMAT_EMPTY;
+ } else {
+ setformat(DPC,yytext);
+ }
+ } else if (!DPC->disk->vdev) {
+ if (!vdev_and_devtype(DPC,yytext))
+ SAVESTRING("vdev", vdev, yytext);
+ } else if (!DPC->access_set) {
+ DPC->access_set = 1;
+ setaccess(DPC,yytext);
+ } else {
+ xlu__disk_err(DPC,yytext,"too many positional parameters");
+ return 0; /* don't print any more errors */
+ }
+}
+
+. {
+ BEGIN(LEXERR);
+ yymore();
+}
+<LEXERR>.* {
+ xlu__disk_err(DPC,yytext,"bad disk syntax"); return 0;
+}
--- /dev/null
+/*
+ * Copyright (C) 2010 Citrix Ltd.
+ * Author Ian Jackson <ian.jackson@eu.citrix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; version 2.1 only. with the special
+ * exception on linking described in file LICENSE.
+ *
+ * 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 Lesser General Public License for more details.
+ */
+
+#ifndef LIBXLU_INTERNAL_H
+#define LIBXLU_INTERNAL_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <assert.h>
+#include <regex.h>
+
+#include "libxlutil.h"
+
+struct XLU_ConfigList {
+ int avalues; /* available slots */
+ int nvalues; /* actual occupied slots */
+ XLU_ConfigValue **values;
+};
+
+typedef struct YYLTYPE
+{
+ int first_line;
+ int first_column;
+ int last_line;
+ int last_column;
+} YYLTYPE;
+#define YYLTYPE_IS_DECLARED
+
+struct XLU_ConfigValue {
+ enum XLU_ConfigValueType type;
+ union {
+ char *string;
+ XLU_ConfigList list;
+ } u;
+ YYLTYPE loc;
+};
+
+typedef struct XLU_ConfigSetting { /* transparent */
+ struct XLU_ConfigSetting *next;
+ char *name;
+ XLU_ConfigValue *value;
+ enum XLU_Operation op;
+ int lineno;
+} XLU_ConfigSetting;
+
+struct XLU_Config {
+ XLU_ConfigSetting *settings;
+ FILE *report;
+ char *config_source;
+};
+
+typedef struct {
+ XLU_Config *cfg;
+ int err, lexerrlineno, likely_python;
+ void *scanner;
+} CfgParseContext;
+
+
+#define STRINGIFY(x) #x
+#define TOSTRING(x) STRINGIFY(x)
+
+#endif /*LIBXLU_INTERNAL_H*/
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- /dev/null
+#define _GNU_SOURCE
+
+#include "libxlu_internal.h"
+#include "libxlu_disk_l.h"
+#include "libxlu_disk_i.h"
+#include "libxlu_cfg_i.h"
+
+
+#define XLU__PCI_ERR(_c, _x, _a...) \
+ if((_c) && (_c)->report) fprintf((_c)->report, _x, ##_a)
+
+static int hex_convert(const char *str, unsigned int *val, unsigned int mask)
+{
+ unsigned long ret;
+ char *end;
+
+ ret = strtoul(str, &end, 16);
+ if ( end == str || *end != '\0' )
+ return -1;
+ if ( ret & ~mask )
+ return -1;
+ *val = (unsigned int)ret & mask;
+ return 0;
+}
+
+static int pcidev_struct_fill(libxl_device_pci *pcidev, unsigned int domain,
+ unsigned int bus, unsigned int dev,
+ unsigned int func, unsigned int vdevfn)
+{
+ pcidev->domain = domain;
+ pcidev->bus = bus;
+ pcidev->dev = dev;
+ pcidev->func = func;
+ pcidev->vdevfn = vdevfn;
+ return 0;
+}
+
+#define STATE_DOMAIN 0
+#define STATE_BUS 1
+#define STATE_DEV 2
+#define STATE_FUNC 3
+#define STATE_VSLOT 4
+#define STATE_OPTIONS_K 6
+#define STATE_OPTIONS_V 7
+#define STATE_TERMINAL 8
+#define STATE_TYPE 9
+#define STATE_RDM_STRATEGY 10
+#define STATE_RESERVE_POLICY 11
+#define INVALID 0xffffffff
+int xlu_pci_parse_bdf(XLU_Config *cfg, libxl_device_pci *pcidev, const char *str)
+{
+ unsigned state = STATE_DOMAIN;
+ unsigned dom = INVALID, bus = INVALID, dev = INVALID, func = INVALID, vslot = 0;
+ char *buf2, *tok, *ptr, *end, *optkey = NULL;
+
+ if ( NULL == (buf2 = ptr = strdup(str)) )
+ return ERROR_NOMEM;
+
+ for(tok = ptr, end = ptr + strlen(ptr) + 1; ptr < end; ptr++) {
+ switch(state) {
+ case STATE_DOMAIN:
+ if ( *ptr == ':' ) {
+ state = STATE_BUS;
+ *ptr = '\0';
+ if ( hex_convert(tok, &dom, 0xffff) )
+ goto parse_error;
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_BUS:
+ if ( *ptr == ':' ) {
+ state = STATE_DEV;
+ *ptr = '\0';
+ if ( hex_convert(tok, &bus, 0xff) )
+ goto parse_error;
+ tok = ptr + 1;
+ }else if ( *ptr == '.' ) {
+ state = STATE_FUNC;
+ *ptr = '\0';
+ if ( dom & ~0xff )
+ goto parse_error;
+ bus = dom;
+ dom = 0;
+ if ( hex_convert(tok, &dev, 0xff) )
+ goto parse_error;
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_DEV:
+ if ( *ptr == '.' ) {
+ state = STATE_FUNC;
+ *ptr = '\0';
+ if ( hex_convert(tok, &dev, 0xff) )
+ goto parse_error;
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_FUNC:
+ if ( *ptr == '\0' || *ptr == '@' || *ptr == ',' ) {
+ switch( *ptr ) {
+ case '\0':
+ state = STATE_TERMINAL;
+ break;
+ case '@':
+ state = STATE_VSLOT;
+ break;
+ case ',':
+ state = STATE_OPTIONS_K;
+ break;
+ }
+ *ptr = '\0';
+ if ( !strcmp(tok, "*") ) {
+ pcidev->vfunc_mask = LIBXL_PCI_FUNC_ALL;
+ }else{
+ if ( hex_convert(tok, &func, 0x7) )
+ goto parse_error;
+ pcidev->vfunc_mask = (1 << 0);
+ }
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_VSLOT:
+ if ( *ptr == '\0' || *ptr == ',' ) {
+ state = ( *ptr == ',' ) ? STATE_OPTIONS_K : STATE_TERMINAL;
+ *ptr = '\0';
+ if ( hex_convert(tok, &vslot, 0xff) )
+ goto parse_error;
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_OPTIONS_K:
+ if ( *ptr == '=' ) {
+ state = STATE_OPTIONS_V;
+ *ptr = '\0';
+ optkey = tok;
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_OPTIONS_V:
+ if ( *ptr == ',' || *ptr == '\0' ) {
+ state = (*ptr == ',') ? STATE_OPTIONS_K : STATE_TERMINAL;
+ *ptr = '\0';
+ if ( !strcmp(optkey, "msitranslate") ) {
+ pcidev->msitranslate = atoi(tok);
+ }else if ( !strcmp(optkey, "power_mgmt") ) {
+ pcidev->power_mgmt = atoi(tok);
+ }else if ( !strcmp(optkey, "permissive") ) {
+ pcidev->permissive = atoi(tok);
+ }else if ( !strcmp(optkey, "seize") ) {
+ pcidev->seize = atoi(tok);
+ } else if (!strcmp(optkey, "rdm_policy")) {
+ if (!strcmp(tok, "strict")) {
+ pcidev->rdm_policy = LIBXL_RDM_RESERVE_POLICY_STRICT;
+ } else if (!strcmp(tok, "relaxed")) {
+ pcidev->rdm_policy = LIBXL_RDM_RESERVE_POLICY_RELAXED;
+ } else {
+ XLU__PCI_ERR(cfg, "%s is not an valid PCI RDM property"
+ " policy: 'strict' or 'relaxed'.",
+ tok);
+ goto parse_error;
+ }
+ } else {
+ XLU__PCI_ERR(cfg, "Unknown PCI BDF option: %s", optkey);
+ }
+ tok = ptr + 1;
+ }
+ default:
+ break;
+ }
+ }
+
+ if ( tok != ptr || state != STATE_TERMINAL )
+ goto parse_error;
+
+ assert(dom != INVALID && bus != INVALID && dev != INVALID && func != INVALID);
+
+ /* Just a pretty way to fill in the values */
+ pcidev_struct_fill(pcidev, dom, bus, dev, func, vslot << 3);
+
+ free(buf2);
+
+ return 0;
+
+parse_error:
+ free(buf2);
+ return ERROR_INVAL;
+}
+
+int xlu_rdm_parse(XLU_Config *cfg, libxl_rdm_reserve *rdm, const char *str)
+{
+ unsigned state = STATE_TYPE;
+ char *buf2, *tok, *ptr, *end;
+
+ if (NULL == (buf2 = ptr = strdup(str)))
+ return ERROR_NOMEM;
+
+ for (tok = ptr, end = ptr + strlen(ptr) + 1; ptr < end; ptr++) {
+ switch(state) {
+ case STATE_TYPE:
+ if (*ptr == '=') {
+ *ptr = '\0';
+ if (!strcmp(tok, "strategy")) {
+ state = STATE_RDM_STRATEGY;
+ } else if (!strcmp(tok, "policy")) {
+ state = STATE_RESERVE_POLICY;
+ } else {
+ XLU__PCI_ERR(cfg, "Unknown RDM state option: %s", tok);
+ goto parse_error;
+ }
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_RDM_STRATEGY:
+ if (*ptr == '\0' || *ptr == ',') {
+ state = *ptr == ',' ? STATE_TYPE : STATE_TERMINAL;
+ *ptr = '\0';
+ if (!strcmp(tok, "host")) {
+ rdm->strategy = LIBXL_RDM_RESERVE_STRATEGY_HOST;
+ } else {
+ XLU__PCI_ERR(cfg, "Unknown RDM strategy option: %s", tok);
+ goto parse_error;
+ }
+ tok = ptr + 1;
+ }
+ break;
+ case STATE_RESERVE_POLICY:
+ if (*ptr == ',' || *ptr == '\0') {
+ state = *ptr == ',' ? STATE_TYPE : STATE_TERMINAL;
+ *ptr = '\0';
+ if (!strcmp(tok, "strict")) {
+ rdm->policy = LIBXL_RDM_RESERVE_POLICY_STRICT;
+ } else if (!strcmp(tok, "relaxed")) {
+ rdm->policy = LIBXL_RDM_RESERVE_POLICY_RELAXED;
+ } else {
+ XLU__PCI_ERR(cfg, "Unknown RDM property policy value: %s",
+ tok);
+ goto parse_error;
+ }
+ tok = ptr + 1;
+ }
+ default:
+ break;
+ }
+ }
+
+ if (tok != ptr || state != STATE_TERMINAL)
+ goto parse_error;
+
+ free(buf2);
+
+ return 0;
+
+parse_error:
+ free(buf2);
+ return ERROR_INVAL;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- /dev/null
+#define _GNU_SOURCE
+
+#include "libxlu_internal.h"
+
+static const char *vif_bytes_per_sec_re = "^[0-9]+[GMK]?[Bb]/s$";
+static const char *vif_internal_usec_re = "^[0-9]+[mu]?s?$";
+
+static void xlu__vif_err(XLU_Config *cfg, const char *msg, const char *rate) {
+ fprintf(cfg->report,
+ "%s: config parsing error in vif: %s in `%s'\n",
+ cfg->config_source, msg, rate);
+}
+
+static int vif_parse_rate_bytes_per_sec(XLU_Config *cfg, const char *bytes,
+ uint64_t *bytes_per_sec)
+{
+ regex_t rec;
+ uint64_t tmp = 0;
+ const char *p;
+ int rc = 0;
+
+ regcomp(&rec, vif_bytes_per_sec_re, REG_EXTENDED|REG_NOSUB);
+ if (regexec(&rec, bytes, 0, NULL, 0)) {
+ xlu__vif_err(cfg, "invalid rate", bytes);
+ rc = EINVAL;
+ goto out;
+ }
+
+ p = bytes;
+ tmp = strtoull(p, (char**)&p, 0);
+ if (tmp == 0 || tmp > UINT32_MAX || errno == ERANGE) {
+ xlu__vif_err(cfg, "rate overflow", bytes);
+ rc = EOVERFLOW;
+ goto out;
+ }
+
+ if (*p == 'G')
+ tmp *= 1000 * 1000 * 1000;
+ else if (*p == 'M')
+ tmp *= 1000 * 1000;
+ else if (*p == 'K')
+ tmp *= 1000;
+ if (*p == 'b' || *(p+1) == 'b')
+ tmp /= 8;
+
+ *bytes_per_sec = tmp;
+
+out:
+ regfree(&rec);
+ return rc;
+}
+
+static int vif_parse_rate_interval_usecs(XLU_Config *cfg, const char *interval,
+ uint32_t *interval_usecs)
+{
+ regex_t rec;
+ uint64_t tmp = 0;
+ const char *p;
+ int rc = 0;
+
+ regcomp(&rec, vif_internal_usec_re, REG_EXTENDED|REG_NOSUB);
+ if (regexec(&rec, interval, 0, NULL, 0)) {
+ xlu__vif_err(cfg, "invalid replenishment interval", interval);
+ rc = EINVAL;
+ goto out;
+ }
+
+ p = interval;
+ tmp = strtoull(p, (char**)&p, 0);
+ if (tmp == 0 || tmp > UINT32_MAX || errno == ERANGE) {
+ xlu__vif_err(cfg, "replenishment interval overflow", interval);
+ rc = EOVERFLOW;
+ goto out;
+ }
+
+ if (*p == 's' || *p == '\0')
+ tmp *= 1000 * 1000;
+ else if (*p == 'm')
+ tmp *= 1000;
+
+ if (tmp > UINT32_MAX) {
+ xlu__vif_err(cfg, "replenishment interval overflow", interval);
+ rc = EOVERFLOW;
+ goto out;
+ }
+
+ *interval_usecs = (uint32_t) tmp;
+
+out:
+ regfree(&rec);
+ return rc;
+}
+
+int xlu_vif_parse_rate(XLU_Config *cfg, const char *rate, libxl_device_nic *nic)
+{
+ uint64_t bytes_per_sec = 0;
+ uint64_t bytes_per_interval = 0;
+ uint32_t interval_usecs = 50000UL; /* Default to 50ms */
+ char *p, *tmprate;
+ int rc = 0;
+
+ tmprate = strdup(rate);
+ if (tmprate == NULL) {
+ rc = ENOMEM;
+ goto out;
+ }
+
+ p = strchr(tmprate, '@');
+ if (p != NULL)
+ *p++ = 0;
+
+ if (!strcmp(tmprate,"")) {
+ xlu__vif_err(cfg, "no rate specified", rate);
+ rc = EINVAL;
+ goto out;
+ }
+
+ rc = vif_parse_rate_bytes_per_sec(cfg, tmprate, &bytes_per_sec);
+ if (rc) goto out;
+
+ if (p != NULL) {
+ rc = vif_parse_rate_interval_usecs(cfg, p, &interval_usecs);
+ if (rc) goto out;
+ }
+
+ if (interval_usecs != 0 && (bytes_per_sec > (UINT64_MAX / interval_usecs))) {
+ xlu__vif_err(cfg, "rate overflow", rate);
+ rc = EOVERFLOW;
+ goto out;
+ }
+
+ bytes_per_interval =
+ (((uint64_t) bytes_per_sec * (uint64_t) interval_usecs) / 1000000UL);
+
+ nic->rate_interval_usecs = interval_usecs;
+ nic->rate_bytes_per_interval = bytes_per_interval;
+
+out:
+ free(tmprate);
+ return rc;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
+++ /dev/null
-LIBXENLIGHT CODING STYLE
-========================
-
-
-AN APOLOGY AND WARNING
-----------------------
-
-Much of the code in libxl does not yet follow this coding style
-document in every respect. However, new code is expected to conform.
-
-Patches to improve the style of existing code are welcome. Please
-separate these out from functional changes.
-
-If it is not feasible to conform fully to the style while patching old
-code, without doing substantial style reengineering first, we may
-accept patches which contain nonconformant elements, provided that
-they don't make the coding style problem worse overall.
-
-In this case, the new code should conform to the prevailing style in
-the area being touched.
-
-
-MEMORY ALLOCATION
------------------
-
-Memory allocation for libxl-internal purposes should normally be done
-with the provided gc mechanisms; there is then no need to free. See
-"libxl memory management" in libxl.h.
-
-
-CONVENTIONAL VARIABLE NAMES
----------------------------
-
-The following local variable names should be used where applicable:
-
- int rc; /* a libxl error code - and not anything else */
- int r; /* the return value from a system call (or libxc call) */
- bool ok; /* the success return value from a boolean function */
-
- uint32_t domid;
- libxl__gc *gc;
- libxl__egc *egc;
- libxl__ao *ao;
-
- libxl_foo_bar_state *fbs; /* local variable */
- libxl_foo_bar_state foo_bar; /* inside another state struct */
-
-
-CONVENIENCE MACROS
-------------------
-
-There are a number of convenience macros which shorten the program and
-avoid opportunity for mistakes. In some cases non-use of the macros
-produces functional bugs or incorrect error handling. Use the macros
-whenever they are applicable. For example:
-
- Usually, don't use: Instead, use (see libxl_internal.h):
- libxl__log[v] LOG, LOGE, LOGEV
- libxl__sprintf GCSPRINTF
- libxl__*alloc et al. GCNEW, GCNEW_ARRAY, GCREALLOC_ARRAY
- isalnum etc. directly CTYPE
- libxl__ctx_[un]lock CTX_LOCK, CTX_UNLOCK
- gc=...; ao=...; EGC_GC, AO_GC, STATE_AO_GC
- explicit gc creation GC_INIT, GC_FREE
- memset(..,0,sizeof..) FILLZERO
-
-Instead of malloc et al one should (as an exception to the above) use
-libxl__{zalloc,calloc,realloc} etc but passing NOGC.
-
-ERROR HANDLING
---------------
-
-Unless, there are good reasons to do otherwise, the following error
-handling and cleanup paradigm should be used:
-
- * All local variables referring to resources which might need
- cleaning up are declared at the top of the function, and
- initialised to a sentinel value indicating "nothing allocated".
- For example,
- libxl_evgen_disk_eject *evg = NULL;
- int nullfd = -1;
-
- * If the function is to return a libxl error value, `rc' is
- used to contain the error code, but it is NOT initialised:
- int rc;
-
- * There is only one error cleanup path out of the function. It
- starts with a label `out:'. That error cleanup path checks for
- each allocated resource and frees it iff necessary. It then
- returns rc. For example,
- out:
- if (evg) libxl__evdisable_disk_eject(gc, evg);
- if (nullfd >= 0) close(nullfd);
- return rc;
-
- * Function calls which might fail (ie most function calls) are
- handled by putting the return/status value into a variable, and
- then checking it in a separate statement:
- char *dompath = libxl__xs_get_dompath(gc, bl->domid);
- if (!dompath) { rc = ERROR_FAIL; goto out; }
-
- * If a resource is freed in the main body of the function (for
- example, in a loop), the corresponding variable has to be reset to
- the sentinel at the point where it's freed.
-
-Whether to use the `out' path for successful returns as well as error
-returns is a matter of taste and convenience for the specific
-function. Not reusing the out path is fine if the duplicated function
-exit code is only `CTX_UNLOCK; GC_FREE;' (or similar).
-
-If you reuse the `out' path for successful returns, there may be
-resources which are to be returned to the caller rather than freed.
-In that case you have to reset the local variable to `nothing here',
-to avoid the resource being freed on the out path. That resetting
-should be done immediately after the resource value is stored at the
-applicable _r function parameter (or equivalent). Do not test `rc' in
-the out section, to discover whether to free things.
-
-The uses of the single-line formatting in the examples above are
-permitted exceptions to the usual libxl code formatting rules.
-
-
-
-IDEMPOTENT DATA STRUCTURE CONSTRUCTION/DESTRUCTION
---------------------------------------------------
-
-Nontrivial data structures (in structs) should come with an idempotent
-_dispose function, which must free all resources associated with the
-data structure (but not free the struct itself).
-
-Such a struct should also come with an _init function which
-initialises the struct so that _dispose is a no-op.
-
-
-ASYNCHRONOUS/LONG-RUNNING OPERATIONS
-------------------------------------
-
-All long-running operations in libxl need to use the asynchronous
-operation machinery. Consult the programmer documentation in
-libxl_internal.h for details - search for "Machinery for asynchronous
-operations".
-
-The code for asynchronous operations should be laid out in
-chronological order. That is, where there is a chain of callback
-functions, each subsequent function should be, textually, the next
-function in the file. This will normally involve predeclaring the
-callback functions. Synchronous helper functions should be separated
-out into a section preceding the main callback chain.
-
-Control flow arrangements in asynchronous operations should be made as
-simple as possible, because it can otherwise be very hard to see
-through the tangle.
-
-
-When inventing a new sub-operation in asynchronous code, consider
-whether to structure it formally as a sub-operation with its own state
-structure. (See, for example, libxl__datacopier_*.)
-
-An ao-suboperation state structure should contain, in this order:
- * fields that the caller must fill in, and which are,
- effectively, the parameters to the operation, including:
- - libxl__ao *ao
- - the callback function pointer(s), which
- should be named callback or callback_*.
- * shared information fields or ones used for returning information
- to the calling operation
- * private fields
-These sections should be clearly demarcated by comments.
-
-An asynchronous operation should normally have an idempotent stop or
-cancel function. It should normally also have an _init function for
-its state struct, which arranges that the stop is a no-op.
-
-The permitted order of calls into your ao operation's methods must be
-documented in comments, if it is nontrivial.
-
-
-When using an ao sub-operation, you should normally:
- * Physically include the sub-operation state struct in your
- own state struct;
- * Use CONTAINER_OF to find your own state struct at the start of
- your implementations of the sub-operation callback functions;
- * Unconditionally initialise the sub-operation's struct (with its
- _init method) in your own _init method.
- * Unconditionally cancel or destroy the sub-operation in your own
- cancel or destroy method.
-
-
-FORMATTING AND NAMING
----------------------
-
-Blatantly copied from qemu and linux with few modifications.
-
-
-1. Whitespace
-
-Of course, the most important aspect in any coding style is whitespace.
-Crusty old coders who have trouble spotting the glasses on their noses
-can tell the difference between a tab and eight spaces from a distance
-of approximately fifteen parsecs. Many a flamewar have been fought and
-lost on this issue.
-
-Libxenlight indents are four spaces. Tabs are never used, except in
-Makefiles where they have been irreversibly coded into the syntax.
-Spaces of course are superior to tabs because:
-
- - You have just one way to specify whitespace, not two. Ambiguity breeds
- mistakes.
- - The confusion surrounding 'use tabs to indent, spaces to justify' is gone.
- - Tab indents push your code to the right, making your screen seriously
- unbalanced.
- - Tabs will be rendered incorrectly on editors who are misconfigured not
- to use tab stops of eight positions.
- - Tabs are rendered badly in patches, causing off-by-one errors in almost
- every line.
- - It is the libxenlight coding style.
-
-Do not leave whitespace dangling off the ends of lines.
-
-
-2. Line width
-
-Lines are limited to 75 characters.
-
-Rationale:
- - Some people like to tile their 24" screens with a 6x4 matrix of 80x24
- xterms and use vi in all of them. The best way to punish them is to
- let them keep doing it.
- - In an 80 column terminal, some room needs to be left for > quoting
- characters, +/- diff characters, and so on, in emails.
- - Code and especially patches is much more readable if limited to a sane
- line length. Eighty is traditional.
- - It is the libxenlight coding style.
-
-
-3. Naming
-
-C is a Spartan language, and so should your naming be. Unlike Modula-2
-and Pascal programmers, C programmers do not use cute names like
-ThisVariableIsATemporaryCounter. A C programmer would call that
-variable "tmp", which is much easier to write, and not the least more
-difficult to understand.
-
-HOWEVER, while mixed-case names are frowned upon, descriptive names for
-global variables are a must. To call a global function "foo" is a
-shooting offense.
-
-GLOBAL variables (to be used only if you _really_ need them) need to
-have descriptive names, as do global functions. If you have a function
-that counts the number of active users, you should call that
-"count_active_users()" or similar, you should _not_ call it "cntusr()".
-
-Encoding the type of a function into the name (so-called Hungarian
-notation) is brain damaged - the compiler knows the types anyway and can
-check those, and it only confuses the programmer.
-
-LOCAL variable names should be short, and to the point. If you have
-some random integer loop counter, it should probably be called "i".
-Calling it "loop_counter" is non-productive, if there is no chance of it
-being mis-understood. Similarly, "tmp" can be just about any type of
-variable that is used to hold a temporary value.
-
-Local variables used to store return values should have descriptive name
-like "rc" or "ret". Following the same reasoning the label used as exit
-path should be called "out".
-
-Function arguments which are used to return values to the caller
-should be suffixed `_r' or `_out'.
-
-Variables, type names and function names are
-lower_case_with_underscores.
-Type names and function names use the prefix libxl__ when internal to
-libxenlight and libxl_ when exported in libxl.h.
-Xl should avoid using libxl_ and libxl__ as prefix for its own function
-names.
-
-When wrapping standard library functions, use the prefix libxl_ to alert
-readers that they are seeing a wrapped version; otherwise avoid this prefix.
-
-Typedefs are used to eliminate the redundant 'struct' keyword.
-It is the libxenlight coding style.
-
-
-4. Statements
-
-Don't put multiple statements on a single line.
-Don't put multiple assignments on a single line either.
-Error code paths with an if statement and a goto or a return on the same
-line are allowed. Examples:
-
- if (rc) goto out;
- if (rc < 0) return;
-
-Libxenlight coding style is super simple. Avoid tricky expressions.
-
-
-5. Block structure
-
-Every indented statement is braced, but blocks that contain just one
-statement may have the braces omitted. To avoid confusion, either all
-the blocks in an if...else chain have braces, or none of them do.
-
-The opening brace is on the line that contains the control flow
-statement that introduces the new block; the closing brace is on the
-same line as the else keyword, or on a line by itself if there is no
-else keyword. Examples:
-
- if (a == 5) {
- printf("a was 5.\n");
- } else if (a == 6) {
- printf("a was 6.\n");
- } else {
- printf("a was something else entirely.\n");
- }
-
- if (a == 5)
- printf("a was 5.\n");
-
-An exception is the opening brace for a function; for reasons of tradition
-and clarity it comes on a line by itself:
-
- void a_function(void)
- {
- do_something();
- }
-
-Rationale: a consistent (except for functions...) bracing style reduces
-ambiguity and avoids needless churn when lines are added or removed.
-Furthermore, it is the libxenlight coding style.
-
+++ /dev/null
-#
-# tools/libxl/Makefile
-#
-
-XEN_ROOT = $(CURDIR)/../..
-include $(XEN_ROOT)/tools/Rules.mk
-
-XLUMAJOR = 4.15
-XLUMINOR = 0
-
-CFLAGS += -Werror -Wno-format-zero-length -Wmissing-declarations \
- -Wno-declaration-after-statement -Wformat-nonliteral
-CFLAGS += -I. -fPIC
-
-CFLAGS += $(PTHREAD_CFLAGS)
-LDFLAGS += $(PTHREAD_LDFLAGS)
-
-LIBXLU_LIBS = $(LDLIBS_libxenlight)
-
-ifeq ($(FLEX),)
-%.c %.h:: %.l
- $(warning Flex is needed to rebuild some libxl parsers and \
- scanners, please install it and rerun configure)
-endif
-
-ifeq ($(BISON),)
-%.c %.h:: %.y
- $(warning Bison is needed to rebuild some libxl parsers and \
- scanners, please install it an rerun configure)
-endif
-
-AUTOINCS= libxlu_cfg_y.h libxlu_cfg_l.h libxlu_disk_l.h
-AUTOSRCS= libxlu_cfg_y.c libxlu_cfg_l.c
-LIBXLU_OBJS = libxlu_cfg_y.o libxlu_cfg_l.o libxlu_cfg.o \
- libxlu_disk_l.o libxlu_disk.o libxlu_vif.o libxlu_pci.o
-$(LIBXLU_OBJS): CFLAGS += $(CFLAGS_libxenctrl) # For xentoollog.h
-
-PKG_CONFIG = xlutil.pc
-
-ifneq ($(CONFIG_LIBXC_MINIOS),y)
-PKG_CONFIG_INST := $(PKG_CONFIG)
-xlutil.pc: PKG_CONFIG_NAME = Xlutil
-xlutil.pc: PKG_CONFIG_DESC = The xl utility library for Xen hypervisor
-xlutil.pc: PKG_CONFIG_VERSION = $(XLUMAJOR).$(XLUMINOR)
-xlutil.pc: PKG_CONFIG_USELIBS = $(SHLIB_libxenutil)
-xlutil.pc: PKG_CONFIG_LIB = xlutil
-xlutil.pc: PKG_CONFIG_REQPRIV = xenlight
-$(PKG_CONFIG_INST): PKG_CONFIG_PREFIX = $(prefix)
-$(PKG_CONFIG_INST): PKG_CONFIG_INCDIR = $(includedir)
-$(PKG_CONFIG_INST): PKG_CONFIG_LIBDIR = $(libdir)
-endif
-
-PKG_CONFIG_LOCAL := $(foreach pc,$(PKG_CONFIG),$(PKG_CONFIG_DIR)/$(pc))
-
-$(PKG_CONFIG_DIR)/xlutil.pc: PKG_CONFIG_NAME = Xlutil
-$(PKG_CONFIG_DIR)/xlutil.pc: PKG_CONFIG_DESC = The xl utility library for Xen hypervisor
-$(PKG_CONFIG_DIR)/xlutil.pc: PKG_CONFIG_VERSION = $(XLUMAJOR).$(XLUMINOR)
-$(PKG_CONFIG_DIR)/xlutil.pc: PKG_CONFIG_USELIBS = $(SHLIB_libxenutil)
-$(PKG_CONFIG_DIR)/xlutil.pc: PKG_CONFIG_LIB = xlutil
-$(PKG_CONFIG_DIR)/xlutil.pc: PKG_CONFIG_REQPRIV = xenlight
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_PREFIX = $(XEN_ROOT)
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_INCDIR = $(CURDIR)
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_LIBDIR = $(CURDIR)
-$(PKG_CONFIG_LOCAL): PKG_CONFIG_CFLAGS_LOCAL = $(CFLAGS_xeninclude)
-
-.PHONY: all
-all: libxlutil.so libxlutil.a $(AUTOSRCS) $(AUTOINCS) $(PKG_CONFIG) $(PKG_CONFIG_LOCAL)
-
-$(LIBXLU_OBJS): $(AUTOINCS)
-
-%.c %.h:: %.y
- @rm -f $*.[ch]
- $(BISON) --output=$*.c $<
-
-%.c %.h:: %.l
- @rm -f $*.[ch]
- $(FLEX) --header-file=$*.h --outfile=$*.c $<
-
-genpath-target = $(call buildmakevars2header,_paths.h)
-$(eval $(genpath-target))
-
-libxlutil.so: libxlutil.so.$(XLUMAJOR)
- $(SYMLINK_SHLIB) $< $@
-
-libxlutil.so.$(XLUMAJOR): libxlutil.so.$(XLUMAJOR).$(XLUMINOR)
- $(SYMLINK_SHLIB) $< $@
-
-libxlutil.so.$(XLUMAJOR).$(XLUMINOR): $(LIBXLU_OBJS)
- $(CC) $(LDFLAGS) -Wl,$(SONAME_LDFLAG) -Wl,libxlutil.so.$(XLUMAJOR) $(SHLIB_LDFLAGS) -o $@ $(LIBXLU_OBJS) $(LIBXLU_LIBS) $(APPEND_LDFLAGS)
-
-libxlutil.a: $(LIBXLU_OBJS)
- $(AR) rcs libxlutil.a $^
-
-.PHONY: install
-install: all
- $(INSTALL_DIR) $(DESTDIR)$(libdir)
- $(INSTALL_DIR) $(DESTDIR)$(includedir)
- $(INSTALL_SHLIB) libxlutil.so.$(XLUMAJOR).$(XLUMINOR) $(DESTDIR)$(libdir)
- $(SYMLINK_SHLIB) libxlutil.so.$(XLUMAJOR).$(XLUMINOR) $(DESTDIR)$(libdir)/libxlutil.so.$(XLUMAJOR)
- $(SYMLINK_SHLIB) libxlutil.so.$(XLUMAJOR) $(DESTDIR)$(libdir)/libxlutil.so
- $(INSTALL_DATA) libxlutil.a $(DESTDIR)$(libdir)
- $(INSTALL_DATA) libxlutil.h $(DESTDIR)$(includedir)
- $(INSTALL_DATA) xlutil.pc $(DESTDIR)$(PKG_INSTALLDIR)
-
-.PHONY: uninstall
-uninstall:
- rm -f $(DESTDIR)$(PKG_INSTALLDIR)/xlutil.pc
- rm -f $(DESTDIR)$(includedir)/libxlutil.h
- rm -f $(DESTDIR)$(libdir)/libxlutil.a
- rm -f $(DESTDIR)$(libdir)/libxlutil.so
- rm -f $(DESTDIR)$(libdir)/libxlutil.so.$(XLUMAJOR)
- rm -f $(DESTDIR)$(libdir)/libxlutil.so.$(XLUMAJOR).$(XLUMINOR)
-
-.PHONY: clean
-clean:
- $(RM) -f _*.h *.o *.so* *.a $(DEPS_RM)
- $(RM) -f xlutil.pc
-
-distclean: clean
-
-realclean: distclean
- $(RM) -f $(AUTOSRCS) $(AUTOINCS)
-
--include $(DEPS_INCLUDE)
+++ /dev/null
-/*
- * libxlu_cfg.c - xl configuration file parsing: setup and helper functions
- *
- * Copyright (C) 2010 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-
-#define _GNU_SOURCE
-
-#include <limits.h>
-
-#include "libxlu_internal.h"
-#include "libxlu_cfg_y.h"
-#include "libxlu_cfg_l.h"
-#include "libxlu_cfg_i.h"
-
-XLU_Config *xlu_cfg_init(FILE *report, const char *report_source) {
- XLU_Config *cfg;
-
- cfg= malloc(sizeof(*cfg));
- if (!cfg) return 0;
-
- cfg->report= report;
- cfg->config_source= strdup(report_source);
- if (!cfg->config_source) { free(cfg); return 0; }
-
- cfg->settings= 0;
- return cfg;
-}
-
-static int ctx_prep(CfgParseContext *ctx, XLU_Config *cfg) {
- int e;
-
- ctx->cfg= cfg;
- ctx->err= 0;
- ctx->lexerrlineno= -1;
- ctx->likely_python= 0;
- ctx->scanner= 0;
-
- e= xlu__cfg_yylex_init_extra(ctx, &ctx->scanner);
- if (e) {
- fprintf(cfg->report,"%s: unable to create scanner: %s\n",
- cfg->config_source, strerror(e));
- return e;
- }
- return 0;
-}
-
-static void ctx_dispose(CfgParseContext *ctx) {
- if (ctx->scanner) xlu__cfg_yylex_destroy(ctx->scanner);
-}
-
-static void parse(CfgParseContext *ctx) {
- /* On return, ctx.err will be updated with the error status. */
- int r;
-
- xlu__cfg_yyset_lineno(1, ctx->scanner);
-
- r= xlu__cfg_yyparse(ctx);
- if (r) assert(ctx->err);
-
- if (ctx->err && ctx->likely_python) {
- fputs(
- "warning: Config file looks like it contains Python code.\n"
- "warning: Arbitrary Python is no longer supported.\n"
- "warning: See https://wiki.xen.org/wiki/PythonInXlConfig\n",
- ctx->cfg->report);
- }
-}
-
-int xlu_cfg_readfile(XLU_Config *cfg, const char *real_filename) {
- FILE *f = 0;
- int e;
-
- CfgParseContext ctx;
- e = ctx_prep(&ctx, cfg);
- if (e) { ctx.err= e; goto xe; }
-
- f= fopen(real_filename, "r");
- if (!f) {
- ctx.err = errno;
- fprintf(cfg->report,"%s: unable to open configuration file: %s\n",
- real_filename, strerror(e));
- goto xe;
- }
-
- xlu__cfg_yyrestart(f, ctx.scanner);
-
- parse(&ctx);
-
- xe:
- ctx_dispose(&ctx);
- if (f) fclose(f);
-
- return ctx.err;
-}
-
-int xlu_cfg_readdata(XLU_Config *cfg, const char *data, int length) {
- int e;
- YY_BUFFER_STATE buf= 0;
-
- CfgParseContext ctx;
- e= ctx_prep(&ctx, cfg);
- if (e) { ctx.err= e; goto xe; }
-
- buf = xlu__cfg_yy_scan_bytes(data, length, ctx.scanner);
- if (!buf) {
- fprintf(cfg->report,"%s: unable to allocate scanner buffer\n",
- cfg->config_source);
- ctx.err= ENOMEM;
- goto xe;
- }
-
- parse(&ctx);
-
- xe:
- if (buf) xlu__cfg_yy_delete_buffer(buf, ctx.scanner);
- ctx_dispose(&ctx);
-
- return ctx.err;
-}
-
-void xlu__cfg_value_free(XLU_ConfigValue *value)
-{
- int i;
-
- if (!value) return;
-
- switch (value->type) {
- case XLU_STRING:
- free(value->u.string);
- break;
- case XLU_LIST:
- for (i = 0; i < value->u.list.nvalues; i++)
- xlu__cfg_value_free(value->u.list.values[i]);
- free(value->u.list.values);
- }
- free(value);
-}
-
-void xlu__cfg_set_free(XLU_ConfigSetting *set) {
- if (!set) return;
- free(set->name);
- xlu__cfg_value_free(set->value);
- free(set);
-}
-
-void xlu_cfg_destroy(XLU_Config *cfg) {
- XLU_ConfigSetting *set, *set_next;
-
- if (!cfg) return;
- for (set= cfg->settings;
- set;
- set= set_next) {
- set_next= set->next;
- xlu__cfg_set_free(set);
- }
- free(cfg->config_source);
- free(cfg);
-}
-
-static XLU_ConfigSetting *find(const XLU_Config *cfg, const char *n) {
- XLU_ConfigSetting *set;
-
- for (set= cfg->settings;
- set;
- set= set->next)
- if (!strcmp(set->name, n))
- return set;
- return 0;
-}
-
-static int find_atom(const XLU_Config *cfg, const char *n,
- XLU_ConfigSetting **set_r, int dont_warn) {
- XLU_ConfigSetting *set;
-
- set= find(cfg,n);
- if (!set) return ESRCH;
-
- if (set->value->type!=XLU_STRING) {
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d: warning: parameter `%s' is"
- " a list but should be a single value\n",
- cfg->config_source, set->lineno, n);
- return EINVAL;
- }
- *set_r= set;
- return 0;
-}
-
-
-enum XLU_ConfigValueType xlu_cfg_value_type(const XLU_ConfigValue *value)
-{
- return value->type;
-}
-
-int xlu_cfg_value_get_string(const XLU_Config *cfg, XLU_ConfigValue *value,
- char **value_r, int dont_warn)
-{
- if (value->type != XLU_STRING) {
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d:%d: warning: value is not a string\n",
- cfg->config_source, value->loc.first_line,
- value->loc.first_column);
- *value_r = NULL;
- return EINVAL;
- }
-
- *value_r = value->u.string;
- return 0;
-}
-
-int xlu_cfg_value_get_list(const XLU_Config *cfg, XLU_ConfigValue *value,
- XLU_ConfigList **value_r, int dont_warn)
-{
- if (value->type != XLU_LIST) {
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d:%d: warning: value is not a list\n",
- cfg->config_source, value->loc.first_line,
- value->loc.first_column);
- *value_r = NULL;
- return EINVAL;
- }
-
- *value_r = &value->u.list;
- return 0;
-}
-
-XLU_ConfigValue *xlu_cfg_get_listitem2(const XLU_ConfigList *list,
- int entry)
-{
- if (entry < 0 || entry >= list->nvalues) return NULL;
- return list->values[entry];
-}
-
-int xlu_cfg_get_string(const XLU_Config *cfg, const char *n,
- const char **value_r, int dont_warn) {
- XLU_ConfigSetting *set;
- int e;
-
- e= find_atom(cfg,n,&set,dont_warn); if (e) return e;
- *value_r= set->value->u.string;
- return 0;
-}
-
-int xlu_cfg_replace_string(const XLU_Config *cfg, const char *n,
- char **value_r, int dont_warn) {
- XLU_ConfigSetting *set;
- int e;
-
- e= find_atom(cfg,n,&set,dont_warn); if (e) return e;
- free(*value_r);
- *value_r= strdup(set->value->u.string);
- return 0;
-}
-
-int xlu_cfg_get_bounded_long(const XLU_Config *cfg, const char *n,
- long min, long max, long *value_r,
- int dont_warn) {
- long l;
- XLU_ConfigSetting *set;
- int e;
- char *ep;
-
- e= find_atom(cfg,n,&set,dont_warn); if (e) return e;
- if (set->op == XLU_OP_ADDITION) {
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d: warning: can't use += with numbers"
- " for parameter `%s'\n",
- cfg->config_source, set->lineno, n);
- return EINVAL;
- }
- errno= 0; l= strtol(set->value->u.string, &ep, 0);
- e= errno;
- if (errno) {
- e= errno;
- assert(e==EINVAL || e==ERANGE);
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d: warning: parameter `%s' could not be parsed"
- " as a number: %s\n",
- cfg->config_source, set->lineno, n, strerror(e));
- return e;
- }
- if (*ep || ep==set->value->u.string) {
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d: warning: parameter `%s' is not a valid number\n",
- cfg->config_source, set->lineno, n);
- return EINVAL;
- }
- if (l < min) {
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d: warning: value `%ld' is smaller than minimum bound '%ld'\n",
- cfg->config_source, set->lineno, l, min);
- return EINVAL;
- }
- if (l > max) {
- if (!dont_warn)
- fprintf(cfg->report,
- "%s:%d: warning: value `%ld' is greater than maximum bound '%ld'\n",
- cfg->config_source, set->lineno, l, max);
- return EINVAL;
- }
-
- *value_r= l;
- return 0;
-}
-
-int xlu_cfg_get_long(const XLU_Config *cfg, const char *n,
- long *value_r, int dont_warn) {
- return xlu_cfg_get_bounded_long(cfg, n, LONG_MIN, LONG_MAX, value_r,
- dont_warn);
-}
-
-int xlu_cfg_get_defbool(const XLU_Config *cfg, const char *n, libxl_defbool *b,
- int dont_warn)
-{
- int ret;
- long l;
-
- ret = xlu_cfg_get_long(cfg, n, &l, dont_warn);
- if (ret) return ret;
- libxl_defbool_set(b, !!l);
- return 0;
-}
-
-int xlu_cfg_get_list(const XLU_Config *cfg, const char *n,
- XLU_ConfigList **list_r, int *entries_r, int dont_warn) {
- XLU_ConfigSetting *set;
- set= find(cfg,n); if (!set) return ESRCH;
- if (set->value->type!=XLU_LIST) {
- if (!dont_warn) {
- fprintf(cfg->report,
- "%s:%d: warning: parameter `%s' is a single value"
- " but should be a list\n",
- cfg->config_source, set->lineno, n);
- }
- return EINVAL;
- }
- if (list_r) *list_r= &set->value->u.list;
- if (entries_r) *entries_r= set->value->u.list.nvalues;
- return 0;
-}
-
-int xlu_cfg_get_list_as_string_list(const XLU_Config *cfg, const char *n,
- libxl_string_list *psl, int dont_warn) {
- int i, rc, nr;
- XLU_ConfigList *list;
- libxl_string_list sl;
-
- rc = xlu_cfg_get_list(cfg, n, &list, &nr, dont_warn);
- if (rc) return rc;
-
- sl = malloc(sizeof(char*)*(nr + 1));
- if (sl == NULL) return ENOMEM;
-
- for (i=0; i<nr; i++) {
- const char *a = xlu_cfg_get_listitem(list, i);
- sl[i] = a ? strdup(a) : NULL;
- }
-
- sl[nr] = NULL;
-
- *psl = sl;
- return 0;
-}
-
-const char *xlu_cfg_get_listitem(const XLU_ConfigList *list, int entry) {
- if (entry < 0 || entry >= list->nvalues) return 0;
- if (list->values[entry]->type != XLU_STRING) return 0;
- return list->values[entry]->u.string;
-}
-
-
-XLU_ConfigValue *xlu__cfg_string_mk(CfgParseContext *ctx, char *atom,
- YYLTYPE *loc)
-{
- XLU_ConfigValue *value = NULL;
-
- if (ctx->err) goto x;
-
- value = malloc(sizeof(*value));
- if (!value) goto xe;
- value->type = XLU_STRING;
- value->u.string = atom;
- memcpy(&value->loc, loc, sizeof(*loc));
-
- return value;
-
- xe:
- ctx->err= errno;
- x:
- free(value);
- free(atom);
- return NULL;
-}
-
-XLU_ConfigValue *xlu__cfg_list_mk(CfgParseContext *ctx,
- XLU_ConfigValue *val,
- YYLTYPE *loc)
-{
- XLU_ConfigValue *value = NULL;
- XLU_ConfigValue **values = NULL;
-
- if (ctx->err) goto x;
-
- values = malloc(sizeof(*values));
- if (!values) goto xe;
- values[0] = val;
-
- value = malloc(sizeof(*value));
- if (!value) goto xe;
- value->type = XLU_LIST;
- value->u.list.nvalues = !!val;
- value->u.list.avalues = 1;
- value->u.list.values = values;
- memcpy(&value->loc, loc, sizeof(*loc));
-
- return value;
-
- xe:
- ctx->err= errno;
- x:
- free(value);
- free(values);
- xlu__cfg_value_free(val);
- return NULL;
-}
-
-void xlu__cfg_list_append(CfgParseContext *ctx,
- XLU_ConfigValue *list,
- XLU_ConfigValue *val)
-{
- if (ctx->err) return;
-
- assert(val);
- assert(list->type == XLU_LIST);
-
- if (list->u.list.nvalues >= list->u.list.avalues) {
- int new_avalues;
- XLU_ConfigValue **new_values = NULL;
-
- if (list->u.list.avalues > INT_MAX / 100) {
- ctx->err = ERANGE;
- xlu__cfg_value_free(val);
- return;
- }
-
- new_avalues = list->u.list.avalues * 4;
- new_values = realloc(list->u.list.values,
- sizeof(*new_values) * new_avalues);
- if (!new_values) {
- ctx->err = errno;
- xlu__cfg_value_free(val);
- return;
- }
-
- list->u.list.avalues = new_avalues;
- list->u.list.values = new_values;
- }
-
- list->u.list.values[list->u.list.nvalues] = val;
- list->u.list.nvalues++;
-}
-
-static int xlu__cfg_concat_vals(CfgParseContext *ctx,
- XLU_ConfigValue *prev,
- XLU_ConfigValue *to_add)
-{
- int r;
-
- if (prev->type != to_add->type) {
- xlu__cfgl_lexicalerror(ctx,
- "can't add [list] to \"string\" or vice versa");
- return EINVAL;
- }
-
- switch (to_add->type) {
- case XLU_STRING: {
- char *new_string = NULL;
-
- r = asprintf(&new_string, "%s%s", prev->u.string,
- to_add->u.string);
- if (r < 0) {
- return errno;
- }
- free(to_add->u.string);
- to_add->u.string = new_string;
- return 0;
- }
- case XLU_LIST: {
- XLU_ConfigList *const prev_list = &prev->u.list;
- XLU_ConfigList *const cur_list = &to_add->u.list;
- int nvalues;
-
- if (prev->u.list.nvalues > INT_MAX - to_add->u.list.nvalues) {
- return ERANGE;
- }
- nvalues = prev->u.list.nvalues + to_add->u.list.nvalues;
-
- if (nvalues >= cur_list->avalues) {
- XLU_ConfigValue **new_vals;
- new_vals = realloc(cur_list->values,
- nvalues * sizeof(*new_vals));
- if (!new_vals) {
- return ENOMEM;
- }
- cur_list->avalues = nvalues;
- cur_list->values = new_vals;
- }
-
- /* make space for `prev' into `to_add' */
- memmove(cur_list->values + prev_list->nvalues,
- cur_list->values,
- cur_list->nvalues * sizeof(XLU_ConfigValue *));
- /* move values from `prev' to `to_add' as the list in `prev' will
- * not be reachable by find(). */
- memcpy(cur_list->values,
- prev_list->values,
- prev_list->nvalues * sizeof(XLU_ConfigValue *));
- cur_list->nvalues = nvalues;
- prev_list->nvalues = 0;
- memset(prev_list->values, 0,
- prev_list->nvalues * sizeof(XLU_ConfigValue *));
- return 0;
- }
- default:
- abort();
- }
- return -1;
-}
-
-void xlu__cfg_set_store(CfgParseContext *ctx, char *name,
- enum XLU_Operation op,
- XLU_ConfigValue *val, int lineno) {
- XLU_ConfigSetting *set;
- int r;
-
- if (ctx->err) goto out;
-
- assert(name);
-
- if (op == XLU_OP_ADDITION) {
- /* If we have += concatenate with previous value with same name */
- XLU_ConfigSetting *prev_set = find(ctx->cfg, name);
- if (prev_set) {
- r = xlu__cfg_concat_vals(ctx, prev_set->value, val);
- if (r) {
- ctx->err = r;
- goto out;
- }
- }
- }
-
- set = malloc(sizeof(*set));
- if (!set) {
- ctx->err = errno;
- goto out;
- }
- set->name= name;
- set->value = val;
- set->op = op;
- set->lineno= lineno;
- set->next= ctx->cfg->settings;
- ctx->cfg->settings= set;
- return;
-out:
- assert(ctx->err);
- free(name);
- xlu__cfg_value_free(val);
-}
-
-char *xlu__cfgl_strdup(CfgParseContext *ctx, const char *src) {
- char *result;
-
- if (ctx->err) return 0;
- result= strdup(src);
- if (!result) ctx->err= errno;
- return result;
-}
-
-char *xlu__cfgl_dequote(CfgParseContext *ctx, const char *src) {
- char *result;
- const char *p;
- char *q;
- int len, c, nc;
-
- if (ctx->err) return 0;
-
- len= strlen(src);
- assert(len>=2 && src[0]==src[len-1]);
-
- result= malloc(len-1);
- if (!result) { ctx->err= errno; return 0; }
-
- q= result;
-
- for (p= src+1;
- p < src+len-1;
- ) {
- c= *p++;
- if (c=='\\') {
- assert(p < src+len-1);
- nc= *p++;
- if (nc=='"' || nc=='\'' || nc=='\\') {
- *q++= nc;
- } else if (nc=='a') { *q++= '\007';
- } else if (nc=='b') { *q++= '\010';
- } else if (nc=='f') { *q++= '\014';
- } else if (nc=='n') { *q++= '\n';
- } else if (nc=='r') { *q++= '\r';
- } else if (nc=='t') { *q++= '\t';
- } else if (nc=='v') { *q++= '\013';
- } else if (nc=='x') {
-
-#define NUMERIC_CHAR(minlen,maxlen,base,basetext) do{ \
- char numbuf[(maxlen)+1], *ep; \
- unsigned long val; \
- \
- strncpy(numbuf,p,(maxlen)); \
- numbuf[(maxlen)]= 0; \
- val= strtoul(numbuf, &ep, (base)); \
- if (ep <= numbuf+(minlen)) { \
- xlu__cfgl_lexicalerror(ctx,"invalid digit after" \
- " backslash " basetext "numerical character escape" \
- " in quoted string"); \
- ctx->err= EINVAL; \
- goto x; \
- } \
- p += (ep - numbuf); \
- }while(0)
-
- p++;
- NUMERIC_CHAR(2,2,16,"hex");
- } else if (nc>='0' && nc<='7') {
- NUMERIC_CHAR(1,3,10,"octal");
- } else {
- xlu__cfgl_lexicalerror(ctx,
- "invalid character after backlash in quoted string");
- ctx->err= EINVAL;
- goto x;
- }
- assert(p <= src+len-1);
- } else {
- *q++= c;
- }
- }
-
- x:
- *q++= 0;
- return result;
-}
-
-void xlu__cfgl_lexicalerror(CfgParseContext *ctx, char const *msg) {
- YYLTYPE loc;
- loc.first_line= xlu__cfg_yyget_lineno(ctx->scanner);
- xlu__cfg_yyerror(&loc, ctx, msg);
- ctx->lexerrlineno= loc.first_line;
-}
-
-void xlu__cfg_yyerror(YYLTYPE *loc, CfgParseContext *ctx, char const *msg) {
- const char *text, *newline;
- int len, lineno;
-
- lineno= loc->first_line;
- if (lineno <= ctx->lexerrlineno) return;
-
- text= xlu__cfg_yyget_text(ctx->scanner);
- len= xlu__cfg_yyget_leng(ctx->scanner);
- newline= "";
- if (len>0 && text[len-1]=='\n') {
- len--;
- lineno--;
- if (!len) {
- newline= "<newline>";
- }
- }
- while (len>0 && (text[len-1]=='\t' || text[len-1]==' ')) {
- len--;
- }
-
- fprintf(ctx->cfg->report,
- "%s:%d: config parsing error near %s%.*s%s%s: %s\n",
- ctx->cfg->config_source, lineno,
- len?"`":"", len, text, len?"'":"", newline,
- msg);
- if (!ctx->err) ctx->err= EINVAL;
-}
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-/*
- * libxlu_cfg_i.h - xl configuration file parsing: parser-internal declarations
- *
- * Copyright (C) 2010 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-
-#ifndef LIBXLU_CFG_I_H
-#define LIBXLU_CFG_I_H
-
-#include "libxlu_internal.h"
-#include "libxlu_cfg_y.h"
-
-void xlu__cfg_set_free(XLU_ConfigSetting *set);
-void xlu__cfg_set_store(CfgParseContext*, char *name,
- enum XLU_Operation op,
- XLU_ConfigValue *val, int lineno);
-XLU_ConfigValue *xlu__cfg_string_mk(CfgParseContext *ctx,
- char *atom, YYLTYPE *loc);
-XLU_ConfigValue *xlu__cfg_list_mk(CfgParseContext *ctx,
- XLU_ConfigValue *val,
- YYLTYPE *loc);
-void xlu__cfg_list_append(CfgParseContext *ctx,
- XLU_ConfigValue *list,
- XLU_ConfigValue *val);
-void xlu__cfg_value_free(XLU_ConfigValue *value);
-char *xlu__cfgl_strdup(CfgParseContext*, const char *src);
-char *xlu__cfgl_dequote(CfgParseContext*, const char *src);
-
-void xlu__cfg_yyerror(YYLTYPE *locp, CfgParseContext*, char const *msg);
-void xlu__cfgl_lexicalerror(CfgParseContext*, char const *msg);
-
-void xlu__cfgl_likely_python(CfgParseContext *ctx);
-
-
-
-/* Why oh why does bison not declare this in its autogenerated .h ? */
-int xlu__cfg_yyparse(CfgParseContext *ctx);
-
-
-#endif /*LIBXLU_CFG_I_H*/
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-#line 2 "libxlu_cfg_l.c"
-
-#line 4 "libxlu_cfg_l.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 6
-#define YY_FLEX_SUBMINOR_VERSION 4
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-#ifdef yy_create_buffer
-#define xlu__cfg_yy_create_buffer_ALREADY_DEFINED
-#else
-#define yy_create_buffer xlu__cfg_yy_create_buffer
-#endif
-
-#ifdef yy_delete_buffer
-#define xlu__cfg_yy_delete_buffer_ALREADY_DEFINED
-#else
-#define yy_delete_buffer xlu__cfg_yy_delete_buffer
-#endif
-
-#ifdef yy_scan_buffer
-#define xlu__cfg_yy_scan_buffer_ALREADY_DEFINED
-#else
-#define yy_scan_buffer xlu__cfg_yy_scan_buffer
-#endif
-
-#ifdef yy_scan_string
-#define xlu__cfg_yy_scan_string_ALREADY_DEFINED
-#else
-#define yy_scan_string xlu__cfg_yy_scan_string
-#endif
-
-#ifdef yy_scan_bytes
-#define xlu__cfg_yy_scan_bytes_ALREADY_DEFINED
-#else
-#define yy_scan_bytes xlu__cfg_yy_scan_bytes
-#endif
-
-#ifdef yy_init_buffer
-#define xlu__cfg_yy_init_buffer_ALREADY_DEFINED
-#else
-#define yy_init_buffer xlu__cfg_yy_init_buffer
-#endif
-
-#ifdef yy_flush_buffer
-#define xlu__cfg_yy_flush_buffer_ALREADY_DEFINED
-#else
-#define yy_flush_buffer xlu__cfg_yy_flush_buffer
-#endif
-
-#ifdef yy_load_buffer_state
-#define xlu__cfg_yy_load_buffer_state_ALREADY_DEFINED
-#else
-#define yy_load_buffer_state xlu__cfg_yy_load_buffer_state
-#endif
-
-#ifdef yy_switch_to_buffer
-#define xlu__cfg_yy_switch_to_buffer_ALREADY_DEFINED
-#else
-#define yy_switch_to_buffer xlu__cfg_yy_switch_to_buffer
-#endif
-
-#ifdef yypush_buffer_state
-#define xlu__cfg_yypush_buffer_state_ALREADY_DEFINED
-#else
-#define yypush_buffer_state xlu__cfg_yypush_buffer_state
-#endif
-
-#ifdef yypop_buffer_state
-#define xlu__cfg_yypop_buffer_state_ALREADY_DEFINED
-#else
-#define yypop_buffer_state xlu__cfg_yypop_buffer_state
-#endif
-
-#ifdef yyensure_buffer_stack
-#define xlu__cfg_yyensure_buffer_stack_ALREADY_DEFINED
-#else
-#define yyensure_buffer_stack xlu__cfg_yyensure_buffer_stack
-#endif
-
-#ifdef yylex
-#define xlu__cfg_yylex_ALREADY_DEFINED
-#else
-#define yylex xlu__cfg_yylex
-#endif
-
-#ifdef yyrestart
-#define xlu__cfg_yyrestart_ALREADY_DEFINED
-#else
-#define yyrestart xlu__cfg_yyrestart
-#endif
-
-#ifdef yylex_init
-#define xlu__cfg_yylex_init_ALREADY_DEFINED
-#else
-#define yylex_init xlu__cfg_yylex_init
-#endif
-
-#ifdef yylex_init_extra
-#define xlu__cfg_yylex_init_extra_ALREADY_DEFINED
-#else
-#define yylex_init_extra xlu__cfg_yylex_init_extra
-#endif
-
-#ifdef yylex_destroy
-#define xlu__cfg_yylex_destroy_ALREADY_DEFINED
-#else
-#define yylex_destroy xlu__cfg_yylex_destroy
-#endif
-
-#ifdef yyget_debug
-#define xlu__cfg_yyget_debug_ALREADY_DEFINED
-#else
-#define yyget_debug xlu__cfg_yyget_debug
-#endif
-
-#ifdef yyset_debug
-#define xlu__cfg_yyset_debug_ALREADY_DEFINED
-#else
-#define yyset_debug xlu__cfg_yyset_debug
-#endif
-
-#ifdef yyget_extra
-#define xlu__cfg_yyget_extra_ALREADY_DEFINED
-#else
-#define yyget_extra xlu__cfg_yyget_extra
-#endif
-
-#ifdef yyset_extra
-#define xlu__cfg_yyset_extra_ALREADY_DEFINED
-#else
-#define yyset_extra xlu__cfg_yyset_extra
-#endif
-
-#ifdef yyget_in
-#define xlu__cfg_yyget_in_ALREADY_DEFINED
-#else
-#define yyget_in xlu__cfg_yyget_in
-#endif
-
-#ifdef yyset_in
-#define xlu__cfg_yyset_in_ALREADY_DEFINED
-#else
-#define yyset_in xlu__cfg_yyset_in
-#endif
-
-#ifdef yyget_out
-#define xlu__cfg_yyget_out_ALREADY_DEFINED
-#else
-#define yyget_out xlu__cfg_yyget_out
-#endif
-
-#ifdef yyset_out
-#define xlu__cfg_yyset_out_ALREADY_DEFINED
-#else
-#define yyset_out xlu__cfg_yyset_out
-#endif
-
-#ifdef yyget_leng
-#define xlu__cfg_yyget_leng_ALREADY_DEFINED
-#else
-#define yyget_leng xlu__cfg_yyget_leng
-#endif
-
-#ifdef yyget_text
-#define xlu__cfg_yyget_text_ALREADY_DEFINED
-#else
-#define yyget_text xlu__cfg_yyget_text
-#endif
-
-#ifdef yyget_lineno
-#define xlu__cfg_yyget_lineno_ALREADY_DEFINED
-#else
-#define yyget_lineno xlu__cfg_yyget_lineno
-#endif
-
-#ifdef yyset_lineno
-#define xlu__cfg_yyset_lineno_ALREADY_DEFINED
-#else
-#define yyset_lineno xlu__cfg_yyset_lineno
-#endif
-
-#ifdef yyget_column
-#define xlu__cfg_yyget_column_ALREADY_DEFINED
-#else
-#define yyget_column xlu__cfg_yyget_column
-#endif
-
-#ifdef yyset_column
-#define xlu__cfg_yyset_column_ALREADY_DEFINED
-#else
-#define yyset_column xlu__cfg_yyset_column
-#endif
-
-#ifdef yywrap
-#define xlu__cfg_yywrap_ALREADY_DEFINED
-#else
-#define yywrap xlu__cfg_yywrap
-#endif
-
-#ifdef yyget_lval
-#define xlu__cfg_yyget_lval_ALREADY_DEFINED
-#else
-#define yyget_lval xlu__cfg_yyget_lval
-#endif
-
-#ifdef yyset_lval
-#define xlu__cfg_yyset_lval_ALREADY_DEFINED
-#else
-#define yyset_lval xlu__cfg_yyset_lval
-#endif
-
-#ifdef yyget_lloc
-#define xlu__cfg_yyget_lloc_ALREADY_DEFINED
-#else
-#define yyget_lloc xlu__cfg_yyget_lloc
-#endif
-
-#ifdef yyset_lloc
-#define xlu__cfg_yyset_lloc_ALREADY_DEFINED
-#else
-#define yyset_lloc xlu__cfg_yyset_lloc
-#endif
-
-#ifdef yyalloc
-#define xlu__cfg_yyalloc_ALREADY_DEFINED
-#else
-#define yyalloc xlu__cfg_yyalloc
-#endif
-
-#ifdef yyrealloc
-#define xlu__cfg_yyrealloc_ALREADY_DEFINED
-#else
-#define yyrealloc xlu__cfg_yyrealloc
-#endif
-
-#ifdef yyfree
-#define xlu__cfg_yyfree_ALREADY_DEFINED
-#else
-#define yyfree xlu__cfg_yyfree
-#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
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types.
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#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;
-
-/* 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
-
-#ifndef SIZE_MAX
-#define SIZE_MAX (~(size_t)0)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-/* begin standard C++ headers. */
-
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an
- * integer in range [0..255] for use as an array index.
- */
-#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
- are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* 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 yyg->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 ((yyg->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 yyrestart( yyin , yyscanner )
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
- /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
- * access to the local variable yy_act. Since yyless() is a macro, it would break
- * existing scanners that call yyless() from OUTSIDE yylex.
- * One obvious solution it to make yy_act a global. I tried that, and saw
- * a 5% performance hit in a non-yylineno scanner, because yy_act is
- * normally declared as a register variable-- so it is not worth it.
- */
- #define YY_LESS_LINENO(n) \
- do { \
- int yyl;\
- for ( yyl = n; yyl < yyleng; ++yyl )\
- if ( yytext[yyl] == '\n' )\
- --yylineno;\
- }while(0)
- #define YY_LINENO_REWIND_TO(dst) \
- do {\
- const char *p;\
- for ( p = yy_cp-1; p >= (dst); --p)\
- if ( *p == '\n' )\
- --yylineno;\
- }while(0)
-
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
- do \
- { \
- /* Undo effects of setting up yytext. */ \
- int yyless_macro_arg = (n); \
- YY_LESS_LINENO(yyless_macro_arg);\
- *yy_cp = yyg->yy_hold_char; \
- YY_RESTORE_YY_MORE_OFFSET \
- yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
- YY_DO_BEFORE_ACTION; /* set up yytext again */ \
- } \
- while ( 0 )
-#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-
-#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.
- */
- int 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 yyrestart()), so that the user can continue scanning by
- * just pointing yyin at a new input file.
- */
-#define YY_BUFFER_EOF_PENDING 2
-
- };
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* 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 ( yyg->yy_buffer_stack \
- ? yyg->yy_buffer_stack[yyg->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 yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-
-void yyrestart ( FILE *input_file , yyscan_t yyscanner );
-void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
-void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-void yypop_buffer_state ( yyscan_t yyscanner );
-
-static void yyensure_buffer_stack ( yyscan_t yyscanner );
-static void yy_load_buffer_state ( yyscan_t yyscanner );
-static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
-#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
-
-YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
-
-void *yyalloc ( yy_size_t , yyscan_t yyscanner );
-void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
-void yyfree ( void * , yyscan_t yyscanner );
-
-#define yy_new_buffer yy_create_buffer
-#define yy_set_interactive(is_interactive) \
- { \
- if ( ! YY_CURRENT_BUFFER ){ \
- yyensure_buffer_stack (yyscanner); \
- YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
- } \
- YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
- }
-#define yy_set_bol(at_bol) \
- { \
- if ( ! YY_CURRENT_BUFFER ){\
- yyensure_buffer_stack (yyscanner); \
- YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
- } \
- YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
- }
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-#define xlu__cfg_yywrap(yyscanner) (/*CONSTCOND*/1)
-#define YY_SKIP_YYWRAP
-typedef flex_uint8_t YY_CHAR;
-
-typedef int yy_state_type;
-
-#define yytext_ptr yytext_r
-
-static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
-static int yy_get_next_buffer ( yyscan_t yyscanner );
-static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
- yyg->yytext_ptr = yy_bp; \
- yyg->yytext_ptr -= yyg->yy_more_len; \
- yyleng = (int) (yy_cp - yyg->yytext_ptr); \
- yyg->yy_hold_char = *yy_cp; \
- *yy_cp = '\0'; \
- yyg->yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 17
-#define YY_END_OF_BUFFER 18
-/* 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 const flex_int16_t yy_accept[37] =
- { 0,
- 0, 0, 15, 15, 18, 14, 3, 10, 14, 14,
- 14, 13, 13, 4, 2, 9, 8, 5, 6, 1,
- 15, 15, 16, 0, 12, 0, 0, 10, 0, 11,
- 0, 7, 2, 1, 15, 0
- } ;
-
-static const YY_CHAR 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, 1, 4, 5, 1, 1, 1, 6, 7,
- 7, 1, 8, 9, 7, 10, 1, 11, 11, 11,
- 11, 11, 11, 11, 11, 11, 11, 7, 12, 1,
- 13, 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,
- 14, 15, 16, 1, 17, 1, 18, 18, 18, 18,
-
- 18, 18, 19, 19, 19, 19, 19, 19, 19, 19,
- 19, 19, 19, 19, 19, 19, 19, 19, 19, 18,
- 19, 19, 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, 1, 1
- } ;
-
-static const YY_CHAR yy_meta[20] =
- { 0,
- 1, 2, 3, 1, 1, 1, 1, 1, 1, 4,
- 4, 1, 1, 1, 1, 1, 4, 4, 4
- } ;
-
-static const flex_int16_t yy_base[43] =
- { 0,
- 0, 0, 18, 20, 53, 59, 59, 59, 20, 42,
- 19, 59, 19, 59, 15, 59, 59, 59, 59, 0,
- 0, 59, 59, 23, 59, 0, 28, 59, 22, 59,
- 0, 59, 18, 0, 0, 59, 38, 42, 46, 50,
- 26, 54
- } ;
-
-static const flex_int16_t yy_def[43] =
- { 0,
- 36, 1, 37, 37, 36, 36, 36, 36, 38, 39,
- 40, 36, 36, 36, 36, 36, 36, 36, 36, 41,
- 42, 36, 36, 38, 36, 38, 39, 36, 40, 36,
- 40, 36, 36, 41, 42, 0, 36, 36, 36, 36,
- 36, 36
- } ;
-
-static const flex_int16_t yy_nxt[79] =
- { 0,
- 6, 7, 8, 9, 10, 11, 12, 13, 14, 12,
- 15, 16, 17, 18, 6, 19, 6, 20, 20, 22,
- 23, 22, 23, 25, 30, 33, 25, 30, 33, 34,
- 28, 32, 33, 31, 26, 33, 31, 26, 21, 21,
- 21, 21, 24, 24, 28, 24, 27, 27, 27, 27,
- 29, 29, 36, 29, 35, 36, 36, 35, 5, 36,
- 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
- 36, 36, 36, 36, 36, 36, 36, 36
- } ;
-
-static const flex_int16_t yy_chk[79] =
- { 0,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
- 3, 4, 4, 9, 11, 15, 24, 29, 33, 41,
- 27, 13, 15, 11, 9, 33, 29, 24, 37, 37,
- 37, 37, 38, 38, 10, 38, 39, 39, 39, 39,
- 40, 40, 5, 40, 42, 0, 0, 42, 36, 36,
- 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
- 36, 36, 36, 36, 36, 36, 36, 36
- } ;
-
-/* Table of booleans, true if rule could match eol. */
-static const flex_int32_t yy_rule_can_match_eol[18] =
- { 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 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() (yyg->yy_more_flag = 1)
-#define YY_MORE_ADJ yyg->yy_more_len
-#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "libxlu_cfg_l.l"
-/* -*- fundamental -*- */
-/*
- * libxlu_cfg_l.l - xl configuration file parsing: lexer
- *
- * Copyright (C) 2010 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-#line 20 "libxlu_cfg_l.l"
-#include "libxlu_cfg_i.h"
-
-#define ctx ((CfgParseContext*)yyextra)
-#define YY_NO_INPUT
-
-#define GOT(x) do{ \
- yylloc->first_line= yylineno; \
- return (x); \
- }while(0)
-
-/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
- * it to fail to declare these functions, which it defines. So declare
- * them ourselves. Hopefully we won't have to simultaneously support
- * a flex version which declares these differently somehow. */
-int xlu__cfg_yyget_column(yyscan_t yyscanner);
-void xlu__cfg_yyset_column(int column_no, yyscan_t yyscanner);
-
-#line 740 "libxlu_cfg_l.c"
-
-#line 742 "libxlu_cfg_l.c"
-
-#define INITIAL 0
-#define lexerr 1
-
-#ifndef YY_NO_UNISTD_H
-/* 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>
-#endif
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-/* Holds the entire state of the reentrant scanner. */
-struct yyguts_t
- {
-
- /* User-defined. Not touched by flex. */
- YY_EXTRA_TYPE yyextra_r;
-
- /* The rest are the same as the globals declared in the non-reentrant scanner. */
- FILE *yyin_r, *yyout_r;
- size_t yy_buffer_stack_top; /**< index of top of stack. */
- size_t yy_buffer_stack_max; /**< capacity of stack. */
- YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
- char yy_hold_char;
- int yy_n_chars;
- int yyleng_r;
- char *yy_c_buf_p;
- int yy_init;
- int yy_start;
- int yy_did_buffer_switch_on_eof;
- int yy_start_stack_ptr;
- int yy_start_stack_depth;
- int *yy_start_stack;
- yy_state_type yy_last_accepting_state;
- char* yy_last_accepting_cpos;
-
- int yylineno_r;
- int yy_flex_debug_r;
-
- char *yytext_r;
- int yy_more_flag;
- int yy_more_len;
-
- YYSTYPE * yylval_r;
-
- YYLTYPE * yylloc_r;
-
- }; /* end struct yyguts_t */
-
-static int yy_init_globals ( yyscan_t yyscanner );
-
- /* This must go here because YYSTYPE and YYLTYPE are included
- * from bison output in section 1.*/
- # define yylval yyg->yylval_r
-
- # define yylloc yyg->yylloc_r
-
-int yylex_init (yyscan_t* scanner);
-
-int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
-
-/* Accessor methods to globals.
- These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy ( yyscan_t yyscanner );
-
-int yyget_debug ( yyscan_t yyscanner );
-
-void yyset_debug ( int debug_flag , yyscan_t yyscanner );
-
-YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
-
-void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
-
-FILE *yyget_in ( yyscan_t yyscanner );
-
-void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
-
-FILE *yyget_out ( yyscan_t yyscanner );
-
-void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
-
- int yyget_leng ( yyscan_t yyscanner );
-
-char *yyget_text ( yyscan_t yyscanner );
-
-int yyget_lineno ( yyscan_t yyscanner );
-
-void yyset_lineno ( int _line_number , yyscan_t yyscanner );
-
-int yyget_column ( yyscan_t yyscanner );
-
-void yyset_column ( int _column_no , yyscan_t yyscanner );
-
-YYSTYPE * yyget_lval ( yyscan_t yyscanner );
-
-void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
-
- YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
-
- void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap ( yyscan_t yyscanner );
-#else
-extern int yywrap ( yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef YY_NO_UNPUT
-
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput ( yyscan_t yyscanner );
-#else
-static int input ( yyscan_t yyscanner );
-#endif
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#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 do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
-#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) \
- if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
- { \
- int c = '*'; \
- int n; \
- for ( n = 0; n < max_size && \
- (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
- buf[n] = (char) c; \
- if ( c == '\n' ) \
- buf[n++] = (char) c; \
- if ( c == EOF && ferror( yyin ) ) \
- YY_FATAL_ERROR( "input in flex scanner failed" ); \
- result = n; \
- } \
- else \
- { \
- errno=0; \
- while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
- { \
- if( errno != EINTR) \
- { \
- YY_FATAL_ERROR( "input in flex scanner failed" ); \
- break; \
- } \
- errno=0; \
- clearerr(yyin); \
- } \
- }\
-\
-
-#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 , yyscanner)
-#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 yylex \
- (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
-
-#define YY_DECL int yylex \
- (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * 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 /*LINTED*/break;
-#endif
-
-#define YY_RULE_SETUP \
- YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
- yy_state_type yy_current_state;
- char *yy_cp, *yy_bp;
- int yy_act;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- yylval = yylval_param;
-
- yylloc = yylloc_param;
-
- if ( !yyg->yy_init )
- {
- yyg->yy_init = 1;
-
-#ifdef YY_USER_INIT
- YY_USER_INIT;
-#endif
-
- if ( ! yyg->yy_start )
- yyg->yy_start = 1; /* first start state */
-
- if ( ! yyin )
- yyin = stdin;
-
- if ( ! yyout )
- yyout = stdout;
-
- if ( ! YY_CURRENT_BUFFER ) {
- yyensure_buffer_stack (yyscanner);
- YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
- }
-
- yy_load_buffer_state( yyscanner );
- }
-
- {
-#line 53 "libxlu_cfg_l.l"
-
-
-#line 1028 "libxlu_cfg_l.c"
-
- while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
- {
- yyg->yy_more_len = 0;
- if ( yyg->yy_more_flag )
- {
- yyg->yy_more_len = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
- yyg->yy_more_flag = 0;
- }
- yy_cp = yyg->yy_c_buf_p;
-
- /* Support of yytext. */
- *yy_cp = yyg->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 = yyg->yy_start;
-yy_match:
- do
- {
- YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
- if ( yy_accept[yy_current_state] )
- {
- yyg->yy_last_accepting_state = yy_current_state;
- yyg->yy_last_accepting_cpos = yy_cp;
- }
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 37 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- ++yy_cp;
- }
- while ( yy_current_state != 36 );
- yy_cp = yyg->yy_last_accepting_cpos;
- yy_current_state = yyg->yy_last_accepting_state;
-
-yy_find_action:
- yy_act = yy_accept[yy_current_state];
-
- YY_DO_BEFORE_ACTION;
-
- if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
- {
- int yyl;
- for ( yyl = yyg->yy_more_len; yyl < yyleng; ++yyl )
- if ( yytext[yyl] == '\n' )
-
- do{ yylineno++;
- yycolumn=0;
- }while(0)
-;
- }
-
-do_action: /* This label is used only to access EOF actions. */
-
- switch ( yy_act )
- { /* beginning of action switch */
- case 0: /* must back up */
- /* undo the effects of YY_DO_BEFORE_ACTION */
- *yy_cp = yyg->yy_hold_char;
- yy_cp = yyg->yy_last_accepting_cpos;
- yy_current_state = yyg->yy_last_accepting_state;
- goto yy_find_action;
-
-case 1:
-YY_RULE_SETUP
-#line 55 "libxlu_cfg_l.l"
-{
- yylval->string= xlu__cfgl_strdup(ctx,yytext);
- GOT(IDENT);
- }
- YY_BREAK
-case 2:
-YY_RULE_SETUP
-#line 59 "libxlu_cfg_l.l"
-{
- yylval->string= xlu__cfgl_strdup(ctx,yytext);
- GOT(NUMBER);
- }
- YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 64 "libxlu_cfg_l.l"
-
- YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 66 "libxlu_cfg_l.l"
-{ GOT(','); }
- YY_BREAK
-case 5:
-YY_RULE_SETUP
-#line 67 "libxlu_cfg_l.l"
-{ GOT('['); }
- YY_BREAK
-case 6:
-YY_RULE_SETUP
-#line 68 "libxlu_cfg_l.l"
-{ GOT(']'); }
- YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 69 "libxlu_cfg_l.l"
-{ GOT(OP_ADD); }
- YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 70 "libxlu_cfg_l.l"
-{ GOT('='); }
- YY_BREAK
-case 9:
-YY_RULE_SETUP
-#line 71 "libxlu_cfg_l.l"
-{ GOT(';'); }
- YY_BREAK
-case 10:
-/* rule 10 can match eol */
-YY_RULE_SETUP
-#line 73 "libxlu_cfg_l.l"
-{ yylloc->first_line= yylineno-1; return NEWLINE; }
- YY_BREAK
-case 11:
-YY_RULE_SETUP
-#line 75 "libxlu_cfg_l.l"
-{
- yylval->string= xlu__cfgl_dequote(ctx,yytext);
- GOT(STRING);
- }
- YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 79 "libxlu_cfg_l.l"
-{
- yylval->string= xlu__cfgl_dequote(ctx,yytext);
- GOT(STRING);
- }
- YY_BREAK
-case 13:
-YY_RULE_SETUP
-#line 84 "libxlu_cfg_l.l"
-{
- ctx->likely_python= 1;
- BEGIN(lexerr);
- yymore();
- }
- YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 90 "libxlu_cfg_l.l"
-{
- BEGIN(lexerr);
- yymore();
- }
- YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 95 "libxlu_cfg_l.l"
-{
- xlu__cfgl_lexicalerror(ctx,"lexical error");
- BEGIN(0);
- }
- YY_BREAK
-case 16:
-/* rule 16 can match eol */
-YY_RULE_SETUP
-#line 100 "libxlu_cfg_l.l"
-{
- xlu__cfgl_lexicalerror(ctx,"lexical error");
- BEGIN(0);
- GOT(NEWLINE);
- }
- YY_BREAK
-case 17:
-YY_RULE_SETUP
-#line 105 "libxlu_cfg_l.l"
-YY_FATAL_ERROR( "flex scanner jammed" );
- YY_BREAK
-#line 1212 "libxlu_cfg_l.c"
-case YY_STATE_EOF(INITIAL):
-case YY_STATE_EOF(lexerr):
- yyterminate();
-
- case YY_END_OF_BUFFER:
- {
- /* Amount of text matched not including the EOB char. */
- int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
-
- /* Undo the effects of YY_DO_BEFORE_ACTION. */
- *yy_cp = yyg->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 yyin at a new source and called
- * yylex(). 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.
- */
- yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
- YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
- 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 ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
- { /* This was really a NUL. */
- yy_state_type yy_next_state;
-
- yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
-
- yy_current_state = yy_get_previous_state( yyscanner );
-
- /* 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 , yyscanner);
-
- yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-
- if ( yy_next_state )
- {
- /* Consume the NUL. */
- yy_cp = ++yyg->yy_c_buf_p;
- yy_current_state = yy_next_state;
- goto yy_match;
- }
-
- else
- {
- yy_cp = yyg->yy_last_accepting_cpos;
- yy_current_state = yyg->yy_last_accepting_state;
- goto yy_find_action;
- }
- }
-
- else switch ( yy_get_next_buffer( yyscanner ) )
- {
- case EOB_ACT_END_OF_FILE:
- {
- yyg->yy_did_buffer_switch_on_eof = 0;
-
- if ( yywrap( yyscanner ) )
- {
- /* Note: because we've taken care in
- * yy_get_next_buffer() to have set up
- * yytext, 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.
- */
- yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
-
- yy_act = YY_STATE_EOF(YY_START);
- goto do_action;
- }
-
- else
- {
- if ( ! yyg->yy_did_buffer_switch_on_eof )
- YY_NEW_FILE;
- }
- break;
- }
-
- case EOB_ACT_CONTINUE_SCAN:
- yyg->yy_c_buf_p =
- yyg->yytext_ptr + yy_amount_of_matched_text;
-
- yy_current_state = yy_get_previous_state( yyscanner );
-
- yy_cp = yyg->yy_c_buf_p;
- yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
- goto yy_match;
-
- case EOB_ACT_LAST_MATCH:
- yyg->yy_c_buf_p =
- &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
-
- yy_current_state = yy_get_previous_state( yyscanner );
-
- yy_cp = yyg->yy_c_buf_p;
- yy_bp = yyg->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 user's declarations */
-} /* end of yylex */
-
-/* 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 (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
- char *source = yyg->yytext_ptr;
- int number_to_move, i;
- int ret_val;
-
- if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->yy_n_chars = 0;
-
- else
- {
- int 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_LVALUE;
-
- int yy_c_buf_p_offset =
- (int) (yyg->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. */
- yyrealloc( (void *) b->yy_ch_buf,
- (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
- }
- else
- /* Can't grow it, we don't own it. */
- b->yy_ch_buf = NULL;
-
- if ( ! b->yy_ch_buf )
- YY_FATAL_ERROR(
- "fatal error - scanner input buffer overflow" );
-
- yyg->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]),
- yyg->yy_n_chars, num_to_read );
-
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
- }
-
- if ( yyg->yy_n_chars == 0 )
- {
- if ( number_to_move == YY_MORE_ADJ )
- {
- ret_val = EOB_ACT_END_OF_FILE;
- yyrestart( yyin , yyscanner);
- }
-
- 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;
-
- if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
- /* Extend the array by 50%, plus the number we really need. */
- int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
- (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
- if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
- /* "- 2" to take care of EOB's */
- YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
- }
-
- yyg->yy_n_chars += number_to_move;
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
- yyg->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 (yyscan_t yyscanner)
-{
- yy_state_type yy_current_state;
- char *yy_cp;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- yy_current_state = yyg->yy_start;
-
- for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
- {
- YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
- if ( yy_accept[yy_current_state] )
- {
- yyg->yy_last_accepting_state = yy_current_state;
- yyg->yy_last_accepting_cpos = yy_cp;
- }
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 37 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- }
-
- 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 , yyscan_t yyscanner)
-{
- int yy_is_jam;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
- char *yy_cp = yyg->yy_c_buf_p;
-
- YY_CHAR yy_c = 1;
- if ( yy_accept[yy_current_state] )
- {
- yyg->yy_last_accepting_state = yy_current_state;
- yyg->yy_last_accepting_cpos = yy_cp;
- }
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 37 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- yy_is_jam = (yy_current_state == 36);
-
- (void)yyg;
- return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_UNPUT
-
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
- static int yyinput (yyscan_t yyscanner)
-#else
- static int input (yyscan_t yyscanner)
-#endif
-
-{
- int c;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- *yyg->yy_c_buf_p = yyg->yy_hold_char;
-
- if ( *yyg->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 ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
- /* This was really a NUL. */
- *yyg->yy_c_buf_p = '\0';
-
- else
- { /* need more input */
- int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
- ++yyg->yy_c_buf_p;
-
- switch ( yy_get_next_buffer( yyscanner ) )
- {
- 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. */
- yyrestart( yyin , yyscanner);
-
- /*FALLTHROUGH*/
-
- case EOB_ACT_END_OF_FILE:
- {
- if ( yywrap( yyscanner ) )
- return 0;
-
- if ( ! yyg->yy_did_buffer_switch_on_eof )
- YY_NEW_FILE;
-#ifdef __cplusplus
- return yyinput(yyscanner);
-#else
- return input(yyscanner);
-#endif
- }
-
- case EOB_ACT_CONTINUE_SCAN:
- yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
- break;
- }
- }
- }
-
- c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
- *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
- yyg->yy_hold_char = *++yyg->yy_c_buf_p;
-
- if ( c == '\n' )
-
- do{ yylineno++;
- yycolumn=0;
- }while(0)
-;
-
- return c;
-}
-#endif /* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * @param yyscanner The scanner object.
- * @note This function does not reset the start condition to @c INITIAL .
- */
- void yyrestart (FILE * input_file , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if ( ! YY_CURRENT_BUFFER ){
- yyensure_buffer_stack (yyscanner);
- YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
- }
-
- yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
- yy_load_buffer_state( yyscanner );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * @param yyscanner The scanner object.
- */
- void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* TODO. We should be able to replace this entire function body
- * with
- * yypop_buffer_state();
- * yypush_buffer_state(new_buffer);
- */
- yyensure_buffer_stack (yyscanner);
- if ( YY_CURRENT_BUFFER == new_buffer )
- return;
-
- if ( YY_CURRENT_BUFFER )
- {
- /* Flush out information for old buffer. */
- *yyg->yy_c_buf_p = yyg->yy_hold_char;
- YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
- }
-
- YY_CURRENT_BUFFER_LVALUE = new_buffer;
- yy_load_buffer_state( yyscanner );
-
- /* We don't actually know whether we did this switch during
- * EOF (yywrap()) processing, but the only time this flag
- * is looked at is after yywrap() is called, so it's safe
- * to go ahead and always set it.
- */
- yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-static void yy_load_buffer_state (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
- yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
- yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
- yyg->yy_hold_char = *yyg->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.
- * @param yyscanner The scanner object.
- * @return the allocated buffer state.
- */
- YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
-{
- YY_BUFFER_STATE b;
-
- b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
- if ( ! b )
- YY_FATAL_ERROR( "out of dynamic memory in yy_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 *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
- if ( ! b->yy_ch_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
- b->yy_is_our_buffer = 1;
-
- yy_init_buffer( b, file , yyscanner);
-
- return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with yy_create_buffer()
- * @param yyscanner The scanner object.
- */
- void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- 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 )
- yyfree( (void *) b->yy_ch_buf , yyscanner );
-
- yyfree( (void *) b , yyscanner );
-}
-
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a yyrestart() or at EOF.
- */
- static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
-
-{
- int oerrno = errno;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- yy_flush_buffer( b , yyscanner);
-
- b->yy_input_file = file;
- b->yy_fill_buffer = 1;
-
- /* If b is the current buffer, then yy_init_buffer was _probably_
- * called from yyrestart() 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 = file ? (isatty( fileno(file) ) > 0) : 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.
- * @param yyscanner The scanner object.
- */
- void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- 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 )
- yy_load_buffer_state( yyscanner );
-}
-
-/** 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.
- * @param yyscanner The scanner object.
- */
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- if (new_buffer == NULL)
- return;
-
- yyensure_buffer_stack(yyscanner);
-
- /* This block is copied from yy_switch_to_buffer. */
- if ( YY_CURRENT_BUFFER )
- {
- /* Flush out information for old buffer. */
- *yyg->yy_c_buf_p = yyg->yy_hold_char;
- YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
- }
-
- /* Only push if top exists. Otherwise, replace top. */
- if (YY_CURRENT_BUFFER)
- yyg->yy_buffer_stack_top++;
- YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
- /* copied from yy_switch_to_buffer. */
- yy_load_buffer_state( yyscanner );
- yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- * The next element becomes the new top.
- * @param yyscanner The scanner object.
- */
-void yypop_buffer_state (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- if (!YY_CURRENT_BUFFER)
- return;
-
- yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
- YY_CURRENT_BUFFER_LVALUE = NULL;
- if (yyg->yy_buffer_stack_top > 0)
- --yyg->yy_buffer_stack_top;
-
- if (YY_CURRENT_BUFFER) {
- yy_load_buffer_state( yyscanner );
- yyg->yy_did_buffer_switch_on_eof = 1;
- }
-}
-
-/* Allocates the stack if it does not exist.
- * Guarantees space for at least one push.
- */
-static void yyensure_buffer_stack (yyscan_t yyscanner)
-{
- yy_size_t num_to_alloc;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if (!yyg->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; /* After all that talk, this was set to 1 anyways... */
- yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
- (num_to_alloc * sizeof(struct yy_buffer_state*)
- , yyscanner);
- if ( ! yyg->yy_buffer_stack )
- YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
- memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-
- yyg->yy_buffer_stack_max = num_to_alloc;
- yyg->yy_buffer_stack_top = 0;
- return;
- }
-
- if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
-
- /* Increase the buffer to prepare for a possible push. */
- yy_size_t grow_size = 8 /* arbitrary grow size */;
-
- num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
- yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
- (yyg->yy_buffer_stack,
- num_to_alloc * sizeof(struct yy_buffer_state*)
- , yyscanner);
- if ( ! yyg->yy_buffer_stack )
- YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
- /* zero only the new slots.*/
- memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
- yyg->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
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
-{
- 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 NULL;
-
- b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
- if ( ! b )
- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
-
- b->yy_buf_size = (int) (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 = NULL;
- 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;
-
- yy_switch_to_buffer( b , yyscanner );
-
- return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- * yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
-{
-
- return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
-{
- YY_BUFFER_STATE b;
- char *buf;
- yy_size_t n;
- int i;
-
- /* Get memory for full buffer, including space for trailing EOB's. */
- n = (yy_size_t) (_yybytes_len + 2);
- buf = (char *) yyalloc( n , yyscanner );
- if ( ! buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-
- for ( i = 0; i < _yybytes_len; ++i )
- buf[i] = yybytes[i];
-
- buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
- b = yy_scan_buffer( buf, n , yyscanner);
- if ( ! b )
- YY_FATAL_ERROR( "bad buffer in yy_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 yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
- 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 yytext. */ \
- int yyless_macro_arg = (n); \
- YY_LESS_LINENO(yyless_macro_arg);\
- yytext[yyleng] = yyg->yy_hold_char; \
- yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
- yyg->yy_hold_char = *yyg->yy_c_buf_p; \
- *yyg->yy_c_buf_p = '\0'; \
- yyleng = yyless_macro_arg; \
- } \
- while ( 0 )
-
-/* Accessor methods (get/set functions) to struct members. */
-
-/** Get the user-defined data for this scanner.
- * @param yyscanner The scanner object.
- */
-YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyextra;
-}
-
-/** Get the current line number.
- * @param yyscanner The scanner object.
- */
-int yyget_lineno (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if (! YY_CURRENT_BUFFER)
- return 0;
-
- return yylineno;
-}
-
-/** Get the current column number.
- * @param yyscanner The scanner object.
- */
-int yyget_column (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if (! YY_CURRENT_BUFFER)
- return 0;
-
- return yycolumn;
-}
-
-/** Get the input stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_in (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyin;
-}
-
-/** Get the output stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_out (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyout;
-}
-
-/** Get the length of the current token.
- * @param yyscanner The scanner object.
- */
-int yyget_leng (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyleng;
-}
-
-/** Get the current token.
- * @param yyscanner The scanner object.
- */
-
-char *yyget_text (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yytext;
-}
-
-/** Set the user-defined data. This data is never touched by the scanner.
- * @param user_defined The data to be associated with this scanner.
- * @param yyscanner The scanner object.
- */
-void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyextra = user_defined ;
-}
-
-/** Set the current line number.
- * @param _line_number line number
- * @param yyscanner The scanner object.
- */
-void yyset_lineno (int _line_number , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* lineno is only valid if an input buffer exists. */
- if (! YY_CURRENT_BUFFER )
- YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
-
- yylineno = _line_number;
-}
-
-/** Set the current column.
- * @param _column_no column number
- * @param yyscanner The scanner object.
- */
-void yyset_column (int _column_no , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* column is only valid if an input buffer exists. */
- if (! YY_CURRENT_BUFFER )
- YY_FATAL_ERROR( "yyset_column called with no buffer" );
-
- yycolumn = _column_no;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param _in_str A readable stream.
- * @param yyscanner The scanner object.
- * @see yy_switch_to_buffer
- */
-void yyset_in (FILE * _in_str , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyin = _in_str ;
-}
-
-void yyset_out (FILE * _out_str , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyout = _out_str ;
-}
-
-int yyget_debug (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yy_flex_debug;
-}
-
-void yyset_debug (int _bdebug , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yy_flex_debug = _bdebug ;
-}
-
-/* Accessor methods for yylval and yylloc */
-
-YYSTYPE * yyget_lval (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yylval;
-}
-
-void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yylval = yylval_param;
-}
-
-YYLTYPE *yyget_lloc (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yylloc;
-}
-
-void yyset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yylloc = yylloc_param;
-}
-
-/* User-visible API */
-
-/* yylex_init is special because it creates the scanner itself, so it is
- * the ONLY reentrant function that doesn't take the scanner as the last argument.
- * That's why we explicitly handle the declaration, instead of using our macros.
- */
-int yylex_init(yyscan_t* ptr_yy_globals)
-{
- if (ptr_yy_globals == NULL){
- errno = EINVAL;
- return 1;
- }
-
- *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
-
- if (*ptr_yy_globals == NULL){
- errno = ENOMEM;
- return 1;
- }
-
- /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
- memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
- return yy_init_globals ( *ptr_yy_globals );
-}
-
-/* yylex_init_extra has the same functionality as yylex_init, but follows the
- * convention of taking the scanner as the last argument. Note however, that
- * this is a *pointer* to a scanner, as it will be allocated by this call (and
- * is the reason, too, why this function also must handle its own declaration).
- * The user defined value in the first argument will be available to yyalloc in
- * the yyextra field.
- */
-int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
-{
- struct yyguts_t dummy_yyguts;
-
- yyset_extra (yy_user_defined, &dummy_yyguts);
-
- if (ptr_yy_globals == NULL){
- errno = EINVAL;
- return 1;
- }
-
- *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-
- if (*ptr_yy_globals == NULL){
- errno = ENOMEM;
- return 1;
- }
-
- /* By setting to 0xAA, we expose bugs in
- yy_init_globals. Leave at 0x00 for releases. */
- memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
- yyset_extra (yy_user_defined, *ptr_yy_globals);
-
- return yy_init_globals ( *ptr_yy_globals );
-}
-
-static int yy_init_globals (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- /* Initialization is the same as for the non-reentrant scanner.
- * This function is called from yylex_destroy(), so don't allocate here.
- */
-
- yyg->yy_buffer_stack = NULL;
- yyg->yy_buffer_stack_top = 0;
- yyg->yy_buffer_stack_max = 0;
- yyg->yy_c_buf_p = NULL;
- yyg->yy_init = 0;
- yyg->yy_start = 0;
-
- yyg->yy_start_stack_ptr = 0;
- yyg->yy_start_stack_depth = 0;
- yyg->yy_start_stack = NULL;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
- yyin = stdin;
- yyout = stdout;
-#else
- yyin = NULL;
- yyout = NULL;
-#endif
-
- /* For future reference: Set errno on error, since we are called by
- * yylex_init()
- */
- return 0;
-}
-
-/* yylex_destroy is for both reentrant and non-reentrant scanners. */
-int yylex_destroy (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* Pop the buffer stack, destroying each element. */
- while(YY_CURRENT_BUFFER){
- yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
- YY_CURRENT_BUFFER_LVALUE = NULL;
- yypop_buffer_state(yyscanner);
- }
-
- /* Destroy the stack itself. */
- yyfree(yyg->yy_buffer_stack , yyscanner);
- yyg->yy_buffer_stack = NULL;
-
- /* Destroy the start condition stack. */
- yyfree( yyg->yy_start_stack , yyscanner );
- yyg->yy_start_stack = NULL;
-
- /* Reset the globals. This is important in a non-reentrant scanner so the next time
- * yylex() is called, initialization will occur. */
- yy_init_globals( yyscanner);
-
- /* Destroy the main struct (reentrant only). */
- yyfree ( yyscanner , yyscanner );
- yyscanner = NULL;
- return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
-
- int i;
- for ( i = 0; i < n; ++i )
- s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
-{
- int n;
- for ( n = 0; s[n]; ++n )
- ;
-
- return n;
-}
-#endif
-
-void *yyalloc (yy_size_t size , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
- return malloc(size);
-}
-
-void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
-
- /* 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 realloc(ptr, size);
-}
-
-void yyfree (void * ptr , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
- free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
-}
-
-#define YYTABLES_NAME "yytables"
-
-#line 105 "libxlu_cfg_l.l"
+++ /dev/null
-#ifndef xlu__cfg_yyHEADER_H
-#define xlu__cfg_yyHEADER_H 1
-#define xlu__cfg_yyIN_HEADER 1
-
-#line 6 "libxlu_cfg_l.h"
-
-#line 8 "libxlu_cfg_l.h"
-
-#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 6
-#define YY_FLEX_SUBMINOR_VERSION 4
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-#ifdef yy_create_buffer
-#define xlu__cfg_yy_create_buffer_ALREADY_DEFINED
-#else
-#define yy_create_buffer xlu__cfg_yy_create_buffer
-#endif
-
-#ifdef yy_delete_buffer
-#define xlu__cfg_yy_delete_buffer_ALREADY_DEFINED
-#else
-#define yy_delete_buffer xlu__cfg_yy_delete_buffer
-#endif
-
-#ifdef yy_scan_buffer
-#define xlu__cfg_yy_scan_buffer_ALREADY_DEFINED
-#else
-#define yy_scan_buffer xlu__cfg_yy_scan_buffer
-#endif
-
-#ifdef yy_scan_string
-#define xlu__cfg_yy_scan_string_ALREADY_DEFINED
-#else
-#define yy_scan_string xlu__cfg_yy_scan_string
-#endif
-
-#ifdef yy_scan_bytes
-#define xlu__cfg_yy_scan_bytes_ALREADY_DEFINED
-#else
-#define yy_scan_bytes xlu__cfg_yy_scan_bytes
-#endif
-
-#ifdef yy_init_buffer
-#define xlu__cfg_yy_init_buffer_ALREADY_DEFINED
-#else
-#define yy_init_buffer xlu__cfg_yy_init_buffer
-#endif
-
-#ifdef yy_flush_buffer
-#define xlu__cfg_yy_flush_buffer_ALREADY_DEFINED
-#else
-#define yy_flush_buffer xlu__cfg_yy_flush_buffer
-#endif
-
-#ifdef yy_load_buffer_state
-#define xlu__cfg_yy_load_buffer_state_ALREADY_DEFINED
-#else
-#define yy_load_buffer_state xlu__cfg_yy_load_buffer_state
-#endif
-
-#ifdef yy_switch_to_buffer
-#define xlu__cfg_yy_switch_to_buffer_ALREADY_DEFINED
-#else
-#define yy_switch_to_buffer xlu__cfg_yy_switch_to_buffer
-#endif
-
-#ifdef yypush_buffer_state
-#define xlu__cfg_yypush_buffer_state_ALREADY_DEFINED
-#else
-#define yypush_buffer_state xlu__cfg_yypush_buffer_state
-#endif
-
-#ifdef yypop_buffer_state
-#define xlu__cfg_yypop_buffer_state_ALREADY_DEFINED
-#else
-#define yypop_buffer_state xlu__cfg_yypop_buffer_state
-#endif
-
-#ifdef yyensure_buffer_stack
-#define xlu__cfg_yyensure_buffer_stack_ALREADY_DEFINED
-#else
-#define yyensure_buffer_stack xlu__cfg_yyensure_buffer_stack
-#endif
-
-#ifdef yylex
-#define xlu__cfg_yylex_ALREADY_DEFINED
-#else
-#define yylex xlu__cfg_yylex
-#endif
-
-#ifdef yyrestart
-#define xlu__cfg_yyrestart_ALREADY_DEFINED
-#else
-#define yyrestart xlu__cfg_yyrestart
-#endif
-
-#ifdef yylex_init
-#define xlu__cfg_yylex_init_ALREADY_DEFINED
-#else
-#define yylex_init xlu__cfg_yylex_init
-#endif
-
-#ifdef yylex_init_extra
-#define xlu__cfg_yylex_init_extra_ALREADY_DEFINED
-#else
-#define yylex_init_extra xlu__cfg_yylex_init_extra
-#endif
-
-#ifdef yylex_destroy
-#define xlu__cfg_yylex_destroy_ALREADY_DEFINED
-#else
-#define yylex_destroy xlu__cfg_yylex_destroy
-#endif
-
-#ifdef yyget_debug
-#define xlu__cfg_yyget_debug_ALREADY_DEFINED
-#else
-#define yyget_debug xlu__cfg_yyget_debug
-#endif
-
-#ifdef yyset_debug
-#define xlu__cfg_yyset_debug_ALREADY_DEFINED
-#else
-#define yyset_debug xlu__cfg_yyset_debug
-#endif
-
-#ifdef yyget_extra
-#define xlu__cfg_yyget_extra_ALREADY_DEFINED
-#else
-#define yyget_extra xlu__cfg_yyget_extra
-#endif
-
-#ifdef yyset_extra
-#define xlu__cfg_yyset_extra_ALREADY_DEFINED
-#else
-#define yyset_extra xlu__cfg_yyset_extra
-#endif
-
-#ifdef yyget_in
-#define xlu__cfg_yyget_in_ALREADY_DEFINED
-#else
-#define yyget_in xlu__cfg_yyget_in
-#endif
-
-#ifdef yyset_in
-#define xlu__cfg_yyset_in_ALREADY_DEFINED
-#else
-#define yyset_in xlu__cfg_yyset_in
-#endif
-
-#ifdef yyget_out
-#define xlu__cfg_yyget_out_ALREADY_DEFINED
-#else
-#define yyget_out xlu__cfg_yyget_out
-#endif
-
-#ifdef yyset_out
-#define xlu__cfg_yyset_out_ALREADY_DEFINED
-#else
-#define yyset_out xlu__cfg_yyset_out
-#endif
-
-#ifdef yyget_leng
-#define xlu__cfg_yyget_leng_ALREADY_DEFINED
-#else
-#define yyget_leng xlu__cfg_yyget_leng
-#endif
-
-#ifdef yyget_text
-#define xlu__cfg_yyget_text_ALREADY_DEFINED
-#else
-#define yyget_text xlu__cfg_yyget_text
-#endif
-
-#ifdef yyget_lineno
-#define xlu__cfg_yyget_lineno_ALREADY_DEFINED
-#else
-#define yyget_lineno xlu__cfg_yyget_lineno
-#endif
-
-#ifdef yyset_lineno
-#define xlu__cfg_yyset_lineno_ALREADY_DEFINED
-#else
-#define yyset_lineno xlu__cfg_yyset_lineno
-#endif
-
-#ifdef yyget_column
-#define xlu__cfg_yyget_column_ALREADY_DEFINED
-#else
-#define yyget_column xlu__cfg_yyget_column
-#endif
-
-#ifdef yyset_column
-#define xlu__cfg_yyset_column_ALREADY_DEFINED
-#else
-#define yyset_column xlu__cfg_yyset_column
-#endif
-
-#ifdef yywrap
-#define xlu__cfg_yywrap_ALREADY_DEFINED
-#else
-#define yywrap xlu__cfg_yywrap
-#endif
-
-#ifdef yyget_lval
-#define xlu__cfg_yyget_lval_ALREADY_DEFINED
-#else
-#define yyget_lval xlu__cfg_yyget_lval
-#endif
-
-#ifdef yyset_lval
-#define xlu__cfg_yyset_lval_ALREADY_DEFINED
-#else
-#define yyset_lval xlu__cfg_yyset_lval
-#endif
-
-#ifdef yyget_lloc
-#define xlu__cfg_yyget_lloc_ALREADY_DEFINED
-#else
-#define yyget_lloc xlu__cfg_yyget_lloc
-#endif
-
-#ifdef yyset_lloc
-#define xlu__cfg_yyset_lloc_ALREADY_DEFINED
-#else
-#define yyset_lloc xlu__cfg_yyset_lloc
-#endif
-
-#ifdef yyalloc
-#define xlu__cfg_yyalloc_ALREADY_DEFINED
-#else
-#define yyalloc xlu__cfg_yyalloc
-#endif
-
-#ifdef yyrealloc
-#define xlu__cfg_yyrealloc_ALREADY_DEFINED
-#else
-#define yyrealloc xlu__cfg_yyrealloc
-#endif
-
-#ifdef yyfree
-#define xlu__cfg_yyfree_ALREADY_DEFINED
-#else
-#define yyfree xlu__cfg_yyfree
-#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
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types.
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#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;
-
-/* 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
-
-#ifndef SIZE_MAX
-#define SIZE_MAX (~(size_t)0)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-/* begin standard C++ headers. */
-
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
- are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t 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.
- */
- int 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;
-
- };
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-void yyrestart ( FILE *input_file , yyscan_t yyscanner );
-void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
-void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-void yypop_buffer_state ( yyscan_t yyscanner );
-
-YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
-
-void *yyalloc ( yy_size_t , yyscan_t yyscanner );
-void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
-void yyfree ( void * , yyscan_t yyscanner );
-
-#define xlu__cfg_yywrap(yyscanner) (/*CONSTCOND*/1)
-#define YY_SKIP_YYWRAP
-
-#define yytext_ptr yytext_r
-
-#ifdef YY_HEADER_EXPORT_START_CONDITIONS
-#define INITIAL 0
-#define lexerr 1
-
-#endif
-
-#ifndef YY_NO_UNISTD_H
-/* 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>
-#endif
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-int yylex_init (yyscan_t* scanner);
-
-int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
-
-/* Accessor methods to globals.
- These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy ( yyscan_t yyscanner );
-
-int yyget_debug ( yyscan_t yyscanner );
-
-void yyset_debug ( int debug_flag , yyscan_t yyscanner );
-
-YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
-
-void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
-
-FILE *yyget_in ( yyscan_t yyscanner );
-
-void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
-
-FILE *yyget_out ( yyscan_t yyscanner );
-
-void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
-
- int yyget_leng ( yyscan_t yyscanner );
-
-char *yyget_text ( yyscan_t yyscanner );
-
-int yyget_lineno ( yyscan_t yyscanner );
-
-void yyset_lineno ( int _line_number , yyscan_t yyscanner );
-
-int yyget_column ( yyscan_t yyscanner );
-
-void yyset_column ( int _column_no , yyscan_t yyscanner );
-
-YYSTYPE * yyget_lval ( yyscan_t yyscanner );
-
-void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
-
- YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
-
- void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap ( yyscan_t yyscanner );
-#else
-extern int yywrap ( yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* 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 yylex \
- (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
-
-#define YY_DECL int yylex \
- (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-#undef YY_NEW_FILE
-#undef YY_FLUSH_BUFFER
-#undef yy_set_bol
-#undef yy_new_buffer
-#undef yy_set_interactive
-#undef YY_DO_BEFORE_ACTION
-
-#ifdef YY_DECL_IS_OURS
-#undef YY_DECL_IS_OURS
-#undef YY_DECL
-#endif
-
-#ifndef xlu__cfg_yy_create_buffer_ALREADY_DEFINED
-#undef yy_create_buffer
-#endif
-#ifndef xlu__cfg_yy_delete_buffer_ALREADY_DEFINED
-#undef yy_delete_buffer
-#endif
-#ifndef xlu__cfg_yy_scan_buffer_ALREADY_DEFINED
-#undef yy_scan_buffer
-#endif
-#ifndef xlu__cfg_yy_scan_string_ALREADY_DEFINED
-#undef yy_scan_string
-#endif
-#ifndef xlu__cfg_yy_scan_bytes_ALREADY_DEFINED
-#undef yy_scan_bytes
-#endif
-#ifndef xlu__cfg_yy_init_buffer_ALREADY_DEFINED
-#undef yy_init_buffer
-#endif
-#ifndef xlu__cfg_yy_flush_buffer_ALREADY_DEFINED
-#undef yy_flush_buffer
-#endif
-#ifndef xlu__cfg_yy_load_buffer_state_ALREADY_DEFINED
-#undef yy_load_buffer_state
-#endif
-#ifndef xlu__cfg_yy_switch_to_buffer_ALREADY_DEFINED
-#undef yy_switch_to_buffer
-#endif
-#ifndef xlu__cfg_yypush_buffer_state_ALREADY_DEFINED
-#undef yypush_buffer_state
-#endif
-#ifndef xlu__cfg_yypop_buffer_state_ALREADY_DEFINED
-#undef yypop_buffer_state
-#endif
-#ifndef xlu__cfg_yyensure_buffer_stack_ALREADY_DEFINED
-#undef yyensure_buffer_stack
-#endif
-#ifndef xlu__cfg_yylex_ALREADY_DEFINED
-#undef yylex
-#endif
-#ifndef xlu__cfg_yyrestart_ALREADY_DEFINED
-#undef yyrestart
-#endif
-#ifndef xlu__cfg_yylex_init_ALREADY_DEFINED
-#undef yylex_init
-#endif
-#ifndef xlu__cfg_yylex_init_extra_ALREADY_DEFINED
-#undef yylex_init_extra
-#endif
-#ifndef xlu__cfg_yylex_destroy_ALREADY_DEFINED
-#undef yylex_destroy
-#endif
-#ifndef xlu__cfg_yyget_debug_ALREADY_DEFINED
-#undef yyget_debug
-#endif
-#ifndef xlu__cfg_yyset_debug_ALREADY_DEFINED
-#undef yyset_debug
-#endif
-#ifndef xlu__cfg_yyget_extra_ALREADY_DEFINED
-#undef yyget_extra
-#endif
-#ifndef xlu__cfg_yyset_extra_ALREADY_DEFINED
-#undef yyset_extra
-#endif
-#ifndef xlu__cfg_yyget_in_ALREADY_DEFINED
-#undef yyget_in
-#endif
-#ifndef xlu__cfg_yyset_in_ALREADY_DEFINED
-#undef yyset_in
-#endif
-#ifndef xlu__cfg_yyget_out_ALREADY_DEFINED
-#undef yyget_out
-#endif
-#ifndef xlu__cfg_yyset_out_ALREADY_DEFINED
-#undef yyset_out
-#endif
-#ifndef xlu__cfg_yyget_leng_ALREADY_DEFINED
-#undef yyget_leng
-#endif
-#ifndef xlu__cfg_yyget_text_ALREADY_DEFINED
-#undef yyget_text
-#endif
-#ifndef xlu__cfg_yyget_lineno_ALREADY_DEFINED
-#undef yyget_lineno
-#endif
-#ifndef xlu__cfg_yyset_lineno_ALREADY_DEFINED
-#undef yyset_lineno
-#endif
-#ifndef xlu__cfg_yyget_column_ALREADY_DEFINED
-#undef yyget_column
-#endif
-#ifndef xlu__cfg_yyset_column_ALREADY_DEFINED
-#undef yyset_column
-#endif
-#ifndef xlu__cfg_yywrap_ALREADY_DEFINED
-#undef yywrap
-#endif
-#ifndef xlu__cfg_yyget_lval_ALREADY_DEFINED
-#undef yyget_lval
-#endif
-#ifndef xlu__cfg_yyset_lval_ALREADY_DEFINED
-#undef yyset_lval
-#endif
-#ifndef xlu__cfg_yyget_lloc_ALREADY_DEFINED
-#undef yyget_lloc
-#endif
-#ifndef xlu__cfg_yyset_lloc_ALREADY_DEFINED
-#undef yyset_lloc
-#endif
-#ifndef xlu__cfg_yyalloc_ALREADY_DEFINED
-#undef yyalloc
-#endif
-#ifndef xlu__cfg_yyrealloc_ALREADY_DEFINED
-#undef yyrealloc
-#endif
-#ifndef xlu__cfg_yyfree_ALREADY_DEFINED
-#undef yyfree
-#endif
-#ifndef xlu__cfg_yytext_ALREADY_DEFINED
-#undef yytext
-#endif
-#ifndef xlu__cfg_yyleng_ALREADY_DEFINED
-#undef yyleng
-#endif
-#ifndef xlu__cfg_yyin_ALREADY_DEFINED
-#undef yyin
-#endif
-#ifndef xlu__cfg_yyout_ALREADY_DEFINED
-#undef yyout
-#endif
-#ifndef xlu__cfg_yy_flex_debug_ALREADY_DEFINED
-#undef yy_flex_debug
-#endif
-#ifndef xlu__cfg_yylineno_ALREADY_DEFINED
-#undef yylineno
-#endif
-#ifndef xlu__cfg_yytables_fload_ALREADY_DEFINED
-#undef yytables_fload
-#endif
-#ifndef xlu__cfg_yytables_destroy_ALREADY_DEFINED
-#undef yytables_destroy
-#endif
-#ifndef xlu__cfg_yyTABLES_NAME_ALREADY_DEFINED
-#undef yyTABLES_NAME
-#endif
-
-#line 105 "libxlu_cfg_l.l"
-
-#line 733 "libxlu_cfg_l.h"
-#undef xlu__cfg_yyIN_HEADER
-#endif /* xlu__cfg_yyHEADER_H */
+++ /dev/null
-/* -*- fundamental -*- */
-/*
- * libxlu_cfg_l.l - xl configuration file parsing: lexer
- *
- * Copyright (C) 2010 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-
-%{
-#include "libxlu_cfg_i.h"
-
-#define ctx ((CfgParseContext*)yyextra)
-#define YY_NO_INPUT
-
-#define GOT(x) do{ \
- yylloc->first_line= yylineno; \
- return (x); \
- }while(0)
-
-/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
- * it to fail to declare these functions, which it defines. So declare
- * them ourselves. Hopefully we won't have to simultaneously support
- * a flex version which declares these differently somehow. */
-int xlu__cfg_yyget_column(yyscan_t yyscanner);
-void xlu__cfg_yyset_column(int column_no, yyscan_t yyscanner);
-
-%}
-
-%option warn
-%option nodefault
-%option batch
-%option 8bit
-%option yylineno
-%option noyywrap
-%option bison-bridge
-%option bison-locations
-%option reentrant
-%option prefix="xlu__cfg_yy"
-%option nounput
-
-%x lexerr
-
-%%
-
-[a-z][._0-9a-z]* {
- yylval->string= xlu__cfgl_strdup(ctx,yytext);
- GOT(IDENT);
- }
-[0-9][0-9a-fx]* {
- yylval->string= xlu__cfgl_strdup(ctx,yytext);
- GOT(NUMBER);
- }
-
-[ \t]
-
-, { GOT(','); }
-\[ { GOT('['); }
-\] { GOT(']'); }
-\+\= { GOT(OP_ADD); }
-\= { GOT('='); }
-\; { GOT(';'); }
-
-\n|\#.*\n { yylloc->first_line= yylineno-1; return NEWLINE; }
-
-\'([^\'\\\n]|\\.)*\' {
- yylval->string= xlu__cfgl_dequote(ctx,yytext);
- GOT(STRING);
- }
-\"([^\"\\\n]|\\.)*\" {
- yylval->string= xlu__cfgl_dequote(ctx,yytext);
- GOT(STRING);
- }
-
-[+-.():] {
- ctx->likely_python= 1;
- BEGIN(lexerr);
- yymore();
- }
-
-. {
- BEGIN(lexerr);
- yymore();
- }
-
-<lexerr>[^ \t\n]*|[ \t] {
- xlu__cfgl_lexicalerror(ctx,"lexical error");
- BEGIN(0);
- }
-
-<lexerr>\n {
- xlu__cfgl_lexicalerror(ctx,"lexical error");
- BEGIN(0);
- GOT(NEWLINE);
- }
+++ /dev/null
-/* A Bison parser, made by GNU Bison 3.3.2. */
-
-/* Bison implementation for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 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 3 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, see <http://www.gnu.org/licenses/>. */
-
-/* As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
-
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison. */
-
-/* C LALR(1) parser skeleton 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. */
-
-/* Undocumented macros, especially those whose name start with YY_,
- are private implementation details. Do not rely on them. */
-
-/* Identify Bison output. */
-#define YYBISON 1
-
-/* Bison version. */
-#define YYBISON_VERSION "3.3.2"
-
-/* Skeleton name. */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers. */
-#define YYPURE 1
-
-/* Push parsers. */
-#define YYPUSH 0
-
-/* Pull parsers. */
-#define YYPULL 1
-
-
-/* Substitute the variable and function names. */
-#define yyparse xlu__cfg_yyparse
-#define yylex xlu__cfg_yylex
-#define yyerror xlu__cfg_yyerror
-#define yydebug xlu__cfg_yydebug
-#define yynerrs xlu__cfg_yynerrs
-
-
-/* First part of user prologue. */
-#line 19 "libxlu_cfg_y.y" /* yacc.c:337 */
-
-#define ctx_scanner ctx->scanner
-#include "libxlu_cfg_i.h"
-#include "libxlu_cfg_l.h"
-
-#line 82 "libxlu_cfg_y.c" /* yacc.c:337 */
-# ifndef YY_NULLPTR
-# if defined __cplusplus
-# if 201103L <= __cplusplus
-# define YY_NULLPTR nullptr
-# else
-# define YY_NULLPTR 0
-# endif
-# else
-# define YY_NULLPTR ((void*)0)
-# endif
-# endif
-
-/* Enabling verbose error messages. */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 1
-#endif
-
-/* In a future release of Bison, this section will be replaced
- by #include "libxlu_cfg_y.h". */
-#ifndef YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
-# define YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
-/* Debug traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int xlu__cfg_yydebug;
-#endif
-
-/* Token type. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- enum yytokentype
- {
- IDENT = 258,
- STRING = 259,
- NUMBER = 260,
- NEWLINE = 261,
- OP_ADD = 262
- };
-#endif
-
-/* Value type. */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-
-union YYSTYPE
-{
-#line 25 "libxlu_cfg_y.y" /* yacc.c:352 */
-
- char *string;
- XLU_ConfigValue *value;
-
-#line 138 "libxlu_cfg_y.c" /* yacc.c:352 */
-};
-
-typedef union YYSTYPE YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-/* Location type. */
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE YYLTYPE;
-struct YYLTYPE
-{
- int first_line;
- int first_column;
- int last_line;
- int last_column;
-};
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-
-int xlu__cfg_yyparse (CfgParseContext *ctx);
-
-#endif /* !YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED */
-
-
-
-#ifdef short
-# undef short
-#endif
-
-#ifdef YYTYPE_UINT8
-typedef YYTYPE_UINT8 yytype_uint8;
-#else
-typedef unsigned char yytype_uint8;
-#endif
-
-#ifdef YYTYPE_INT8
-typedef YYTYPE_INT8 yytype_int8;
-#else
-typedef signed char yytype_int8;
-#endif
-
-#ifdef YYTYPE_UINT16
-typedef YYTYPE_UINT16 yytype_uint16;
-#else
-typedef unsigned short yytype_uint16;
-#endif
-
-#ifdef YYTYPE_INT16
-typedef YYTYPE_INT16 yytype_int16;
-#else
-typedef short yytype_int16;
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-# define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-# define YYSIZE_T size_t
-# elif ! defined YYSIZE_T
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
-# else
-# define YYSIZE_T unsigned
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-# if ENABLE_NLS
-# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
-# endif
-# endif
-# ifndef YY_
-# define YY_(Msgid) Msgid
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE
-# if (defined __GNUC__ \
- && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
- || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
-# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
-# else
-# define YY_ATTRIBUTE(Spec) /* empty */
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE_PURE
-# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
-#endif
-
-#ifndef YY_ATTRIBUTE_UNUSED
-# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
-#endif
-
-/* Suppress unused-variable warnings by "using" E. */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(E) ((void) (E))
-#else
-# define YYUSE(E) /* empty */
-#endif
-
-#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
-/* Suppress an incorrect diagnostic about yylval being uninitialized. */
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
- _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
- _Pragma ("GCC diagnostic pop")
-#else
-# define YY_INITIAL_VALUE(Value) Value
-#endif
-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
-#endif
-#ifndef YY_INITIAL_VALUE
-# define YY_INITIAL_VALUE(Value) /* Nothing. */
-#endif
-
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols. */
-
-# ifdef YYSTACK_USE_ALLOCA
-# if YYSTACK_USE_ALLOCA
-# ifdef __GNUC__
-# define YYSTACK_ALLOC __builtin_alloca
-# elif defined __BUILTIN_VA_ARG_INCR
-# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-# elif defined _AIX
-# define YYSTACK_ALLOC __alloca
-# elif defined _MSC_VER
-# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-# define alloca _alloca
-# else
-# define YYSTACK_ALLOC alloca
-# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
- /* Use EXIT_SUCCESS as a witness for stdlib.h. */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# endif
-# endif
-# endif
-
-# ifdef YYSTACK_ALLOC
- /* Pacify GCC's 'empty if-body' warning. */
-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
-# ifndef YYSTACK_ALLOC_MAXIMUM
- /* The OS might guarantee only one guard page at the bottom of the stack,
- and a page size can be as small as 4096 bytes. So we cannot safely
- invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
- to allow for a few compiler-allocated temporary stack slots. */
-# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-# endif
-# else
-# define YYSTACK_ALLOC YYMALLOC
-# define YYSTACK_FREE YYFREE
-# ifndef YYSTACK_ALLOC_MAXIMUM
-# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-# endif
-# if (defined __cplusplus && ! defined EXIT_SUCCESS \
- && ! ((defined YYMALLOC || defined malloc) \
- && (defined YYFREE || defined free)))
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# ifndef YYMALLOC
-# define YYMALLOC malloc
-# if ! defined malloc && ! defined EXIT_SUCCESS
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# ifndef YYFREE
-# define YYFREE free
-# if ! defined free && ! defined EXIT_SUCCESS
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
- && (! defined __cplusplus \
- || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
- && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member. */
-union yyalloc
-{
- yytype_int16 yyss_alloc;
- YYSTYPE yyvs_alloc;
- YYLTYPE yyls_alloc;
-};
-
-/* 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 (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
- + 2 * YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* 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_alloc, Stack) \
- do \
- { \
- YYSIZE_T yynewbytes; \
- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
- Stack = &yyptr->Stack_alloc; \
- yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
- yyptr += yynewbytes / sizeof (*yyptr); \
- } \
- while (0)
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST. The source and destination do
- not overlap. */
-# ifndef YYCOPY
-# if defined __GNUC__ && 1 < __GNUC__
-# define YYCOPY(Dst, Src, Count) \
- __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
-# else
-# define YYCOPY(Dst, Src, Count) \
- do \
- { \
- YYSIZE_T yyi; \
- for (yyi = 0; yyi < (Count); yyi++) \
- (Dst)[yyi] = (Src)[yyi]; \
- } \
- while (0)
-# endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state. */
-#define YYFINAL 3
-/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 27
-
-/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 13
-/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 11
-/* YYNRULES -- Number of rules. */
-#define YYNRULES 23
-/* YYNSTATES -- Number of states. */
-#define YYNSTATES 32
-
-#define YYUNDEFTOK 2
-#define YYMAXUTOK 262
-
-/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex, with out-of-bounds checking. */
-#define YYTRANSLATE(YYX) \
- ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex. */
-static const yytype_uint8 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, 12, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 9,
- 2, 8, 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, 10, 2, 11, 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
-};
-
-#if YYDEBUG
- /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
-static const yytype_uint8 yyrline[] =
-{
- 0, 48, 48, 49, 51, 52, 54, 55, 56, 58,
- 59, 61, 62, 64, 65, 67, 68, 70, 71, 72,
- 74, 75, 77, 79
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || 1
-/* YYTNAME[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", "IDENT", "STRING", "NUMBER", "NEWLINE",
- "\"+=\"", "'='", "';'", "'['", "']'", "','", "$accept", "file", "stmts",
- "stmt", "assignment", "endstmt", "value", "atom", "valuelist", "values",
- "nlok", YY_NULLPTR
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[NUM] -- (External) token number corresponding to the
- (internal) symbol number NUM (which must be that of a token). */
-static const yytype_uint16 yytoknum[] =
-{
- 0, 256, 257, 258, 259, 260, 261, 262, 61, 59,
- 91, 93, 44
-};
-# endif
-
-#define YYPACT_NINF -18
-
-#define yypact_value_is_default(Yystate) \
- (!!((Yystate) == (-18)))
-
-#define YYTABLE_NINF -3
-
-#define yytable_value_is_error(Yytable_value) \
- 0
-
- /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- STATE-NUM. */
-static const yytype_int8 yypact[] =
-{
- -18, 5, 1, -18, -3, 14, -18, -18, -18, 3,
- -18, -18, 10, 10, -18, -18, -18, -18, -18, -18,
- -18, 13, -18, -18, 15, 12, 19, -18, -18, 13,
- -18, 19
-};
-
- /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
- Performed when YYTABLE does not specify something else to do. Zero
- means the default is an error. */
-static const yytype_uint8 yydefact[] =
-{
- 4, 0, 0, 1, 0, 0, 11, 12, 5, 3,
- 7, 8, 0, 0, 6, 15, 16, 22, 10, 13,
- 9, 17, 23, 22, 0, 18, 20, 14, 22, 19,
- 22, 21
-};
-
- /* YYPGOTO[NTERM-NUM]. */
-static const yytype_int8 yypgoto[] =
-{
- -18, -18, -18, -18, -18, 18, -13, -18, -18, -18,
- -17
-};
-
- /* YYDEFGOTO[NTERM-NUM]. */
-static const yytype_int8 yydefgoto[] =
-{
- -1, 1, 2, 8, 9, 10, 18, 19, 24, 25,
- 21
-};
-
- /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
- positive, shift that token. If negative, reduce the rule whose
- number is the opposite. If YYTABLE_NINF, syntax error. */
-static const yytype_int8 yytable[] =
-{
- 20, -2, 4, 11, 5, 3, 26, 6, 23, 6,
- 7, 29, 7, 31, 15, 16, 30, 15, 16, 22,
- 17, 12, 13, 17, 28, 22, 27, 14
-};
-
-static const yytype_uint8 yycheck[] =
-{
- 13, 0, 1, 6, 3, 0, 23, 6, 21, 6,
- 9, 28, 9, 30, 4, 5, 29, 4, 5, 6,
- 10, 7, 8, 10, 12, 6, 11, 9
-};
-
- /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
- symbol of state STATE-NUM. */
-static const yytype_uint8 yystos[] =
-{
- 0, 14, 15, 0, 1, 3, 6, 9, 16, 17,
- 18, 6, 7, 8, 18, 4, 5, 10, 19, 20,
- 19, 23, 6, 19, 21, 22, 23, 11, 12, 23,
- 19, 23
-};
-
- /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
-static const yytype_uint8 yyr1[] =
-{
- 0, 13, 14, 14, 15, 15, 16, 16, 16, 17,
- 17, 18, 18, 19, 19, 20, 20, 21, 21, 21,
- 22, 22, 23, 23
-};
-
- /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
-static const yytype_uint8 yyr2[] =
-{
- 0, 2, 1, 2, 0, 2, 2, 1, 2, 3,
- 3, 1, 1, 1, 4, 1, 1, 0, 1, 3,
- 2, 5, 0, 2
-};
-
-
-#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 yyerrorlab
-
-
-#define YYRECOVERING() (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value) \
- do \
- if (yychar == YYEMPTY) \
- { \
- yychar = (Token); \
- yylval = (Value); \
- YYPOPSTACK (yylen); \
- yystate = *yyssp; \
- goto yybackup; \
- } \
- else \
- { \
- yyerror (&yylloc, ctx, YY_("syntax error: cannot back up")); \
- YYERROR; \
- } \
- while (0)
-
-/* Error token number */
-#define YYTERROR 1
-#define YYERRCODE 256
-
-
-/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
- If N is 0, then set CURRENT to the empty location which ends
- the previous symbol: RHS[0] (always defined). */
-
-#ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N) \
- do \
- if (N) \
- { \
- (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
- (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
- (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
- (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
- } \
- else \
- { \
- (Current).first_line = (Current).last_line = \
- YYRHSLOC (Rhs, 0).last_line; \
- (Current).first_column = (Current).last_column = \
- YYRHSLOC (Rhs, 0).last_column; \
- } \
- while (0)
-#endif
-
-#define YYRHSLOC(Rhs, K) ((Rhs)[K])
-
-
-/* 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)
-
-
-/* YY_LOCATION_PRINT -- Print the location on the stream.
- This macro was not mandated originally: define only if we know
- we won't break user code: when these are the locations we know. */
-
-#ifndef YY_LOCATION_PRINT
-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-
-/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
-
-YY_ATTRIBUTE_UNUSED
-static int
-yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
-{
- int res = 0;
- int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
- if (0 <= yylocp->first_line)
- {
- res += YYFPRINTF (yyo, "%d", yylocp->first_line);
- if (0 <= yylocp->first_column)
- res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
- }
- if (0 <= yylocp->last_line)
- {
- if (yylocp->first_line < yylocp->last_line)
- {
- res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
- if (0 <= end_col)
- res += YYFPRINTF (yyo, ".%d", end_col);
- }
- else if (0 <= end_col && yylocp->first_column < end_col)
- res += YYFPRINTF (yyo, "-%d", end_col);
- }
- return res;
- }
-
-# define YY_LOCATION_PRINT(File, Loc) \
- yy_location_print_ (File, &(Loc))
-
-# else
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
-#endif
-
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
-do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yy_symbol_print (stderr, \
- Type, Value, Location, ctx); \
- YYFPRINTF (stderr, "\n"); \
- } \
-} while (0)
-
-
-/*-----------------------------------.
-| Print this symbol's value on YYO. |
-`-----------------------------------*/
-
-static void
-yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, CfgParseContext *ctx)
-{
- FILE *yyoutput = yyo;
- YYUSE (yyoutput);
- YYUSE (yylocationp);
- YYUSE (ctx);
- if (!yyvaluep)
- return;
-# ifdef YYPRINT
- if (yytype < YYNTOKENS)
- YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
-# endif
- YYUSE (yytype);
-}
-
-
-/*---------------------------.
-| Print this symbol on YYO. |
-`---------------------------*/
-
-static void
-yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, CfgParseContext *ctx)
-{
- YYFPRINTF (yyo, "%s %s (",
- yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
-
- YY_LOCATION_PRINT (yyo, *yylocationp);
- YYFPRINTF (yyo, ": ");
- yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, ctx);
- YYFPRINTF (yyo, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included). |
-`------------------------------------------------------------------*/
-
-static void
-yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
-{
- YYFPRINTF (stderr, "Stack now");
- for (; yybottom <= yytop; yybottom++)
- {
- int yybot = *yybottom;
- YYFPRINTF (stderr, " %d", yybot);
- }
- 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. |
-`------------------------------------------------*/
-
-static void
-yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, CfgParseContext *ctx)
-{
- unsigned long yylno = yyrline[yyrule];
- int yynrhs = yyr2[yyrule];
- int yyi;
- YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
- yyrule - 1, yylno);
- /* The symbols being reduced. */
- for (yyi = 0; yyi < yynrhs; yyi++)
- {
- YYFPRINTF (stderr, " $%d = ", yyi + 1);
- yy_symbol_print (stderr,
- yystos[yyssp[yyi + 1 - yynrhs]],
- &yyvsp[(yyi + 1) - (yynrhs)]
- , &(yylsp[(yyi + 1) - (yynrhs)]) , ctx);
- YYFPRINTF (stderr, "\n");
- }
-}
-
-# define YY_REDUCE_PRINT(Rule) \
-do { \
- if (yydebug) \
- yy_reduce_print (yyssp, yyvsp, yylsp, Rule, ctx); \
-} 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 YY_SYMBOL_PRINT(Title, Type, 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
- YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
- evaluated with infinite-precision integer arithmetic. */
-
-#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
-yystrlen (const char *yystr)
-{
- YYSIZE_T yylen;
- for (yylen = 0; yystr[yylen]; yylen++)
- continue;
- return yylen;
-}
-# 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 *
-yystpcpy (char *yydest, const char *yysrc)
-{
- char *yyd = yydest;
- const char *yys = yysrc;
-
- while ((*yyd++ = *yys++) != '\0')
- continue;
-
- return yyd - 1;
-}
-# endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
- quotes and backslashes, so that it's suitable for yyerror. The
- heuristic is that double-quoting is unnecessary unless the string
- contains an apostrophe, a comma, or backslash (other than
- backslash-backslash). YYSTR is taken from yytname. If YYRES is
- null, do not copy; instead, return the length of what the result
- would have been. */
-static YYSIZE_T
-yytnamerr (char *yyres, const char *yystr)
-{
- if (*yystr == '"')
- {
- YYSIZE_T yyn = 0;
- char const *yyp = yystr;
-
- for (;;)
- switch (*++yyp)
- {
- case '\'':
- case ',':
- goto do_not_strip_quotes;
-
- case '\\':
- if (*++yyp != '\\')
- goto do_not_strip_quotes;
- else
- goto append;
-
- append:
- default:
- if (yyres)
- yyres[yyn] = *yyp;
- yyn++;
- break;
-
- case '"':
- if (yyres)
- yyres[yyn] = '\0';
- return yyn;
- }
- do_not_strip_quotes: ;
- }
-
- if (! yyres)
- return yystrlen (yystr);
-
- return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
-}
-# endif
-
-/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
- about the unexpected token YYTOKEN for the state stack whose top is
- YYSSP.
-
- Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
- not large enough to hold the message. In that case, also set
- *YYMSG_ALLOC to the required number of bytes. Return 2 if the
- required number of bytes is too large to store. */
-static int
-yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
- yytype_int16 *yyssp, int yytoken)
-{
- YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
- YYSIZE_T yysize = yysize0;
- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
- /* Internationalized format string. */
- const char *yyformat = YY_NULLPTR;
- /* Arguments of yyformat. */
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
- /* Number of reported tokens (one for the "unexpected", one per
- "expected"). */
- int yycount = 0;
-
- /* There are many possibilities here to consider:
- - If this state is a consistent state with a default action, then
- the only way this function was invoked is if the default action
- is an error action. In that case, don't check for expected
- tokens because there are none.
- - The only way there can be no lookahead present (in yychar) is if
- this state is a consistent state with a default action. Thus,
- detecting the absence of a lookahead is sufficient to determine
- that there is no unexpected or expected token to report. In that
- case, just report a simple "syntax error".
- - Don't assume there isn't a lookahead just because this state is a
- consistent state with a default action. There might have been a
- previous inconsistent state, consistent state with a non-default
- action, or user semantic action that manipulated yychar.
- - Of course, the expected token list depends on states to have
- correct lookahead information, and it depends on the parser not
- to perform extra reductions after fetching a lookahead from the
- scanner and before detecting a syntax error. Thus, state merging
- (from LALR or IELR) and default reductions corrupt the expected
- token list. However, the list is correct for canonical LR with
- one exception: it will still contain any token that will not be
- accepted due to an error action in a later state.
- */
- if (yytoken != YYEMPTY)
- {
- int yyn = yypact[*yyssp];
- yyarg[yycount++] = yytname[yytoken];
- if (!yypact_value_is_default (yyn))
- {
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. In other words, skip the first -YYN actions for
- this state because they are default actions. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn + 1;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- int yyx;
-
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
- && !yytable_value_is_error (yytable[yyx + yyn]))
- {
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- yysize = yysize0;
- break;
- }
- yyarg[yycount++] = yytname[yyx];
- {
- YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
- if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
- yysize = yysize1;
- else
- return 2;
- }
- }
- }
- }
-
- switch (yycount)
- {
-# define YYCASE_(N, S) \
- case N: \
- yyformat = S; \
- break
- default: /* Avoid compiler warnings. */
- YYCASE_(0, YY_("syntax error"));
- YYCASE_(1, YY_("syntax error, unexpected %s"));
- YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
- YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
- YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
- YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
-# undef YYCASE_
- }
-
- {
- YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
- if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
- yysize = yysize1;
- else
- return 2;
- }
-
- if (*yymsg_alloc < yysize)
- {
- *yymsg_alloc = 2 * yysize;
- if (! (yysize <= *yymsg_alloc
- && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
- *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
- return 1;
- }
-
- /* Avoid sprintf, as that infringes on the user's name space.
- Don't have undefined behavior even if the translation
- produced a string with the wrong number of "%s"s. */
- {
- char *yyp = *yymsg;
- int yyi = 0;
- while ((*yyp = *yyformat) != '\0')
- if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
- {
- yyp += yytnamerr (yyp, yyarg[yyi++]);
- yyformat += 2;
- }
- else
- {
- yyp++;
- yyformat++;
- }
- }
- return 0;
-}
-#endif /* YYERROR_VERBOSE */
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol. |
-`-----------------------------------------------*/
-
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, CfgParseContext *ctx)
-{
- YYUSE (yyvaluep);
- YYUSE (yylocationp);
- YYUSE (ctx);
- if (!yymsg)
- yymsg = "Deleting";
- YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- switch (yytype)
- {
- case 3: /* IDENT */
-#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
- { free(((*yyvaluep).string)); }
-#line 1072 "libxlu_cfg_y.c" /* yacc.c:1257 */
- break;
-
- case 4: /* STRING */
-#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
- { free(((*yyvaluep).string)); }
-#line 1078 "libxlu_cfg_y.c" /* yacc.c:1257 */
- break;
-
- case 5: /* NUMBER */
-#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
- { free(((*yyvaluep).string)); }
-#line 1084 "libxlu_cfg_y.c" /* yacc.c:1257 */
- break;
-
- case 19: /* value */
-#line 44 "libxlu_cfg_y.y" /* yacc.c:1257 */
- { xlu__cfg_value_free(((*yyvaluep).value)); }
-#line 1090 "libxlu_cfg_y.c" /* yacc.c:1257 */
- break;
-
- case 20: /* atom */
-#line 40 "libxlu_cfg_y.y" /* yacc.c:1257 */
- { free(((*yyvaluep).string)); }
-#line 1096 "libxlu_cfg_y.c" /* yacc.c:1257 */
- break;
-
- case 21: /* valuelist */
-#line 44 "libxlu_cfg_y.y" /* yacc.c:1257 */
- { xlu__cfg_value_free(((*yyvaluep).value)); }
-#line 1102 "libxlu_cfg_y.c" /* yacc.c:1257 */
- break;
-
- case 22: /* values */
-#line 44 "libxlu_cfg_y.y" /* yacc.c:1257 */
- { xlu__cfg_value_free(((*yyvaluep).value)); }
-#line 1108 "libxlu_cfg_y.c" /* yacc.c:1257 */
- break;
-
- default:
- break;
- }
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-
-
-/*----------.
-| yyparse. |
-`----------*/
-
-int
-yyparse (CfgParseContext *ctx)
-{
-/* The lookahead symbol. */
-int yychar;
-
-
-/* The semantic value of the lookahead symbol. */
-/* Default value used for initialization, for pacifying older GCCs
- or non-GCC compilers. */
-YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
-YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
-
-/* Location data for the lookahead symbol. */
-static YYLTYPE yyloc_default
-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
- = { 1, 1, 1, 1 }
-# endif
-;
-YYLTYPE yylloc = yyloc_default;
-
- /* Number of syntax errors so far. */
- int yynerrs;
-
- int yystate;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus;
-
- /* The stacks and their tools:
- 'yyss': related to states.
- 'yyvs': related to semantic values.
- 'yyls': related to locations.
-
- Refer to the stacks through separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
-
- /* The state stack. */
- yytype_int16 yyssa[YYINITDEPTH];
- yytype_int16 *yyss;
- yytype_int16 *yyssp;
-
- /* The semantic value stack. */
- YYSTYPE yyvsa[YYINITDEPTH];
- YYSTYPE *yyvs;
- YYSTYPE *yyvsp;
-
- /* The location stack. */
- YYLTYPE yylsa[YYINITDEPTH];
- YYLTYPE *yyls;
- YYLTYPE *yylsp;
-
- /* The locations where the error started and ended. */
- YYLTYPE yyerror_range[3];
-
- YYSIZE_T yystacksize;
-
- int yyn;
- int yyresult;
- /* Lookahead token as an internal (translated) token number. */
- int yytoken = 0;
- /* The variables used to return semantic value and location from the
- action routines. */
- YYSTYPE yyval;
- YYLTYPE yyloc;
-
-#if YYERROR_VERBOSE
- /* Buffer for error messages, and its allocated size. */
- char yymsgbuf[128];
- char *yymsg = yymsgbuf;
- YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
-
- /* The number of symbols on the RHS of the reduced rule.
- Keep to zero when no symbol should be popped. */
- int yylen = 0;
-
- yyssp = yyss = yyssa;
- yyvsp = yyvs = yyvsa;
- yylsp = yyls = yylsa;
- yystacksize = YYINITDEPTH;
-
- YYDPRINTF ((stderr, "Starting parse\n"));
-
- yystate = 0;
- yyerrstatus = 0;
- yynerrs = 0;
- yychar = YYEMPTY; /* Cause a token to be read. */
- yylsp[0] = yylloc;
- 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++;
-
-
-/*--------------------------------------------------------------------.
-| yynewstate -- set current state (the top of the stack) to yystate. |
-`--------------------------------------------------------------------*/
-yysetstate:
- *yyssp = (yytype_int16) yystate;
-
- if (yyss + yystacksize - 1 <= yyssp)
-#if !defined yyoverflow && !defined YYSTACK_RELOCATE
- goto yyexhaustedlab;
-#else
- {
- /* Get the current used size of the three stacks, in elements. */
- YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
-
-# if defined 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;
- yytype_int16 *yyss1 = yyss;
- YYLTYPE *yyls1 = yyls;
-
- /* 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 (YY_("memory exhausted"),
- &yyss1, yysize * sizeof (*yyssp),
- &yyvs1, yysize * sizeof (*yyvsp),
- &yyls1, yysize * sizeof (*yylsp),
- &yystacksize);
- yyss = yyss1;
- yyvs = yyvs1;
- yyls = yyls1;
- }
-# else /* defined YYSTACK_RELOCATE */
- /* Extend the stack our own way. */
- if (YYMAXDEPTH <= yystacksize)
- goto yyexhaustedlab;
- yystacksize *= 2;
- if (YYMAXDEPTH < yystacksize)
- yystacksize = YYMAXDEPTH;
-
- {
- yytype_int16 *yyss1 = yyss;
- union yyalloc *yyptr =
- (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
- if (! yyptr)
- goto yyexhaustedlab;
- YYSTACK_RELOCATE (yyss_alloc, yyss);
- YYSTACK_RELOCATE (yyvs_alloc, yyvs);
- YYSTACK_RELOCATE (yyls_alloc, yyls);
-# undef YYSTACK_RELOCATE
- if (yyss1 != yyssa)
- YYSTACK_FREE (yyss1);
- }
-# endif
-
- yyssp = yyss + yysize - 1;
- yyvsp = yyvs + yysize - 1;
- yylsp = yyls + yysize - 1;
-
- YYDPRINTF ((stderr, "Stack size increased to %lu\n",
- (unsigned long) yystacksize));
-
- if (yyss + yystacksize - 1 <= yyssp)
- YYABORT;
- }
-#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
-
- YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-
- if (yystate == YYFINAL)
- YYACCEPT;
-
- 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. */
-
- /* First try to decide what to do without reference to lookahead token. */
- yyn = yypact[yystate];
- if (yypact_value_is_default (yyn))
- 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 (&yylval, &yylloc, ctx_scanner);
- }
-
- if (yychar <= YYEOF)
- {
- yychar = yytoken = YYEOF;
- YYDPRINTF ((stderr, "Now at end of input.\n"));
- }
- else
- {
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("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 (yytable_value_is_error (yyn))
- goto yyerrlab;
- yyn = -yyn;
- goto yyreduce;
- }
-
- /* Count tokens shifted since error; after three, turn off error
- status. */
- if (yyerrstatus)
- yyerrstatus--;
-
- /* Shift the lookahead token. */
- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-
- /* Discard the shifted token. */
- yychar = YYEMPTY;
-
- yystate = yyn;
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- *++yyvsp = yylval;
- YY_IGNORE_MAYBE_UNINITIALIZED_END
- *++yylsp = yylloc;
- 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];
-
- /* Default location. */
- YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
- yyerror_range[1] = yyloc;
- YY_REDUCE_PRINT (yyn);
- switch (yyn)
- {
- case 9:
-#line 58 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { xlu__cfg_set_store(ctx,(yyvsp[-2].string),XLU_OP_ASSIGNMENT,(yyvsp[0].value),(yylsp[0]).first_line); }
-#line 1406 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 10:
-#line 59 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { xlu__cfg_set_store(ctx,(yyvsp[-2].string),XLU_OP_ADDITION,(yyvsp[0].value),(yylsp[0]).first_line); }
-#line 1412 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 13:
-#line 64 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.value)= xlu__cfg_string_mk(ctx,(yyvsp[0].string),&(yylsp[0])); }
-#line 1418 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 14:
-#line 65 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.value)= (yyvsp[-1].value); }
-#line 1424 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 15:
-#line 67 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.string)= (yyvsp[0].string); }
-#line 1430 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 16:
-#line 68 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.string)= (yyvsp[0].string); }
-#line 1436 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 17:
-#line 70 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.value)= xlu__cfg_list_mk(ctx,NULL,&yylloc); }
-#line 1442 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 18:
-#line 71 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.value)= (yyvsp[0].value); }
-#line 1448 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 19:
-#line 72 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.value)= (yyvsp[-2].value); }
-#line 1454 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 20:
-#line 74 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { (yyval.value)= xlu__cfg_list_mk(ctx,(yyvsp[-1].value),&(yylsp[-1])); }
-#line 1460 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
- case 21:
-#line 75 "libxlu_cfg_y.y" /* yacc.c:1652 */
- { xlu__cfg_list_append(ctx,(yyvsp[-4].value),(yyvsp[-1].value)); (yyval.value)= (yyvsp[-4].value); }
-#line 1466 "libxlu_cfg_y.c" /* yacc.c:1652 */
- break;
-
-
-#line 1470 "libxlu_cfg_y.c" /* yacc.c:1652 */
- default: break;
- }
- /* User semantic actions sometimes alter yychar, and that requires
- that yytoken be updated with the new translation. We take the
- approach of translating immediately before every use of yytoken.
- One alternative is translating here after every semantic action,
- but that translation would be missed if the semantic action invokes
- YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
- if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
- incorrect destructor might then be invoked immediately. In the
- case of YYERROR or YYBACKUP, subsequent parser actions might lead
- to an incorrect destructor call or verbose syntax error message
- before the lookahead is translated. */
- YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-
- YYPOPSTACK (yylen);
- yylen = 0;
- YY_STACK_PRINT (yyss, yyssp);
-
- *++yyvsp = yyval;
- *++yylsp = yyloc;
-
- /* 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. */
- {
- const int yylhs = yyr1[yyn] - YYNTOKENS;
- const int yyi = yypgoto[yylhs] + *yyssp;
- yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
- ? yytable[yyi]
- : yydefgoto[yylhs]);
- }
-
- goto yynewstate;
-
-
-/*--------------------------------------.
-| yyerrlab -- here on detecting error. |
-`--------------------------------------*/
-yyerrlab:
- /* Make sure we have latest lookahead translation. See comments at
- user semantic actions for why this is necessary. */
- yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
-
- /* If not already recovering from an error, report this error. */
- if (!yyerrstatus)
- {
- ++yynerrs;
-#if ! YYERROR_VERBOSE
- yyerror (&yylloc, ctx, YY_("syntax error"));
-#else
-# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
- yyssp, yytoken)
- {
- char const *yymsgp = YY_("syntax error");
- int yysyntax_error_status;
- yysyntax_error_status = YYSYNTAX_ERROR;
- if (yysyntax_error_status == 0)
- yymsgp = yymsg;
- else if (yysyntax_error_status == 1)
- {
- if (yymsg != yymsgbuf)
- YYSTACK_FREE (yymsg);
- yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
- if (!yymsg)
- {
- yymsg = yymsgbuf;
- yymsg_alloc = sizeof yymsgbuf;
- yysyntax_error_status = 2;
- }
- else
- {
- yysyntax_error_status = YYSYNTAX_ERROR;
- yymsgp = yymsg;
- }
- }
- yyerror (&yylloc, ctx, yymsgp);
- if (yysyntax_error_status == 2)
- goto yyexhaustedlab;
- }
-# undef YYSYNTAX_ERROR
-#endif
- }
-
- yyerror_range[1] = yylloc;
-
- if (yyerrstatus == 3)
- {
- /* If just tried and failed to reuse lookahead token after an
- error, discard it. */
-
- if (yychar <= YYEOF)
- {
- /* Return failure if at end of input. */
- if (yychar == YYEOF)
- YYABORT;
- }
- else
- {
- yydestruct ("Error: discarding",
- yytoken, &yylval, &yylloc, ctx);
- yychar = YYEMPTY;
- }
- }
-
- /* Else will try to reuse lookahead token after shifting the error
- token. */
- goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR. |
-`---------------------------------------------------*/
-yyerrorlab:
- /* Pacify compilers when the user code never invokes YYERROR and the
- label yyerrorlab therefore never appears in user code. */
- if (0)
- YYERROR;
-
- /* Do not reclaim the symbols of the rule whose action triggered
- this YYERROR. */
- YYPOPSTACK (yylen);
- yylen = 0;
- YY_STACK_PRINT (yyss, yyssp);
- yystate = *yyssp;
- goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR. |
-`-------------------------------------------------------------*/
-yyerrlab1:
- yyerrstatus = 3; /* Each real token shifted decrements this. */
-
- for (;;)
- {
- yyn = yypact[yystate];
- if (!yypact_value_is_default (yyn))
- {
- 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;
-
- yyerror_range[1] = *yylsp;
- yydestruct ("Error: popping",
- yystos[yystate], yyvsp, yylsp, ctx);
- YYPOPSTACK (1);
- yystate = *yyssp;
- YY_STACK_PRINT (yyss, yyssp);
- }
-
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- *++yyvsp = yylval;
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-
- yyerror_range[2] = yylloc;
- /* Using YYLLOC is tempting, but would change the location of
- the lookahead. YYLOC is available though. */
- YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
- *++yylsp = yyloc;
-
- /* Shift the error token. */
- YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
-
- yystate = yyn;
- goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here. |
-`-------------------------------------*/
-yyacceptlab:
- yyresult = 0;
- goto yyreturn;
-
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here. |
-`-----------------------------------*/
-yyabortlab:
- yyresult = 1;
- goto yyreturn;
-
-
-#if !defined yyoverflow || YYERROR_VERBOSE
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here. |
-`-------------------------------------------------*/
-yyexhaustedlab:
- yyerror (&yylloc, ctx, YY_("memory exhausted"));
- yyresult = 2;
- /* Fall through. */
-#endif
-
-
-/*-----------------------------------------------------.
-| yyreturn -- parsing is finished, return the result. |
-`-----------------------------------------------------*/
-yyreturn:
- if (yychar != YYEMPTY)
- {
- /* Make sure we have latest lookahead translation. See comments at
- user semantic actions for why this is necessary. */
- yytoken = YYTRANSLATE (yychar);
- yydestruct ("Cleanup: discarding lookahead",
- yytoken, &yylval, &yylloc, ctx);
- }
- /* Do not reclaim the symbols of the rule whose action triggered
- this YYABORT or YYACCEPT. */
- YYPOPSTACK (yylen);
- YY_STACK_PRINT (yyss, yyssp);
- while (yyssp != yyss)
- {
- yydestruct ("Cleanup: popping",
- yystos[*yyssp], yyvsp, yylsp, ctx);
- YYPOPSTACK (1);
- }
-#ifndef yyoverflow
- if (yyss != yyssa)
- YYSTACK_FREE (yyss);
-#endif
-#if YYERROR_VERBOSE
- if (yymsg != yymsgbuf)
- YYSTACK_FREE (yymsg);
-#endif
- return yyresult;
-}
+++ /dev/null
-/* A Bison parser, made by GNU Bison 3.3.2. */
-
-/* Bison interface for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 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 3 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, see <http://www.gnu.org/licenses/>. */
-
-/* As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
-
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison. */
-
-/* Undocumented macros, especially those whose name start with YY_,
- are private implementation details. Do not rely on them. */
-
-#ifndef YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
-# define YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED
-/* Debug traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int xlu__cfg_yydebug;
-#endif
-
-/* Token type. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- enum yytokentype
- {
- IDENT = 258,
- STRING = 259,
- NUMBER = 260,
- NEWLINE = 261,
- OP_ADD = 262
- };
-#endif
-
-/* Value type. */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-
-union YYSTYPE
-{
-#line 25 "libxlu_cfg_y.y" /* yacc.c:1921 */
-
- char *string;
- XLU_ConfigValue *value;
-
-#line 71 "libxlu_cfg_y.h" /* yacc.c:1921 */
-};
-
-typedef union YYSTYPE YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-/* Location type. */
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE YYLTYPE;
-struct YYLTYPE
-{
- int first_line;
- int first_column;
- int last_line;
- int last_column;
-};
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
-
-int xlu__cfg_yyparse (CfgParseContext *ctx);
-
-#endif /* !YY_XLU_CFG_YY_LIBXLU_CFG_Y_H_INCLUDED */
+++ /dev/null
-/* -*- fundamental -*- */
-/*
- * libxlu_cfg_l.y - xl configuration file parsing: parser
- *
- * Copyright (C) 2010 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-
-%{
-#define ctx_scanner ctx->scanner
-#include "libxlu_cfg_i.h"
-#include "libxlu_cfg_l.h"
-%}
-
-%union {
- char *string;
- XLU_ConfigValue *value;
-}
-
-%locations
-%pure-parser
-%defines
-%error-verbose
-%name-prefix "xlu__cfg_yy"
-%parse-param { CfgParseContext *ctx }
-%lex-param { ctx_scanner }
-
-%token <string> IDENT STRING NUMBER NEWLINE
-%type <string> atom
-%destructor { free($$); } atom IDENT STRING NUMBER
-%token OP_ADD "+="
-
-%type <value> value valuelist values
-%destructor { xlu__cfg_value_free($$); } value valuelist values
-
-%%
-
-file: stmts
- | stmts assignment
-
-stmts: /* empty */
- | stmts stmt
-
-stmt: assignment endstmt
- | endstmt
- | error NEWLINE
-
-assignment: IDENT '=' value { xlu__cfg_set_store(ctx,$1,XLU_OP_ASSIGNMENT,$3,@3.first_line); }
- | IDENT "+=" value { xlu__cfg_set_store(ctx,$1,XLU_OP_ADDITION,$3,@3.first_line); }
-
-endstmt: NEWLINE
- | ';'
-
-value: atom { $$= xlu__cfg_string_mk(ctx,$1,&@1); }
- | '[' nlok valuelist ']' { $$= $3; }
-
-atom: STRING { $$= $1; }
- | NUMBER { $$= $1; }
-
-valuelist: /* empty */ { $$= xlu__cfg_list_mk(ctx,NULL,&yylloc); }
- | values { $$= $1; }
- | values ',' nlok { $$= $1; }
-
-values: value nlok { $$= xlu__cfg_list_mk(ctx,$1,&@1); }
- | values ',' nlok value nlok { xlu__cfg_list_append(ctx,$1,$4); $$= $1; }
-
-nlok:
- /* nothing */
- | nlok NEWLINE
+++ /dev/null
-#include "libxlu_internal.h"
-#include "libxlu_disk_l.h"
-#include "libxlu_disk_i.h"
-#include "libxlu_cfg_i.h"
-
-void xlu__disk_err(DiskParseContext *dpc, const char *erroneous,
- const char *message) {
- fprintf(dpc->cfg->report,
- "%s: config parsing error in disk specification: %s"
- "%s%s%s"
- " in `%s'\n",
- dpc->cfg->config_source, message,
- erroneous?": near `":"", erroneous?erroneous:"", erroneous?"'":"",
- dpc->spec);
- if (!dpc->err) dpc->err= EINVAL;
-}
-
-static int dpc_prep(DiskParseContext *dpc, const char *spec) {
- int e;
-
- dpc->spec = spec;
-
- e = xlu__disk_yylex_init_extra(dpc, &dpc->scanner);
- if (e) goto fail;
-
- dpc->buf = xlu__disk_yy_scan_bytes(spec, strlen(spec), dpc->scanner);
- if (!dpc->buf) { e = ENOMEM; goto fail; }
-
- return 0;
-
- fail:
- fprintf(dpc->cfg->report, "cannot init disk scanner: %s\n",
- strerror(errno));
- return e;
-}
-
-static void dpc_dispose(DiskParseContext *dpc) {
- if (dpc->buf) {
- xlu__disk_yy_delete_buffer(dpc->buf, dpc->scanner);
- dpc->buf = 0;
- }
- if (dpc->scanner) {
- xlu__disk_yylex_destroy(dpc->scanner);
- dpc->scanner = 0;
- }
-}
-
-int xlu_disk_parse(XLU_Config *cfg,
- int nspecs, const char *const *specs,
- libxl_device_disk *disk) {
- DiskParseContext dpc;
- int i, e;
-
- memset(&dpc,0,sizeof(dpc));
- dpc.cfg = cfg;
- dpc.scanner = 0;
- dpc.disk = disk;
-
- disk->readwrite = 1;
-
- for (i=0; i<nspecs; i++) {
- e = dpc_prep(&dpc, specs[i]);
- if (e) { dpc.err = e; goto x_err; }
-
- xlu__disk_yylex(dpc.scanner);
- assert(!e);
- if (dpc.err) goto x_err;
-
- dpc_dispose(&dpc);
- }
-
- if (disk->format == LIBXL_DISK_FORMAT_UNKNOWN) {
- disk->format = LIBXL_DISK_FORMAT_RAW;
- }
- if (disk->is_cdrom) {
- disk->removable = 1;
- disk->readwrite = 0;
- if (!disk->pdev_path || !strcmp(disk->pdev_path, ""))
- disk->format = LIBXL_DISK_FORMAT_EMPTY;
- }
-
- if (!disk->vdev) {
- xlu__disk_err(&dpc,0, "no vdev specified");
- goto x_err;
- }
- if (!disk->pdev_path && !disk->removable) {
- xlu__disk_err(&dpc,0,"no target specified (and device not removable)");
- goto x_err;
- }
-
- x_err:
- dpc_dispose(&dpc);
- return dpc.err;
-}
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-#ifndef LIBXLU_DISK_I_H
-#define LIBXLU_DISK_I_H
-
-#include "libxlu_internal.h"
-
-
-typedef struct {
- XLU_Config *cfg;
- int err;
- void *scanner;
- YY_BUFFER_STATE buf;
- libxl_device_disk *disk;
- int access_set, had_depr_prefix;
- const char *spec;
-} DiskParseContext;
-
-void xlu__disk_err(DiskParseContext *dpc, const char *erroneous,
- const char *message);
-
-
-#endif /*LIBXLU_DISK_I_H*/
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-#line 1 "libxlu_disk_l.c"
-#define _GNU_SOURCE
-
-#line 4 "libxlu_disk_l.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 6
-#define YY_FLEX_SUBMINOR_VERSION 4
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-#ifdef yy_create_buffer
-#define xlu__disk_yy_create_buffer_ALREADY_DEFINED
-#else
-#define yy_create_buffer xlu__disk_yy_create_buffer
-#endif
-
-#ifdef yy_delete_buffer
-#define xlu__disk_yy_delete_buffer_ALREADY_DEFINED
-#else
-#define yy_delete_buffer xlu__disk_yy_delete_buffer
-#endif
-
-#ifdef yy_scan_buffer
-#define xlu__disk_yy_scan_buffer_ALREADY_DEFINED
-#else
-#define yy_scan_buffer xlu__disk_yy_scan_buffer
-#endif
-
-#ifdef yy_scan_string
-#define xlu__disk_yy_scan_string_ALREADY_DEFINED
-#else
-#define yy_scan_string xlu__disk_yy_scan_string
-#endif
-
-#ifdef yy_scan_bytes
-#define xlu__disk_yy_scan_bytes_ALREADY_DEFINED
-#else
-#define yy_scan_bytes xlu__disk_yy_scan_bytes
-#endif
-
-#ifdef yy_init_buffer
-#define xlu__disk_yy_init_buffer_ALREADY_DEFINED
-#else
-#define yy_init_buffer xlu__disk_yy_init_buffer
-#endif
-
-#ifdef yy_flush_buffer
-#define xlu__disk_yy_flush_buffer_ALREADY_DEFINED
-#else
-#define yy_flush_buffer xlu__disk_yy_flush_buffer
-#endif
-
-#ifdef yy_load_buffer_state
-#define xlu__disk_yy_load_buffer_state_ALREADY_DEFINED
-#else
-#define yy_load_buffer_state xlu__disk_yy_load_buffer_state
-#endif
-
-#ifdef yy_switch_to_buffer
-#define xlu__disk_yy_switch_to_buffer_ALREADY_DEFINED
-#else
-#define yy_switch_to_buffer xlu__disk_yy_switch_to_buffer
-#endif
-
-#ifdef yypush_buffer_state
-#define xlu__disk_yypush_buffer_state_ALREADY_DEFINED
-#else
-#define yypush_buffer_state xlu__disk_yypush_buffer_state
-#endif
-
-#ifdef yypop_buffer_state
-#define xlu__disk_yypop_buffer_state_ALREADY_DEFINED
-#else
-#define yypop_buffer_state xlu__disk_yypop_buffer_state
-#endif
-
-#ifdef yyensure_buffer_stack
-#define xlu__disk_yyensure_buffer_stack_ALREADY_DEFINED
-#else
-#define yyensure_buffer_stack xlu__disk_yyensure_buffer_stack
-#endif
-
-#ifdef yylex
-#define xlu__disk_yylex_ALREADY_DEFINED
-#else
-#define yylex xlu__disk_yylex
-#endif
-
-#ifdef yyrestart
-#define xlu__disk_yyrestart_ALREADY_DEFINED
-#else
-#define yyrestart xlu__disk_yyrestart
-#endif
-
-#ifdef yylex_init
-#define xlu__disk_yylex_init_ALREADY_DEFINED
-#else
-#define yylex_init xlu__disk_yylex_init
-#endif
-
-#ifdef yylex_init_extra
-#define xlu__disk_yylex_init_extra_ALREADY_DEFINED
-#else
-#define yylex_init_extra xlu__disk_yylex_init_extra
-#endif
-
-#ifdef yylex_destroy
-#define xlu__disk_yylex_destroy_ALREADY_DEFINED
-#else
-#define yylex_destroy xlu__disk_yylex_destroy
-#endif
-
-#ifdef yyget_debug
-#define xlu__disk_yyget_debug_ALREADY_DEFINED
-#else
-#define yyget_debug xlu__disk_yyget_debug
-#endif
-
-#ifdef yyset_debug
-#define xlu__disk_yyset_debug_ALREADY_DEFINED
-#else
-#define yyset_debug xlu__disk_yyset_debug
-#endif
-
-#ifdef yyget_extra
-#define xlu__disk_yyget_extra_ALREADY_DEFINED
-#else
-#define yyget_extra xlu__disk_yyget_extra
-#endif
-
-#ifdef yyset_extra
-#define xlu__disk_yyset_extra_ALREADY_DEFINED
-#else
-#define yyset_extra xlu__disk_yyset_extra
-#endif
-
-#ifdef yyget_in
-#define xlu__disk_yyget_in_ALREADY_DEFINED
-#else
-#define yyget_in xlu__disk_yyget_in
-#endif
-
-#ifdef yyset_in
-#define xlu__disk_yyset_in_ALREADY_DEFINED
-#else
-#define yyset_in xlu__disk_yyset_in
-#endif
-
-#ifdef yyget_out
-#define xlu__disk_yyget_out_ALREADY_DEFINED
-#else
-#define yyget_out xlu__disk_yyget_out
-#endif
-
-#ifdef yyset_out
-#define xlu__disk_yyset_out_ALREADY_DEFINED
-#else
-#define yyset_out xlu__disk_yyset_out
-#endif
-
-#ifdef yyget_leng
-#define xlu__disk_yyget_leng_ALREADY_DEFINED
-#else
-#define yyget_leng xlu__disk_yyget_leng
-#endif
-
-#ifdef yyget_text
-#define xlu__disk_yyget_text_ALREADY_DEFINED
-#else
-#define yyget_text xlu__disk_yyget_text
-#endif
-
-#ifdef yyget_lineno
-#define xlu__disk_yyget_lineno_ALREADY_DEFINED
-#else
-#define yyget_lineno xlu__disk_yyget_lineno
-#endif
-
-#ifdef yyset_lineno
-#define xlu__disk_yyset_lineno_ALREADY_DEFINED
-#else
-#define yyset_lineno xlu__disk_yyset_lineno
-#endif
-
-#ifdef yyget_column
-#define xlu__disk_yyget_column_ALREADY_DEFINED
-#else
-#define yyget_column xlu__disk_yyget_column
-#endif
-
-#ifdef yyset_column
-#define xlu__disk_yyset_column_ALREADY_DEFINED
-#else
-#define yyset_column xlu__disk_yyset_column
-#endif
-
-#ifdef yywrap
-#define xlu__disk_yywrap_ALREADY_DEFINED
-#else
-#define yywrap xlu__disk_yywrap
-#endif
-
-#ifdef yyalloc
-#define xlu__disk_yyalloc_ALREADY_DEFINED
-#else
-#define yyalloc xlu__disk_yyalloc
-#endif
-
-#ifdef yyrealloc
-#define xlu__disk_yyrealloc_ALREADY_DEFINED
-#else
-#define yyrealloc xlu__disk_yyrealloc
-#endif
-
-#ifdef yyfree
-#define xlu__disk_yyfree_ALREADY_DEFINED
-#else
-#define yyfree xlu__disk_yyfree
-#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
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types.
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#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;
-
-/* 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
-
-#ifndef SIZE_MAX
-#define SIZE_MAX (~(size_t)0)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-/* begin standard C++ headers. */
-
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an
- * integer in range [0..255] for use as an array index.
- */
-#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
- are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* 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 yyg->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 ((yyg->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 yyrestart( yyin , yyscanner )
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
- #define YY_LESS_LINENO(n)
- #define YY_LINENO_REWIND_TO(ptr)
-
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
- do \
- { \
- /* Undo effects of setting up yytext. */ \
- int yyless_macro_arg = (n); \
- YY_LESS_LINENO(yyless_macro_arg);\
- *yy_cp = yyg->yy_hold_char; \
- YY_RESTORE_YY_MORE_OFFSET \
- yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
- YY_DO_BEFORE_ACTION; /* set up yytext again */ \
- } \
- while ( 0 )
-#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-
-#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.
- */
- int 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 yyrestart()), so that the user can continue scanning by
- * just pointing yyin at a new input file.
- */
-#define YY_BUFFER_EOF_PENDING 2
-
- };
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* 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 ( yyg->yy_buffer_stack \
- ? yyg->yy_buffer_stack[yyg->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 yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-
-void yyrestart ( FILE *input_file , yyscan_t yyscanner );
-void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
-void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-void yypop_buffer_state ( yyscan_t yyscanner );
-
-static void yyensure_buffer_stack ( yyscan_t yyscanner );
-static void yy_load_buffer_state ( yyscan_t yyscanner );
-static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner );
-#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner)
-
-YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
-
-void *yyalloc ( yy_size_t , yyscan_t yyscanner );
-void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
-void yyfree ( void * , yyscan_t yyscanner );
-
-#define yy_new_buffer yy_create_buffer
-#define yy_set_interactive(is_interactive) \
- { \
- if ( ! YY_CURRENT_BUFFER ){ \
- yyensure_buffer_stack (yyscanner); \
- YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
- } \
- YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
- }
-#define yy_set_bol(at_bol) \
- { \
- if ( ! YY_CURRENT_BUFFER ){\
- yyensure_buffer_stack (yyscanner); \
- YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \
- } \
- YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
- }
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-#define xlu__disk_yywrap(yyscanner) (/*CONSTCOND*/1)
-#define YY_SKIP_YYWRAP
-typedef flex_uint8_t YY_CHAR;
-
-typedef int yy_state_type;
-
-#define yytext_ptr yytext_r
-
-static yy_state_type yy_get_previous_state ( yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner);
-static int yy_get_next_buffer ( yyscan_t yyscanner );
-static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
- yyg->yytext_ptr = yy_bp; \
- yyg->yytext_ptr -= yyg->yy_more_len; \
- yyleng = (int) (yy_cp - yyg->yytext_ptr); \
- yyg->yy_hold_char = *yy_cp; \
- *yy_cp = '\0'; \
- yyg->yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 36
-#define YY_END_OF_BUFFER 37
-/* 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 const flex_int16_t yy_acclist[575] =
- { 0,
- 35, 35, 37, 33, 34, 36, 8193, 33, 34, 36,
- 16385, 8193, 33, 36,16385, 33, 34, 36, 34, 36,
- 33, 34, 36, 33, 34, 36, 33, 34, 36, 33,
- 34, 36, 33, 34, 36, 33, 34, 36, 33, 34,
- 36, 33, 34, 36, 33, 34, 36, 33, 34, 36,
- 33, 34, 36, 33, 34, 36, 33, 34, 36, 33,
- 34, 36, 33, 34, 36, 33, 34, 36, 35, 36,
- 36, 33, 33, 8193, 33, 8193, 33,16385, 8193, 33,
- 8193, 33, 33, 8224, 33,16416, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
-
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 35,
- 8193, 33, 8193, 33, 8193, 8224, 33, 8224, 33, 8224,
- 23, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 8224, 33, 8224, 33, 8224,
- 23, 33, 33, 28, 8224, 33,16416, 33, 33, 15,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 8217,
- 8224, 33,16409,16416, 33, 33, 31, 8224, 33,16416,
- 33, 8216, 8224, 33,16408,16416, 33, 33, 8219, 8224,
- 33,16411,16416, 33, 33, 33, 33, 33, 28, 8224,
-
- 33, 28, 8224, 33, 28, 33, 28, 8224, 33, 3,
- 33, 15, 33, 33, 33, 33, 33, 30, 8224, 33,
- 16416, 33, 33, 33, 8217, 8224, 33, 8217, 8224, 33,
- 8217, 33, 8217, 8224, 33, 33, 31, 8224, 33, 31,
- 8224, 33, 31, 33, 31, 8224, 8216, 8224, 33, 8216,
- 8224, 33, 8216, 33, 8216, 8224, 33, 8219, 8224, 33,
- 8219, 8224, 33, 8219, 33, 8219, 8224, 33, 33, 10,
- 33, 33, 28, 8224, 33, 28, 8224, 33, 28, 8224,
- 28, 33, 28, 33, 3, 33, 33, 33, 33, 33,
- 33, 33, 30, 8224, 33, 30, 8224, 33, 30, 33,
-
- 30, 8224, 33, 33, 29, 8224, 33,16416, 8217, 8224,
- 33, 8217, 8224, 33, 8217, 8224, 8217, 33, 8217, 33,
- 33, 31, 8224, 33, 31, 8224, 33, 31, 8224, 31,
- 33, 31, 8216, 8224, 33, 8216, 8224, 33, 8216, 8224,
- 8216, 33, 8216, 33, 8219, 8224, 33, 8219, 8224, 33,
- 8219, 8224, 8219, 33, 8219, 33, 33, 10, 23, 10,
- 7, 33, 33, 33, 33, 33, 33, 33, 13, 33,
- 30, 8224, 33, 30, 8224, 33, 30, 8224, 30, 33,
- 30, 2, 33, 29, 8224, 33, 29, 8224, 33, 29,
- 33, 29, 8224, 16, 33, 33, 11, 33, 22, 10,
-
- 10, 23, 7, 23, 7, 33, 8, 33, 33, 33,
- 33, 6, 33, 13, 33, 2, 23, 2, 33, 29,
- 8224, 33, 29, 8224, 33, 29, 8224, 29, 33, 29,
- 16, 33, 33, 11, 23, 11, 26, 8224, 33,16416,
- 22, 23, 22, 7, 7, 23, 33, 8, 23, 8,
- 33, 33, 33, 33, 6, 23, 6, 6, 23, 6,
- 23, 33, 2, 2, 23, 33, 33, 11, 11, 23,
- 26, 8224, 33, 26, 8224, 33, 26, 33, 26, 8224,
- 22, 23, 33, 8, 8, 23, 33, 33, 17, 18,
- 6, 6, 23, 6, 6, 33, 33, 14, 33, 26,
-
- 8224, 33, 26, 8224, 33, 26, 8224, 26, 33, 26,
- 33, 33, 33, 17, 23, 17, 18, 23, 18, 6,
- 6, 33, 33, 14, 33, 20, 9, 19, 17, 17,
- 23, 18, 18, 23, 6, 5, 6, 33, 21, 20,
- 23, 20, 9, 23, 9, 19, 23, 19, 4, 6,
- 5, 6, 33, 21, 23, 21, 20, 20, 23, 9,
- 9, 23, 19, 19, 23, 4, 6, 12, 33, 21,
- 21, 23, 12, 33
- } ;
-
-static const flex_int16_t yy_accept[356] =
- { 0,
- 1, 1, 1, 2, 3, 4, 7, 12, 16, 19,
- 21, 24, 27, 30, 33, 36, 39, 42, 45, 48,
- 51, 54, 57, 60, 63, 66, 69, 71, 72, 73,
- 74, 76, 79, 81, 82, 83, 84, 87, 87, 88,
- 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
- 99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
- 109, 110, 111, 113, 115, 116, 118, 120, 121, 122,
- 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
- 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
- 143, 144, 145, 146, 148, 150, 151, 152, 153, 154,
-
- 158, 159, 160, 162, 163, 164, 165, 166, 167, 168,
- 169, 170, 175, 176, 177, 181, 182, 187, 188, 189,
- 194, 195, 196, 197, 198, 199, 202, 205, 207, 209,
- 210, 212, 214, 215, 216, 217, 218, 222, 223, 224,
- 225, 228, 231, 233, 235, 236, 237, 240, 243, 245,
- 247, 250, 253, 255, 257, 258, 261, 264, 266, 268,
- 269, 270, 271, 272, 273, 276, 279, 281, 283, 284,
- 285, 287, 288, 289, 290, 291, 292, 293, 296, 299,
- 301, 303, 304, 305, 309, 312, 315, 317, 319, 320,
- 321, 322, 325, 328, 330, 332, 333, 336, 339, 341,
-
- 343, 344, 345, 348, 351, 353, 355, 356, 357, 358,
- 360, 361, 362, 363, 364, 365, 366, 367, 368, 369,
- 371, 374, 377, 379, 381, 382, 383, 384, 387, 390,
- 392, 394, 396, 397, 398, 399, 400, 401, 403, 405,
- 406, 407, 408, 409, 410, 411, 412, 413, 414, 416,
- 418, 419, 420, 423, 426, 428, 430, 431, 433, 434,
- 436, 437, 441, 443, 444, 445, 447, 448, 450, 451,
- 452, 453, 454, 455, 457, 458, 460, 462, 463, 464,
- 466, 467, 468, 469, 471, 474, 477, 479, 481, 483,
- 484, 485, 487, 488, 489, 490, 491, 492, 494, 495,
-
- 496, 497, 498, 500, 503, 506, 508, 510, 511, 512,
- 513, 514, 516, 517, 519, 520, 521, 522, 523, 524,
- 526, 527, 528, 529, 530, 532, 533, 535, 536, 538,
- 539, 540, 542, 543, 545, 546, 548, 549, 551, 553,
- 554, 556, 557, 558, 560, 561, 563, 564, 566, 568,
- 570, 571, 573, 575, 575
- } ;
-
-static const YY_CHAR 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, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 4, 5, 1, 1, 6, 6, 7,
- 6, 6, 6, 6, 6, 6, 6, 8, 1, 1,
- 9, 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, 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, 19, 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, 1, 1
- } ;
-
-static const YY_CHAR yy_meta[35] =
- { 0,
- 1, 1, 2, 3, 1, 1, 1, 1, 4, 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
- } ;
-
-static const flex_int16_t yy_base[424] =
- { 0,
- 0, 0, 901, 900, 902, 897, 33, 36, 905, 905,
- 45, 63, 31, 42, 51, 52, 890, 33, 65, 67,
- 69, 70, 889, 71, 888, 75, 0, 905, 893, 905,
- 91, 94, 0, 0, 103, 886, 112, 0, 89, 98,
- 113, 92, 114, 99, 100, 48, 121, 116, 119, 74,
- 124, 129, 123, 135, 132, 133, 137, 134, 138, 139,
- 141, 0, 155, 0, 0, 164, 0, 0, 849, 142,
- 152, 164, 140, 161, 165, 166, 167, 168, 169, 173,
- 174, 178, 176, 180, 184, 208, 189, 183, 192, 195,
- 215, 191, 193, 223, 0, 0, 905, 208, 204, 236,
-
- 219, 209, 238, 196, 237, 831, 242, 815, 241, 224,
- 243, 261, 244, 259, 277, 266, 286, 250, 288, 298,
- 249, 283, 274, 282, 294, 308, 0, 310, 0, 295,
- 305, 905, 308, 306, 313, 314, 342, 319, 316, 320,
- 331, 0, 349, 0, 342, 344, 356, 0, 358, 0,
- 365, 0, 367, 0, 354, 375, 0, 377, 0, 363,
- 356, 809, 327, 322, 384, 0, 0, 0, 0, 379,
- 905, 382, 384, 386, 390, 372, 392, 403, 0, 410,
- 0, 407, 413, 423, 426, 0, 0, 0, 0, 409,
- 424, 435, 0, 0, 0, 0, 437, 0, 0, 0,
-
- 0, 433, 444, 0, 0, 0, 0, 391, 440, 781,
- 905, 769, 439, 445, 444, 447, 449, 454, 453, 399,
- 464, 0, 0, 0, 0, 757, 465, 476, 0, 478,
- 0, 479, 476, 753, 462, 490, 749, 905, 745, 905,
- 483, 737, 424, 485, 487, 490, 500, 493, 905, 729,
- 905, 502, 518, 0, 0, 0, 0, 905, 498, 721,
- 905, 527, 713, 0, 705, 905, 495, 697, 905, 365,
- 521, 528, 530, 685, 905, 534, 540, 540, 657, 905,
- 537, 542, 650, 905, 553, 0, 557, 0, 0, 551,
- 641, 905, 558, 557, 633, 614, 613, 905, 547, 555,
-
- 563, 565, 569, 584, 0, 0, 0, 0, 583, 570,
- 585, 612, 905, 601, 905, 522, 580, 589, 594, 905,
- 600, 585, 563, 520, 905, 514, 905, 586, 486, 597,
- 480, 441, 905, 416, 905, 345, 905, 334, 905, 601,
- 254, 905, 242, 905, 200, 905, 151, 905, 905, 607,
- 86, 905, 905, 905, 620, 624, 627, 631, 635, 639,
- 643, 647, 651, 655, 659, 663, 667, 671, 675, 679,
- 683, 687, 691, 695, 699, 703, 707, 711, 715, 719,
- 723, 727, 731, 735, 739, 743, 747, 751, 755, 759,
- 763, 767, 771, 775, 779, 783, 787, 791, 795, 799,
-
- 803, 807, 811, 815, 819, 823, 827, 831, 835, 839,
- 843, 847, 851, 855, 859, 863, 867, 871, 875, 879,
- 883, 887, 891
- } ;
-
-static const flex_int16_t yy_def[424] =
- { 0,
- 354, 1, 355, 355, 354, 356, 357, 357, 354, 354,
- 358, 358, 12, 12, 12, 12, 12, 12, 12, 12,
- 12, 12, 12, 12, 12, 12, 359, 354, 356, 354,
- 360, 357, 361, 361, 362, 12, 356, 363, 12, 12,
- 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 12, 359, 360, 361, 361, 364, 365, 365, 354, 12,
- 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 12, 12, 12, 12, 12, 362, 12, 12, 12, 12,
- 12, 12, 12, 364, 365, 365, 354, 12, 12, 366,
-
- 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 12, 367, 86, 86, 368, 12, 369, 12, 12, 370,
- 12, 12, 12, 12, 12, 371, 372, 366, 372, 12,
- 12, 354, 86, 12, 12, 12, 373, 12, 12, 12,
- 374, 375, 367, 375, 86, 86, 376, 377, 368, 377,
- 378, 379, 369, 379, 12, 380, 381, 370, 381, 12,
- 12, 382, 12, 12, 371, 372, 372, 383, 383, 12,
- 354, 86, 86, 86, 12, 12, 12, 384, 385, 373,
- 385, 12, 12, 386, 374, 375, 375, 387, 387, 86,
- 86, 376, 377, 377, 388, 388, 378, 379, 379, 389,
-
- 389, 12, 380, 381, 381, 390, 390, 12, 12, 391,
- 354, 392, 86, 12, 86, 86, 86, 12, 86, 12,
- 384, 385, 385, 393, 393, 394, 86, 395, 396, 386,
- 396, 86, 86, 397, 12, 398, 391, 354, 399, 354,
- 86, 400, 12, 86, 86, 86, 401, 86, 354, 402,
- 354, 86, 395, 396, 396, 403, 403, 354, 86, 404,
- 354, 405, 406, 406, 399, 354, 86, 407, 354, 12,
- 86, 86, 86, 408, 354, 408, 408, 86, 402, 354,
- 86, 86, 404, 354, 409, 410, 405, 410, 406, 86,
- 407, 354, 12, 86, 411, 412, 408, 354, 408, 408,
-
- 86, 86, 86, 409, 410, 410, 413, 413, 86, 12,
- 86, 414, 354, 415, 354, 408, 408, 86, 86, 354,
- 416, 417, 418, 414, 354, 415, 354, 408, 408, 86,
- 419, 420, 354, 421, 354, 422, 354, 408, 354, 86,
- 423, 354, 420, 354, 421, 354, 422, 354, 354, 86,
- 423, 354, 354, 0, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
-
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354
- } ;
-
-static const flex_int16_t yy_nxt[940] =
- { 0,
- 6, 7, 8, 9, 6, 6, 6, 6, 10, 11,
- 12, 13, 14, 15, 16, 17, 18, 19, 17, 17,
- 17, 17, 20, 17, 21, 22, 23, 24, 25, 17,
- 26, 17, 17, 17, 32, 32, 33, 32, 32, 33,
- 36, 34, 36, 42, 34, 29, 29, 29, 30, 35,
- 50, 36, 37, 38, 43, 44, 39, 36, 79, 45,
- 36, 36, 40, 29, 29, 29, 30, 35, 46, 48,
- 37, 38, 41, 47, 36, 49, 36, 53, 36, 36,
- 36, 56, 58, 36, 36, 55, 82, 60, 51, 342,
- 54, 61, 52, 29, 64, 32, 32, 33, 36, 65,
-
- 70, 36, 34, 29, 29, 29, 30, 36, 36, 36,
- 29, 38, 66, 66, 66, 67, 66, 71, 74, 66,
- 68, 72, 36, 36, 73, 36, 77, 78, 36, 76,
- 36, 53, 36, 36, 75, 85, 80, 83, 36, 86,
- 84, 36, 36, 36, 36, 81, 36, 36, 36, 36,
- 36, 36, 93, 89, 337, 98, 88, 29, 64, 101,
- 90, 36, 91, 65, 92, 87, 29, 95, 89, 99,
- 36, 100, 96, 36, 36, 36, 36, 36, 36, 106,
- 105, 85, 36, 36, 102, 36, 107, 36, 103, 36,
- 109, 112, 36, 36, 104, 108, 115, 110, 36, 117,
-
- 36, 36, 36, 335, 36, 36, 122, 111, 29, 29,
- 29, 30, 118, 36, 116, 29, 38, 36, 36, 113,
- 114, 119, 120, 123, 36, 29, 95, 121, 36, 134,
- 131, 96, 130, 36, 125, 124, 126, 126, 66, 127,
- 126, 132, 133, 126, 129, 333, 36, 36, 135, 137,
- 36, 36, 36, 140, 139, 35, 35, 352, 36, 36,
- 85, 141, 141, 66, 142, 141, 160, 145, 141, 144,
- 35, 35, 89, 117, 155, 36, 146, 147, 147, 66,
- 148, 147, 162, 36, 147, 150, 151, 151, 66, 152,
- 151, 36, 36, 151, 154, 120, 161, 36, 156, 156,
-
- 66, 157, 156, 36, 36, 156, 159, 164, 171, 163,
- 29, 166, 29, 168, 36, 36, 167, 170, 169, 35,
- 35, 172, 36, 36, 173, 36, 213, 184, 36, 36,
- 175, 36, 174, 29, 186, 212, 36, 349, 183, 187,
- 177, 176, 178, 178, 66, 179, 178, 182, 348, 178,
- 181, 29, 188, 35, 35, 35, 35, 189, 29, 193,
- 29, 195, 190, 36, 194, 36, 196, 29, 198, 29,
- 200, 191, 36, 199, 36, 201, 219, 29, 204, 29,
- 206, 36, 202, 205, 209, 207, 29, 166, 36, 293,
- 208, 214, 167, 35, 35, 35, 35, 35, 35, 36,
-
- 36, 36, 249, 218, 220, 29, 222, 216, 36, 217,
- 235, 223, 29, 224, 215, 226, 36, 227, 225, 346,
- 35, 35, 36, 228, 228, 66, 229, 228, 29, 186,
- 228, 231, 232, 36, 187, 233, 35, 29, 193, 29,
- 198, 234, 36, 194, 344, 199, 29, 204, 236, 36,
- 35, 241, 205, 242, 36, 35, 35, 270, 35, 35,
- 35, 35, 247, 36, 35, 35, 29, 222, 244, 262,
- 248, 36, 223, 243, 245, 246, 35, 252, 29, 254,
- 29, 256, 258, 342, 255, 259, 257, 35, 35, 339,
- 35, 35, 69, 264, 35, 35, 35, 35, 35, 35,
-
- 267, 35, 35, 275, 35, 35, 35, 35, 271, 35,
- 35, 276, 277, 35, 35, 272, 278, 315, 273, 281,
- 29, 254, 290, 313, 282, 275, 255, 285, 285, 66,
- 286, 285, 35, 35, 285, 288, 295, 298, 296, 35,
- 35, 35, 35, 298, 301, 328, 299, 294, 35, 35,
- 275, 35, 35, 35, 303, 29, 305, 300, 275, 29,
- 307, 306, 35, 35, 302, 308, 337, 36, 35, 35,
- 309, 310, 320, 316, 35, 35, 35, 35, 322, 36,
- 35, 35, 317, 275, 319, 311, 29, 305, 335, 275,
- 318, 321, 306, 323, 35, 35, 35, 35, 330, 329,
-
- 35, 35, 331, 333, 327, 35, 35, 338, 35, 35,
- 353, 340, 35, 35, 350, 325, 275, 315, 35, 35,
- 27, 27, 27, 27, 29, 29, 29, 31, 31, 31,
- 31, 36, 36, 36, 36, 62, 313, 62, 62, 63,
- 63, 63, 63, 65, 269, 65, 65, 35, 35, 35,
- 35, 69, 69, 261, 69, 94, 94, 94, 94, 96,
- 251, 96, 96, 128, 128, 128, 128, 143, 143, 143,
- 143, 149, 149, 149, 149, 153, 153, 153, 153, 158,
- 158, 158, 158, 165, 165, 165, 165, 167, 298, 167,
- 167, 180, 180, 180, 180, 185, 185, 185, 185, 187,
-
- 292, 187, 187, 192, 192, 192, 192, 194, 240, 194,
- 194, 197, 197, 197, 197, 199, 289, 199, 199, 203,
- 203, 203, 203, 205, 284, 205, 205, 210, 210, 210,
- 210, 169, 280, 169, 169, 221, 221, 221, 221, 223,
- 269, 223, 223, 230, 230, 230, 230, 189, 266, 189,
- 189, 196, 211, 196, 196, 201, 261, 201, 201, 207,
- 251, 207, 207, 237, 237, 237, 237, 239, 239, 239,
- 239, 225, 240, 225, 225, 250, 250, 250, 250, 253,
- 253, 253, 253, 255, 238, 255, 255, 260, 260, 260,
- 260, 263, 263, 263, 263, 265, 265, 265, 265, 268,
-
- 268, 268, 268, 274, 274, 274, 274, 279, 279, 279,
- 279, 257, 211, 257, 257, 283, 283, 283, 283, 287,
- 287, 287, 287, 264, 138, 264, 264, 291, 291, 291,
- 291, 297, 297, 297, 297, 304, 304, 304, 304, 306,
- 136, 306, 306, 312, 312, 312, 312, 314, 314, 314,
- 314, 308, 97, 308, 308, 324, 324, 324, 324, 326,
- 326, 326, 326, 332, 332, 332, 332, 334, 334, 334,
- 334, 336, 336, 336, 336, 341, 341, 341, 341, 343,
- 343, 343, 343, 345, 345, 345, 345, 347, 347, 347,
- 347, 351, 351, 351, 351, 36, 30, 59, 57, 36,
-
- 30, 354, 28, 28, 5, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354
- } ;
-
-static const flex_int16_t yy_chk[940] =
- { 0,
- 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, 7, 7, 7, 8, 8, 8,
- 13, 7, 18, 13, 8, 11, 11, 11, 11, 11,
- 18, 14, 11, 11, 13, 14, 11, 46, 46, 14,
- 15, 16, 11, 12, 12, 12, 12, 12, 14, 16,
- 12, 12, 12, 15, 19, 16, 20, 20, 21, 22,
- 24, 22, 24, 50, 26, 21, 50, 26, 19, 351,
- 20, 26, 19, 31, 31, 32, 32, 32, 39, 31,
-
- 39, 42, 32, 35, 35, 35, 35, 40, 44, 45,
- 35, 35, 37, 37, 37, 37, 37, 39, 42, 37,
- 37, 40, 41, 43, 41, 48, 45, 45, 49, 44,
- 47, 47, 53, 51, 43, 53, 48, 51, 52, 54,
- 52, 55, 56, 58, 54, 49, 57, 59, 60, 73,
- 61, 70, 60, 61, 347, 70, 56, 63, 63, 73,
- 58, 71, 59, 63, 59, 55, 66, 66, 57, 71,
- 74, 72, 66, 72, 75, 76, 77, 78, 79, 78,
- 77, 79, 80, 81, 74, 83, 80, 82, 75, 84,
- 82, 85, 88, 85, 76, 81, 87, 83, 87, 89,
-
- 92, 89, 93, 345, 90, 104, 92, 84, 86, 86,
- 86, 86, 90, 99, 88, 86, 86, 98, 102, 86,
- 86, 91, 91, 93, 91, 94, 94, 91, 101, 104,
- 102, 94, 101, 110, 99, 98, 100, 100, 100, 100,
- 100, 103, 103, 100, 100, 343, 105, 103, 105, 107,
- 109, 107, 111, 110, 109, 113, 113, 341, 121, 118,
- 111, 112, 112, 112, 112, 112, 121, 113, 112, 112,
- 114, 114, 116, 116, 118, 116, 114, 115, 115, 115,
- 115, 115, 123, 123, 115, 115, 117, 117, 117, 117,
- 117, 124, 122, 117, 117, 119, 122, 119, 120, 120,
-
- 120, 120, 120, 125, 130, 120, 120, 125, 131, 124,
- 126, 126, 128, 128, 131, 134, 126, 130, 128, 133,
- 133, 133, 135, 136, 133, 139, 164, 140, 138, 140,
- 134, 164, 133, 141, 141, 163, 163, 338, 139, 141,
- 136, 135, 137, 137, 137, 137, 137, 138, 336, 137,
- 137, 143, 143, 145, 145, 146, 146, 143, 147, 147,
- 149, 149, 145, 155, 147, 161, 149, 151, 151, 153,
- 153, 146, 160, 151, 270, 153, 176, 156, 156, 158,
- 158, 176, 155, 156, 161, 158, 165, 165, 170, 270,
- 160, 170, 165, 172, 172, 173, 173, 174, 174, 175,
-
- 208, 177, 220, 175, 177, 178, 178, 173, 220, 174,
- 208, 178, 180, 180, 172, 182, 182, 183, 180, 334,
- 190, 190, 183, 184, 184, 184, 184, 184, 185, 185,
- 184, 184, 190, 243, 185, 191, 191, 192, 192, 197,
- 197, 202, 202, 192, 332, 197, 203, 203, 209, 209,
- 213, 213, 203, 214, 214, 215, 215, 243, 216, 216,
- 217, 217, 218, 218, 219, 219, 221, 221, 215, 235,
- 219, 235, 221, 214, 216, 217, 227, 227, 228, 228,
- 230, 230, 232, 331, 228, 233, 230, 233, 233, 329,
- 232, 232, 236, 236, 241, 241, 244, 244, 245, 245,
-
- 241, 246, 246, 247, 248, 248, 267, 267, 244, 259,
- 259, 247, 247, 252, 252, 245, 248, 326, 246, 252,
- 253, 253, 267, 324, 259, 316, 253, 262, 262, 262,
- 262, 262, 271, 271, 262, 262, 272, 276, 273, 272,
- 272, 273, 273, 277, 278, 316, 276, 271, 281, 281,
- 299, 278, 278, 282, 282, 285, 285, 277, 300, 287,
- 287, 285, 290, 290, 281, 287, 323, 293, 294, 294,
- 290, 293, 303, 299, 301, 301, 302, 302, 310, 310,
- 303, 303, 300, 317, 302, 294, 304, 304, 322, 328,
- 301, 309, 304, 311, 309, 309, 311, 311, 318, 317,
-
- 318, 318, 319, 321, 314, 319, 319, 328, 330, 330,
- 350, 330, 340, 340, 340, 312, 297, 296, 350, 350,
- 355, 355, 355, 355, 356, 356, 356, 357, 357, 357,
- 357, 358, 358, 358, 358, 359, 295, 359, 359, 360,
- 360, 360, 360, 361, 291, 361, 361, 362, 362, 362,
- 362, 363, 363, 283, 363, 364, 364, 364, 364, 365,
- 279, 365, 365, 366, 366, 366, 366, 367, 367, 367,
- 367, 368, 368, 368, 368, 369, 369, 369, 369, 370,
- 370, 370, 370, 371, 371, 371, 371, 372, 274, 372,
- 372, 373, 373, 373, 373, 374, 374, 374, 374, 375,
-
- 268, 375, 375, 376, 376, 376, 376, 377, 265, 377,
- 377, 378, 378, 378, 378, 379, 263, 379, 379, 380,
- 380, 380, 380, 381, 260, 381, 381, 382, 382, 382,
- 382, 383, 250, 383, 383, 384, 384, 384, 384, 385,
- 242, 385, 385, 386, 386, 386, 386, 387, 239, 387,
- 387, 388, 237, 388, 388, 389, 234, 389, 389, 390,
- 226, 390, 390, 391, 391, 391, 391, 392, 392, 392,
- 392, 393, 212, 393, 393, 394, 394, 394, 394, 395,
- 395, 395, 395, 396, 210, 396, 396, 397, 397, 397,
- 397, 398, 398, 398, 398, 399, 399, 399, 399, 400,
-
- 400, 400, 400, 401, 401, 401, 401, 402, 402, 402,
- 402, 403, 162, 403, 403, 404, 404, 404, 404, 405,
- 405, 405, 405, 406, 108, 406, 406, 407, 407, 407,
- 407, 408, 408, 408, 408, 409, 409, 409, 409, 410,
- 106, 410, 410, 411, 411, 411, 411, 412, 412, 412,
- 412, 413, 69, 413, 413, 414, 414, 414, 414, 415,
- 415, 415, 415, 416, 416, 416, 416, 417, 417, 417,
- 417, 418, 418, 418, 418, 419, 419, 419, 419, 420,
- 420, 420, 420, 421, 421, 421, 421, 422, 422, 422,
- 422, 423, 423, 423, 423, 36, 29, 25, 23, 17,
-
- 6, 5, 4, 3, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354
- } ;
-
-#define YY_TRAILING_MASK 0x2000
-#define YY_TRAILING_HEAD_MASK 0x4000
-#define REJECT \
-{ \
-*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */ \
-yy_cp = yyg->yy_full_match; /* restore poss. backed-over text */ \
-yyg->yy_lp = yyg->yy_full_lp; /* restore orig. accepting pos. */ \
-yyg->yy_state_ptr = yyg->yy_full_state; /* restore orig. state */ \
-yy_current_state = *yyg->yy_state_ptr; /* restore curr. state */ \
-++yyg->yy_lp; \
-goto find_rule; \
-}
-
-#define yymore() (yyg->yy_more_flag = 1)
-#define YY_MORE_ADJ yyg->yy_more_len
-#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "libxlu_disk_l.l"
-/* -*- fundamental -*- */
-/*
- * libxlu_disk_l.l - parser for disk specification strings
- *
- * Copyright (C) 2011 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-/*
- * Parsing the old xm/xend/xl-4.1 disk specs is a tricky problem,
- * because the target string might in theory contain "," which is the
- * delimiter we use for stripping off things on the RHS, and ":",
- * which is the delimiter we use for stripping off things on the LHS.
- *
- * In this parser we do not support such target strings in the old
- * syntax; if the target string has to contain "," or ":" the new
- * syntax's "target=" should be used.
- */
-
-#line 35 "libxlu_disk_l.l"
-#include "libxlu_disk_i.h"
-
-#define YY_NO_INPUT
-
-/* The code generated by flex is missing braces in single line expressions and
- * is not properly indented, which triggers the clang misleading-indentation
- * check that has been made part of -Wall since clang 10. In order to safely
- * disable it on clang versions that don't have the diagnostic implemented
- * also disable the unknown option and pragma warning. */
-#ifdef __clang__
-# pragma clang diagnostic ignored "-Wunknown-pragmas"
-# pragma clang diagnostic ignored "-Wunknown-warning-option"
-# pragma clang diagnostic ignored "-Wmisleading-indentation"
-#endif
-
-/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
- * it to fail to declare these functions, which it defines. So declare
- * them ourselves. Hopefully we won't have to simultaneously support
- * a flex version which declares these differently somehow. */
-int xlu__disk_yyget_column(yyscan_t yyscanner);
-void xlu__disk_yyset_column(int column_no, yyscan_t yyscanner);
-
-
-/*----- useful macros and functions used in actions -----
- * we use macros in the actual rules to keep the actions short
- * and particularly to avoid repeating boilerplate values such as
- * DPC->disk, yytext, etc. */
-
-/* Sets an enum, checking it hasn't already been set to a different value */
-#define DSET(dpc,member,enumname,str,valname) do{ \
- if (dpc->disk->member != LIBXL_DISK_##enumname##_UNKNOWN && \
- dpc->disk->member != LIBXL_DISK_##enumname##_##valname) { \
- xlu__disk_err(dpc, str, TOSTRING(member) " respecified"); \
- } else { \
- dpc->disk->member = LIBXL_DISK_##enumname##_##valname; \
- } \
- }while(0)
-
-/* For actions whose patterns contain '=', finds the start of the value */
-#define FROMEQUALS (strchr(yytext,'=')+1)
-
-/* Chops the delimiter off, modifying yytext and yyleng. */
-#define STRIP(delim) do{ \
- if (yyleng>0 && yytext[yyleng-1]==(delim)) \
- yytext[--yyleng] = 0; \
- }while(0)
-
-/* Sets a string value, checking it hasn't been set already. */
-#define SAVESTRING(what,loc,val) do{ \
- savestring(DPC, what " respecified", &DPC->disk->loc, (val)); \
- }while(0)
-static void savestring(DiskParseContext *dpc, const char *what_respecified,
- char **update, const char *value) {
- if (*update) {
- if (**update) { xlu__disk_err(dpc,value,what_respecified); return; }
- free(*update); /* do not complain about overwriting empty strings */
- }
- *update = strdup(value);
-}
-
-#define DPC dpc /* our convention in lexer helper functions */
-
-/* Sets ->readwrite from the string. This ought to be an enum, perhaps. */
-static void setaccess(DiskParseContext *dpc, const char *str) {
- if (!strcmp(str, "r") || !strcmp(str, "ro")) {
- dpc->disk->readwrite = 0;
- } else if (!strcmp(str, "rw") || !strcmp(str, "w") || !strcmp(str,"")) {
- dpc->disk->readwrite = 1;
- } else {
- xlu__disk_err(dpc,str,"unknown value for access");
- }
-}
-
-/* Sets ->format from the string. IDL should provide something for this. */
-static void setformat(DiskParseContext *dpc, const char *str) {
- if (!strcmp(str,"")) DSET(dpc,format,FORMAT,str,RAW);
- else if (!strcmp(str,"raw")) DSET(dpc,format,FORMAT,str,RAW);
- else if (!strcmp(str,"qcow")) DSET(dpc,format,FORMAT,str,QCOW);
- else if (!strcmp(str,"qcow2")) DSET(dpc,format,FORMAT,str,QCOW2);
- else if (!strcmp(str,"vhd")) DSET(dpc,format,FORMAT,str,VHD);
- else if (!strcmp(str,"empty")) DSET(dpc,format,FORMAT,str,EMPTY);
- else if (!strcmp(str,"qed")) DSET(dpc,format,FORMAT,str,QED);
- else xlu__disk_err(dpc,str,"unknown value for format");
-}
-
-/* Sets ->backend from the string. IDL should provide something for this. */
-static void setbackendtype(DiskParseContext *dpc, const char *str) {
- if ( !strcmp(str,"phy")) DSET(dpc,backend,BACKEND,str,PHY);
- else if (!strcmp(str,"tap")) DSET(dpc,backend,BACKEND,str,TAP);
- else if (!strcmp(str,"qdisk")) DSET(dpc,backend,BACKEND,str,QDISK);
- else xlu__disk_err(dpc,str,"unknown value for backendtype");
-}
-
-/* Sets ->colo-port from the string. COLO need this. */
-static void setcoloport(DiskParseContext *dpc, const char *str) {
- int port = atoi(str);
- if (port) {
- dpc->disk->colo_port = port;
- } else {
- xlu__disk_err(dpc,str,"unknown value for colo_port");
- }
-}
-
-#define DEPRECATE(usewhatinstead) /* not currently reported */
-
-/* Handles a vdev positional parameter which includes a devtype. */
-static int vdev_and_devtype(DiskParseContext *dpc, char *str) {
- /* returns 1 if it was <vdev>:<devtype>, 0 (doing nothing) otherwise */
- char *colon = strrchr(str, ':');
- if (!colon)
- return 0;
-
- DEPRECATE("use `devtype=...'");
- *colon++ = 0;
- SAVESTRING("vdev", vdev, str);
-
- if (!strcmp(colon,"cdrom")) {
- DPC->disk->is_cdrom = 1;
- } else if (!strcmp(colon,"disk")) {
- DPC->disk->is_cdrom = 0;
- } else {
- xlu__disk_err(DPC,colon,"unknown deprecated type");
- }
- return 1;
-}
-
-#undef DPC /* needs to be defined differently the actual lexer */
-#define DPC ((DiskParseContext*)yyextra)
-
-#line 1202 "libxlu_disk_l.c"
-
-#line 1204 "libxlu_disk_l.c"
-
-#define INITIAL 0
-#define LEXERR 1
-
-#ifndef YY_NO_UNISTD_H
-/* 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>
-#endif
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-/* Holds the entire state of the reentrant scanner. */
-struct yyguts_t
- {
-
- /* User-defined. Not touched by flex. */
- YY_EXTRA_TYPE yyextra_r;
-
- /* The rest are the same as the globals declared in the non-reentrant scanner. */
- FILE *yyin_r, *yyout_r;
- size_t yy_buffer_stack_top; /**< index of top of stack. */
- size_t yy_buffer_stack_max; /**< capacity of stack. */
- YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
- char yy_hold_char;
- int yy_n_chars;
- int yyleng_r;
- char *yy_c_buf_p;
- int yy_init;
- int yy_start;
- int yy_did_buffer_switch_on_eof;
- int yy_start_stack_ptr;
- int yy_start_stack_depth;
- int *yy_start_stack;
- yy_state_type yy_last_accepting_state;
- char* yy_last_accepting_cpos;
-
- int yylineno_r;
- int yy_flex_debug_r;
-
- yy_state_type *yy_state_buf;
- yy_state_type *yy_state_ptr;
- char *yy_full_match;
- int yy_lp;
-
- /* These are only needed for trailing context rules,
- * but there's no conditional variable for that yet. */
- int yy_looking_for_trail_begin;
- int yy_full_lp;
- int *yy_full_state;
-
- char *yytext_r;
- int yy_more_flag;
- int yy_more_len;
-
- }; /* end struct yyguts_t */
-
-static int yy_init_globals ( yyscan_t yyscanner );
-
-int yylex_init (yyscan_t* scanner);
-
-int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
-
-/* Accessor methods to globals.
- These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy ( yyscan_t yyscanner );
-
-int yyget_debug ( yyscan_t yyscanner );
-
-void yyset_debug ( int debug_flag , yyscan_t yyscanner );
-
-YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
-
-void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
-
-FILE *yyget_in ( yyscan_t yyscanner );
-
-void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
-
-FILE *yyget_out ( yyscan_t yyscanner );
-
-void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
-
- int yyget_leng ( yyscan_t yyscanner );
-
-char *yyget_text ( yyscan_t yyscanner );
-
-int yyget_lineno ( yyscan_t yyscanner );
-
-void yyset_lineno ( int _line_number , yyscan_t yyscanner );
-
-int yyget_column ( yyscan_t yyscanner );
-
-void yyset_column ( int _column_no , yyscan_t yyscanner );
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap ( yyscan_t yyscanner );
-#else
-extern int yywrap ( yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef YY_NO_UNPUT
-
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput ( yyscan_t yyscanner );
-#else
-static int input ( yyscan_t yyscanner );
-#endif
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#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 do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
-#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) \
- if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
- { \
- int c = '*'; \
- int n; \
- for ( n = 0; n < max_size && \
- (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
- buf[n] = (char) c; \
- if ( c == '\n' ) \
- buf[n++] = (char) c; \
- if ( c == EOF && ferror( yyin ) ) \
- YY_FATAL_ERROR( "input in flex scanner failed" ); \
- result = n; \
- } \
- else \
- { \
- errno=0; \
- while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
- { \
- if( errno != EINTR) \
- { \
- YY_FATAL_ERROR( "input in flex scanner failed" ); \
- break; \
- } \
- errno=0; \
- clearerr(yyin); \
- } \
- }\
-\
-
-#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 , yyscanner)
-#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 yylex (yyscan_t yyscanner);
-
-#define YY_DECL int yylex (yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * 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 /*LINTED*/break;
-#endif
-
-#define YY_RULE_SETUP \
- YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
- yy_state_type yy_current_state;
- char *yy_cp, *yy_bp;
- int yy_act;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if ( !yyg->yy_init )
- {
- yyg->yy_init = 1;
-
-#ifdef YY_USER_INIT
- YY_USER_INIT;
-#endif
-
- /* Create the reject buffer large enough to save one state per allowed character. */
- if ( ! yyg->yy_state_buf )
- yyg->yy_state_buf = (yy_state_type *)yyalloc(YY_STATE_BUF_SIZE , yyscanner);
- if ( ! yyg->yy_state_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
-
- if ( ! yyg->yy_start )
- yyg->yy_start = 1; /* first start state */
-
- if ( ! yyin )
- yyin = stdin;
-
- if ( ! yyout )
- yyout = stdout;
-
- if ( ! YY_CURRENT_BUFFER ) {
- yyensure_buffer_stack (yyscanner);
- YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
- }
-
- yy_load_buffer_state( yyscanner );
- }
-
- {
-#line 177 "libxlu_disk_l.l"
-
-
-#line 180 "libxlu_disk_l.l"
- /*----- the scanner rules which do the parsing -----*/
-
-#line 1486 "libxlu_disk_l.c"
-
- while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
- {
- yyg->yy_more_len = 0;
- if ( yyg->yy_more_flag )
- {
- yyg->yy_more_len = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
- yyg->yy_more_flag = 0;
- }
- yy_cp = yyg->yy_c_buf_p;
-
- /* Support of yytext. */
- *yy_cp = yyg->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 = yyg->yy_start;
-
- yyg->yy_state_ptr = yyg->yy_state_buf;
- *yyg->yy_state_ptr++ = yy_current_state;
-
-yy_match:
- do
- {
- YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 355 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- *yyg->yy_state_ptr++ = yy_current_state;
- ++yy_cp;
- }
- while ( yy_current_state != 354 );
-
-yy_find_action:
- yy_current_state = *--yyg->yy_state_ptr;
- yyg->yy_lp = yy_accept[yy_current_state];
-find_rule: /* we branch to this label when backing up */
- for ( ; ; ) /* until we find what rule we matched */
- {
- if ( yyg->yy_lp && yyg->yy_lp < yy_accept[yy_current_state + 1] )
- {
- yy_act = yy_acclist[yyg->yy_lp];
- if ( yy_act & YY_TRAILING_HEAD_MASK ||
- yyg->yy_looking_for_trail_begin )
- {
- if ( yy_act == yyg->yy_looking_for_trail_begin )
- {
- yyg->yy_looking_for_trail_begin = 0;
- yy_act &= ~YY_TRAILING_HEAD_MASK;
- break;
- }
- }
- else if ( yy_act & YY_TRAILING_MASK )
- {
- yyg->yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
- yyg->yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
- }
- else
- {
- yyg->yy_full_match = yy_cp;
- yyg->yy_full_state = yyg->yy_state_ptr;
- yyg->yy_full_lp = yyg->yy_lp;
- break;
- }
- ++yyg->yy_lp;
- goto find_rule;
- }
- --yy_cp;
- yy_current_state = *--yyg->yy_state_ptr;
- yyg->yy_lp = 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
-#line 182 "libxlu_disk_l.l"
-{ /* ignore whitespace before parameters */ }
- YY_BREAK
-/* ordinary parameters setting enums or strings */
-case 2:
-/* rule 2 can match eol */
-YY_RULE_SETUP
-#line 186 "libxlu_disk_l.l"
-{ STRIP(','); setformat(DPC, FROMEQUALS); }
- YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 188 "libxlu_disk_l.l"
-{ DPC->disk->is_cdrom = 1; }
- YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 189 "libxlu_disk_l.l"
-{ DPC->disk->is_cdrom = 1; }
- YY_BREAK
-case 5:
-YY_RULE_SETUP
-#line 190 "libxlu_disk_l.l"
-{ DPC->disk->is_cdrom = 0; }
- YY_BREAK
-case 6:
-/* rule 6 can match eol */
-YY_RULE_SETUP
-#line 191 "libxlu_disk_l.l"
-{ xlu__disk_err(DPC,yytext,"unknown value for type"); }
- YY_BREAK
-case 7:
-/* rule 7 can match eol */
-YY_RULE_SETUP
-#line 193 "libxlu_disk_l.l"
-{ STRIP(','); setaccess(DPC, FROMEQUALS); }
- YY_BREAK
-case 8:
-/* rule 8 can match eol */
-YY_RULE_SETUP
-#line 194 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("backend", backend_domname, FROMEQUALS); }
- YY_BREAK
-case 9:
-/* rule 9 can match eol */
-YY_RULE_SETUP
-#line 195 "libxlu_disk_l.l"
-{ STRIP(','); setbackendtype(DPC,FROMEQUALS); }
- YY_BREAK
-case 10:
-/* rule 10 can match eol */
-YY_RULE_SETUP
-#line 197 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("vdev", vdev, FROMEQUALS); }
- YY_BREAK
-case 11:
-/* rule 11 can match eol */
-YY_RULE_SETUP
-#line 198 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("script", script, FROMEQUALS); }
- YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 199 "libxlu_disk_l.l"
-{ DPC->disk->direct_io_safe = 1; }
- YY_BREAK
-case 13:
-YY_RULE_SETUP
-#line 200 "libxlu_disk_l.l"
-{ libxl_defbool_set(&DPC->disk->discard_enable, true); }
- YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 201 "libxlu_disk_l.l"
-{ libxl_defbool_set(&DPC->disk->discard_enable, false); }
- YY_BREAK
-/* Note that the COLO configuration settings should be considered unstable.
- * They may change incompatibly in future versions of Xen. */
-case 15:
-YY_RULE_SETUP
-#line 204 "libxlu_disk_l.l"
-{ libxl_defbool_set(&DPC->disk->colo_enable, true); }
- YY_BREAK
-case 16:
-YY_RULE_SETUP
-#line 205 "libxlu_disk_l.l"
-{ libxl_defbool_set(&DPC->disk->colo_enable, false); }
- YY_BREAK
-case 17:
-/* rule 17 can match eol */
-YY_RULE_SETUP
-#line 206 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("colo-host", colo_host, FROMEQUALS); }
- YY_BREAK
-case 18:
-/* rule 18 can match eol */
-YY_RULE_SETUP
-#line 207 "libxlu_disk_l.l"
-{ STRIP(','); setcoloport(DPC, FROMEQUALS); }
- YY_BREAK
-case 19:
-/* rule 19 can match eol */
-YY_RULE_SETUP
-#line 208 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("colo-export", colo_export, FROMEQUALS); }
- YY_BREAK
-case 20:
-/* rule 20 can match eol */
-YY_RULE_SETUP
-#line 209 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("active-disk", active_disk, FROMEQUALS); }
- YY_BREAK
-case 21:
-/* rule 21 can match eol */
-YY_RULE_SETUP
-#line 210 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("hidden-disk", hidden_disk, FROMEQUALS); }
- YY_BREAK
-/* the target magic parameter, eats the rest of the string */
-case 22:
-YY_RULE_SETUP
-#line 214 "libxlu_disk_l.l"
-{ STRIP(','); SAVESTRING("target", pdev_path, FROMEQUALS); }
- YY_BREAK
-/* unknown parameters */
-case 23:
-/* rule 23 can match eol */
-YY_RULE_SETUP
-#line 218 "libxlu_disk_l.l"
-{ xlu__disk_err(DPC,yytext,"unknown parameter"); }
- YY_BREAK
-/* deprecated prefixes */
-/* the "/.*" in these patterns ensures that they count as if they
- * matched the whole string, so these patterns take precedence */
-case 24:
-YY_RULE_SETUP
-#line 225 "libxlu_disk_l.l"
-{
- STRIP(':');
- DPC->had_depr_prefix=1; DEPRECATE("use `[format=]...,'");
- setformat(DPC, yytext);
- }
- YY_BREAK
-case 25:
-YY_RULE_SETUP
-#line 231 "libxlu_disk_l.l"
-{
- char *newscript;
- STRIP(':');
- DPC->had_depr_prefix=1; DEPRECATE("use `script=...'");
- if (asprintf(&newscript, "block-%s", yytext) < 0) {
- xlu__disk_err(DPC,yytext,"unable to format script");
- return 0;
- }
- savestring(DPC, "script respecified",
- &DPC->disk->script, newscript);
- free(newscript);
- }
- YY_BREAK
-case 26:
-*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
-yyg->yy_c_buf_p = yy_cp = yy_bp + 8;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
-YY_RULE_SETUP
-#line 244 "libxlu_disk_l.l"
-{ DPC->had_depr_prefix=1; DEPRECATE(0); }
- YY_BREAK
-case 27:
-YY_RULE_SETUP
-#line 245 "libxlu_disk_l.l"
-{ DPC->had_depr_prefix=1; DEPRECATE(0); }
- YY_BREAK
-case 28:
-*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
-yyg->yy_c_buf_p = yy_cp = yy_bp + 4;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
-YY_RULE_SETUP
-#line 246 "libxlu_disk_l.l"
-{ DPC->had_depr_prefix=1; DEPRECATE(0); }
- YY_BREAK
-case 29:
-*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
-yyg->yy_c_buf_p = yy_cp = yy_bp + 6;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
-YY_RULE_SETUP
-#line 247 "libxlu_disk_l.l"
-{ DPC->had_depr_prefix=1; DEPRECATE(0); }
- YY_BREAK
-case 30:
-*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
-yyg->yy_c_buf_p = yy_cp = yy_bp + 5;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
-YY_RULE_SETUP
-#line 248 "libxlu_disk_l.l"
-{ DPC->had_depr_prefix=1; DEPRECATE(0); }
- YY_BREAK
-case 31:
-*yy_cp = yyg->yy_hold_char; /* undo effects of setting up yytext */
-yyg->yy_c_buf_p = yy_cp = yy_bp + 4;
-YY_DO_BEFORE_ACTION; /* set up yytext again */
-YY_RULE_SETUP
-#line 249 "libxlu_disk_l.l"
-{ DPC->had_depr_prefix=1; DEPRECATE(0); }
- YY_BREAK
-case 32:
-/* rule 32 can match eol */
-YY_RULE_SETUP
-#line 251 "libxlu_disk_l.l"
-{
- xlu__disk_err(DPC,yytext,"unknown deprecated disk prefix");
- return 0;
- }
- YY_BREAK
-/* positional parameters */
-case 33:
-/* rule 33 can match eol */
-YY_RULE_SETUP
-#line 258 "libxlu_disk_l.l"
-{
- STRIP(',');
-
- if (DPC->err) {
- /* previous errors may just lead to subsequent ones */
- } else if (!DPC->disk->pdev_path) {
- SAVESTRING("target", pdev_path, yytext);
- } else if (!DPC->had_depr_prefix &&
- DPC->disk->format == LIBXL_DISK_FORMAT_UNKNOWN) {
- if (!*DPC->disk->pdev_path && vdev_and_devtype(DPC,yytext)) {
- DPC->disk->format = LIBXL_DISK_FORMAT_EMPTY;
- } else {
- setformat(DPC,yytext);
- }
- } else if (!DPC->disk->vdev) {
- if (!vdev_and_devtype(DPC,yytext))
- SAVESTRING("vdev", vdev, yytext);
- } else if (!DPC->access_set) {
- DPC->access_set = 1;
- setaccess(DPC,yytext);
- } else {
- xlu__disk_err(DPC,yytext,"too many positional parameters");
- return 0; /* don't print any more errors */
- }
-}
- YY_BREAK
-case 34:
-YY_RULE_SETUP
-#line 284 "libxlu_disk_l.l"
-{
- BEGIN(LEXERR);
- yymore();
-}
- YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 288 "libxlu_disk_l.l"
-{
- xlu__disk_err(DPC,yytext,"bad disk syntax"); return 0;
-}
- YY_BREAK
-case 36:
-YY_RULE_SETUP
-#line 291 "libxlu_disk_l.l"
-YY_FATAL_ERROR( "flex scanner jammed" );
- YY_BREAK
-#line 1839 "libxlu_disk_l.c"
- case YY_STATE_EOF(INITIAL):
- case YY_STATE_EOF(LEXERR):
- yyterminate();
-
- case YY_END_OF_BUFFER:
- {
- /* Amount of text matched not including the EOB char. */
- int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
-
- /* Undo the effects of YY_DO_BEFORE_ACTION. */
- *yy_cp = yyg->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 yyin at a new source and called
- * yylex(). 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.
- */
- yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
- YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
- 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 ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
- { /* This was really a NUL. */
- yy_state_type yy_next_state;
-
- yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
-
- yy_current_state = yy_get_previous_state( yyscanner );
-
- /* 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 , yyscanner);
-
- yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-
- if ( yy_next_state )
- {
- /* Consume the NUL. */
- yy_cp = ++yyg->yy_c_buf_p;
- yy_current_state = yy_next_state;
- goto yy_match;
- }
-
- else
- {
- yy_cp = yyg->yy_c_buf_p;
- goto yy_find_action;
- }
- }
-
- else switch ( yy_get_next_buffer( yyscanner ) )
- {
- case EOB_ACT_END_OF_FILE:
- {
- yyg->yy_did_buffer_switch_on_eof = 0;
-
- if ( yywrap( yyscanner ) )
- {
- /* Note: because we've taken care in
- * yy_get_next_buffer() to have set up
- * yytext, 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.
- */
- yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
-
- yy_act = YY_STATE_EOF(YY_START);
- goto do_action;
- }
-
- else
- {
- if ( ! yyg->yy_did_buffer_switch_on_eof )
- YY_NEW_FILE;
- }
- break;
- }
-
- case EOB_ACT_CONTINUE_SCAN:
- yyg->yy_c_buf_p =
- yyg->yytext_ptr + yy_amount_of_matched_text;
-
- yy_current_state = yy_get_previous_state( yyscanner );
-
- yy_cp = yyg->yy_c_buf_p;
- yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
- goto yy_match;
-
- case EOB_ACT_LAST_MATCH:
- yyg->yy_c_buf_p =
- &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
-
- yy_current_state = yy_get_previous_state( yyscanner );
-
- yy_cp = yyg->yy_c_buf_p;
- yy_bp = yyg->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 user's declarations */
-} /* end of yylex */
-
-/* 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 (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
- char *source = yyg->yytext_ptr;
- int number_to_move, i;
- int ret_val;
-
- if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->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 ( yyg->yy_c_buf_p - yyg->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) (yyg->yy_c_buf_p - yyg->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 = yyg->yy_n_chars = 0;
-
- else
- {
- int 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. */
-
- YY_FATAL_ERROR(
-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-
- }
-
- 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]),
- yyg->yy_n_chars, num_to_read );
-
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
- }
-
- if ( yyg->yy_n_chars == 0 )
- {
- if ( number_to_move == YY_MORE_ADJ )
- {
- ret_val = EOB_ACT_END_OF_FILE;
- yyrestart( yyin , yyscanner);
- }
-
- 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;
-
- if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
- /* Extend the array by 50%, plus the number we really need. */
- int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
- (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );
- if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
- /* "- 2" to take care of EOB's */
- YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
- }
-
- yyg->yy_n_chars += number_to_move;
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
- yyg->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 (yyscan_t yyscanner)
-{
- yy_state_type yy_current_state;
- char *yy_cp;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- yy_current_state = yyg->yy_start;
-
- yyg->yy_state_ptr = yyg->yy_state_buf;
- *yyg->yy_state_ptr++ = yy_current_state;
-
- for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
- {
- YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 355 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- *yyg->yy_state_ptr++ = yy_current_state;
- }
-
- 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 , yyscan_t yyscanner)
-{
- int yy_is_jam;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
-
- YY_CHAR yy_c = 1;
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 355 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- yy_is_jam = (yy_current_state == 354);
- if ( ! yy_is_jam )
- *yyg->yy_state_ptr++ = yy_current_state;
-
- (void)yyg;
- return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_UNPUT
-
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
- static int yyinput (yyscan_t yyscanner)
-#else
- static int input (yyscan_t yyscanner)
-#endif
-
-{
- int c;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- *yyg->yy_c_buf_p = yyg->yy_hold_char;
-
- if ( *yyg->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 ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
- /* This was really a NUL. */
- *yyg->yy_c_buf_p = '\0';
-
- else
- { /* need more input */
- int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);
- ++yyg->yy_c_buf_p;
-
- switch ( yy_get_next_buffer( yyscanner ) )
- {
- 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. */
- yyrestart( yyin , yyscanner);
-
- /*FALLTHROUGH*/
-
- case EOB_ACT_END_OF_FILE:
- {
- if ( yywrap( yyscanner ) )
- return 0;
-
- if ( ! yyg->yy_did_buffer_switch_on_eof )
- YY_NEW_FILE;
-#ifdef __cplusplus
- return yyinput(yyscanner);
-#else
- return input(yyscanner);
-#endif
- }
-
- case EOB_ACT_CONTINUE_SCAN:
- yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
- break;
- }
- }
- }
-
- c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
- *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
- yyg->yy_hold_char = *++yyg->yy_c_buf_p;
-
- return c;
-}
-#endif /* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * @param yyscanner The scanner object.
- * @note This function does not reset the start condition to @c INITIAL .
- */
- void yyrestart (FILE * input_file , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if ( ! YY_CURRENT_BUFFER ){
- yyensure_buffer_stack (yyscanner);
- YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);
- }
-
- yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);
- yy_load_buffer_state( yyscanner );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * @param yyscanner The scanner object.
- */
- void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* TODO. We should be able to replace this entire function body
- * with
- * yypop_buffer_state();
- * yypush_buffer_state(new_buffer);
- */
- yyensure_buffer_stack (yyscanner);
- if ( YY_CURRENT_BUFFER == new_buffer )
- return;
-
- if ( YY_CURRENT_BUFFER )
- {
- /* Flush out information for old buffer. */
- *yyg->yy_c_buf_p = yyg->yy_hold_char;
- YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
- }
-
- YY_CURRENT_BUFFER_LVALUE = new_buffer;
- yy_load_buffer_state( yyscanner );
-
- /* We don't actually know whether we did this switch during
- * EOF (yywrap()) processing, but the only time this flag
- * is looked at is after yywrap() is called, so it's safe
- * to go ahead and always set it.
- */
- yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-static void yy_load_buffer_state (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
- yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
- yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
- yyg->yy_hold_char = *yyg->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.
- * @param yyscanner The scanner object.
- * @return the allocated buffer state.
- */
- YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
-{
- YY_BUFFER_STATE b;
-
- b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
- if ( ! b )
- YY_FATAL_ERROR( "out of dynamic memory in yy_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 *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );
- if ( ! b->yy_ch_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
- b->yy_is_our_buffer = 1;
-
- yy_init_buffer( b, file , yyscanner);
-
- return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with yy_create_buffer()
- * @param yyscanner The scanner object.
- */
- void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- 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 )
- yyfree( (void *) b->yy_ch_buf , yyscanner );
-
- yyfree( (void *) b , yyscanner );
-}
-
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a yyrestart() or at EOF.
- */
- static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
-
-{
- int oerrno = errno;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- yy_flush_buffer( b , yyscanner);
-
- b->yy_input_file = file;
- b->yy_fill_buffer = 1;
-
- /* If b is the current buffer, then yy_init_buffer was _probably_
- * called from yyrestart() 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 = file ? (isatty( fileno(file) ) > 0) : 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.
- * @param yyscanner The scanner object.
- */
- void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- 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 )
- yy_load_buffer_state( yyscanner );
-}
-
-/** 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.
- * @param yyscanner The scanner object.
- */
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- if (new_buffer == NULL)
- return;
-
- yyensure_buffer_stack(yyscanner);
-
- /* This block is copied from yy_switch_to_buffer. */
- if ( YY_CURRENT_BUFFER )
- {
- /* Flush out information for old buffer. */
- *yyg->yy_c_buf_p = yyg->yy_hold_char;
- YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
- }
-
- /* Only push if top exists. Otherwise, replace top. */
- if (YY_CURRENT_BUFFER)
- yyg->yy_buffer_stack_top++;
- YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
- /* copied from yy_switch_to_buffer. */
- yy_load_buffer_state( yyscanner );
- yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- * The next element becomes the new top.
- * @param yyscanner The scanner object.
- */
-void yypop_buffer_state (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- if (!YY_CURRENT_BUFFER)
- return;
-
- yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
- YY_CURRENT_BUFFER_LVALUE = NULL;
- if (yyg->yy_buffer_stack_top > 0)
- --yyg->yy_buffer_stack_top;
-
- if (YY_CURRENT_BUFFER) {
- yy_load_buffer_state( yyscanner );
- yyg->yy_did_buffer_switch_on_eof = 1;
- }
-}
-
-/* Allocates the stack if it does not exist.
- * Guarantees space for at least one push.
- */
-static void yyensure_buffer_stack (yyscan_t yyscanner)
-{
- yy_size_t num_to_alloc;
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if (!yyg->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; /* After all that talk, this was set to 1 anyways... */
- yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
- (num_to_alloc * sizeof(struct yy_buffer_state*)
- , yyscanner);
- if ( ! yyg->yy_buffer_stack )
- YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
- memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-
- yyg->yy_buffer_stack_max = num_to_alloc;
- yyg->yy_buffer_stack_top = 0;
- return;
- }
-
- if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
-
- /* Increase the buffer to prepare for a possible push. */
- yy_size_t grow_size = 8 /* arbitrary grow size */;
-
- num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
- yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
- (yyg->yy_buffer_stack,
- num_to_alloc * sizeof(struct yy_buffer_state*)
- , yyscanner);
- if ( ! yyg->yy_buffer_stack )
- YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
- /* zero only the new slots.*/
- memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
- yyg->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
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
-{
- 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 NULL;
-
- b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
- if ( ! b )
- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
-
- b->yy_buf_size = (int) (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 = NULL;
- 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;
-
- yy_switch_to_buffer( b , yyscanner );
-
- return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- * yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
-{
-
- return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)
-{
- YY_BUFFER_STATE b;
- char *buf;
- yy_size_t n;
- int i;
-
- /* Get memory for full buffer, including space for trailing EOB's. */
- n = (yy_size_t) (_yybytes_len + 2);
- buf = (char *) yyalloc( n , yyscanner );
- if ( ! buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-
- for ( i = 0; i < _yybytes_len; ++i )
- buf[i] = yybytes[i];
-
- buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
- b = yy_scan_buffer( buf, n , yyscanner);
- if ( ! b )
- YY_FATAL_ERROR( "bad buffer in yy_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 yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
- 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 yytext. */ \
- int yyless_macro_arg = (n); \
- YY_LESS_LINENO(yyless_macro_arg);\
- yytext[yyleng] = yyg->yy_hold_char; \
- yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
- yyg->yy_hold_char = *yyg->yy_c_buf_p; \
- *yyg->yy_c_buf_p = '\0'; \
- yyleng = yyless_macro_arg; \
- } \
- while ( 0 )
-
-/* Accessor methods (get/set functions) to struct members. */
-
-/** Get the user-defined data for this scanner.
- * @param yyscanner The scanner object.
- */
-YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyextra;
-}
-
-/** Get the current line number.
- * @param yyscanner The scanner object.
- */
-int yyget_lineno (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if (! YY_CURRENT_BUFFER)
- return 0;
-
- return yylineno;
-}
-
-/** Get the current column number.
- * @param yyscanner The scanner object.
- */
-int yyget_column (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- if (! YY_CURRENT_BUFFER)
- return 0;
-
- return yycolumn;
-}
-
-/** Get the input stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_in (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyin;
-}
-
-/** Get the output stream.
- * @param yyscanner The scanner object.
- */
-FILE *yyget_out (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyout;
-}
-
-/** Get the length of the current token.
- * @param yyscanner The scanner object.
- */
-int yyget_leng (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yyleng;
-}
-
-/** Get the current token.
- * @param yyscanner The scanner object.
- */
-
-char *yyget_text (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yytext;
-}
-
-/** Set the user-defined data. This data is never touched by the scanner.
- * @param user_defined The data to be associated with this scanner.
- * @param yyscanner The scanner object.
- */
-void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyextra = user_defined ;
-}
-
-/** Set the current line number.
- * @param _line_number line number
- * @param yyscanner The scanner object.
- */
-void yyset_lineno (int _line_number , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* lineno is only valid if an input buffer exists. */
- if (! YY_CURRENT_BUFFER )
- YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
-
- yylineno = _line_number;
-}
-
-/** Set the current column.
- * @param _column_no column number
- * @param yyscanner The scanner object.
- */
-void yyset_column (int _column_no , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* column is only valid if an input buffer exists. */
- if (! YY_CURRENT_BUFFER )
- YY_FATAL_ERROR( "yyset_column called with no buffer" );
-
- yycolumn = _column_no;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param _in_str A readable stream.
- * @param yyscanner The scanner object.
- * @see yy_switch_to_buffer
- */
-void yyset_in (FILE * _in_str , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyin = _in_str ;
-}
-
-void yyset_out (FILE * _out_str , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yyout = _out_str ;
-}
-
-int yyget_debug (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- return yy_flex_debug;
-}
-
-void yyset_debug (int _bdebug , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- yy_flex_debug = _bdebug ;
-}
-
-/* Accessor methods for yylval and yylloc */
-
-/* User-visible API */
-
-/* yylex_init is special because it creates the scanner itself, so it is
- * the ONLY reentrant function that doesn't take the scanner as the last argument.
- * That's why we explicitly handle the declaration, instead of using our macros.
- */
-int yylex_init(yyscan_t* ptr_yy_globals)
-{
- if (ptr_yy_globals == NULL){
- errno = EINVAL;
- return 1;
- }
-
- *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
-
- if (*ptr_yy_globals == NULL){
- errno = ENOMEM;
- return 1;
- }
-
- /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
- memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
- return yy_init_globals ( *ptr_yy_globals );
-}
-
-/* yylex_init_extra has the same functionality as yylex_init, but follows the
- * convention of taking the scanner as the last argument. Note however, that
- * this is a *pointer* to a scanner, as it will be allocated by this call (and
- * is the reason, too, why this function also must handle its own declaration).
- * The user defined value in the first argument will be available to yyalloc in
- * the yyextra field.
- */
-int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )
-{
- struct yyguts_t dummy_yyguts;
-
- yyset_extra (yy_user_defined, &dummy_yyguts);
-
- if (ptr_yy_globals == NULL){
- errno = EINVAL;
- return 1;
- }
-
- *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-
- if (*ptr_yy_globals == NULL){
- errno = ENOMEM;
- return 1;
- }
-
- /* By setting to 0xAA, we expose bugs in
- yy_init_globals. Leave at 0x00 for releases. */
- memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
- yyset_extra (yy_user_defined, *ptr_yy_globals);
-
- return yy_init_globals ( *ptr_yy_globals );
-}
-
-static int yy_init_globals (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- /* Initialization is the same as for the non-reentrant scanner.
- * This function is called from yylex_destroy(), so don't allocate here.
- */
-
- yyg->yy_buffer_stack = NULL;
- yyg->yy_buffer_stack_top = 0;
- yyg->yy_buffer_stack_max = 0;
- yyg->yy_c_buf_p = NULL;
- yyg->yy_init = 0;
- yyg->yy_start = 0;
-
- yyg->yy_start_stack_ptr = 0;
- yyg->yy_start_stack_depth = 0;
- yyg->yy_start_stack = NULL;
-
- yyg->yy_state_buf = 0;
- yyg->yy_state_ptr = 0;
- yyg->yy_full_match = 0;
- yyg->yy_lp = 0;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
- yyin = stdin;
- yyout = stdout;
-#else
- yyin = NULL;
- yyout = NULL;
-#endif
-
- /* For future reference: Set errno on error, since we are called by
- * yylex_init()
- */
- return 0;
-}
-
-/* yylex_destroy is for both reentrant and non-reentrant scanners. */
-int yylex_destroy (yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
- /* Pop the buffer stack, destroying each element. */
- while(YY_CURRENT_BUFFER){
- yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
- YY_CURRENT_BUFFER_LVALUE = NULL;
- yypop_buffer_state(yyscanner);
- }
-
- /* Destroy the stack itself. */
- yyfree(yyg->yy_buffer_stack , yyscanner);
- yyg->yy_buffer_stack = NULL;
-
- /* Destroy the start condition stack. */
- yyfree( yyg->yy_start_stack , yyscanner );
- yyg->yy_start_stack = NULL;
-
- yyfree ( yyg->yy_state_buf , yyscanner);
- yyg->yy_state_buf = NULL;
-
- /* Reset the globals. This is important in a non-reentrant scanner so the next time
- * yylex() is called, initialization will occur. */
- yy_init_globals( yyscanner);
-
- /* Destroy the main struct (reentrant only). */
- yyfree ( yyscanner , yyscanner );
- yyscanner = NULL;
- return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
-
- int i;
- for ( i = 0; i < n; ++i )
- s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
-{
- int n;
- for ( n = 0; s[n]; ++n )
- ;
-
- return n;
-}
-#endif
-
-void *yyalloc (yy_size_t size , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
- return malloc(size);
-}
-
-void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
-
- /* 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 realloc(ptr, size);
-}
-
-void yyfree (void * ptr , yyscan_t yyscanner)
-{
- struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
- (void)yyg;
- free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
-}
-
-#define YYTABLES_NAME "yytables"
-
-#line 291 "libxlu_disk_l.l"
+++ /dev/null
-#ifndef xlu__disk_yyHEADER_H
-#define xlu__disk_yyHEADER_H 1
-#define xlu__disk_yyIN_HEADER 1
-
-#line 5 "libxlu_disk_l.h"
-#define _GNU_SOURCE
-
-#line 8 "libxlu_disk_l.h"
-
-#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 6
-#define YY_FLEX_SUBMINOR_VERSION 4
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-#ifdef yy_create_buffer
-#define xlu__disk_yy_create_buffer_ALREADY_DEFINED
-#else
-#define yy_create_buffer xlu__disk_yy_create_buffer
-#endif
-
-#ifdef yy_delete_buffer
-#define xlu__disk_yy_delete_buffer_ALREADY_DEFINED
-#else
-#define yy_delete_buffer xlu__disk_yy_delete_buffer
-#endif
-
-#ifdef yy_scan_buffer
-#define xlu__disk_yy_scan_buffer_ALREADY_DEFINED
-#else
-#define yy_scan_buffer xlu__disk_yy_scan_buffer
-#endif
-
-#ifdef yy_scan_string
-#define xlu__disk_yy_scan_string_ALREADY_DEFINED
-#else
-#define yy_scan_string xlu__disk_yy_scan_string
-#endif
-
-#ifdef yy_scan_bytes
-#define xlu__disk_yy_scan_bytes_ALREADY_DEFINED
-#else
-#define yy_scan_bytes xlu__disk_yy_scan_bytes
-#endif
-
-#ifdef yy_init_buffer
-#define xlu__disk_yy_init_buffer_ALREADY_DEFINED
-#else
-#define yy_init_buffer xlu__disk_yy_init_buffer
-#endif
-
-#ifdef yy_flush_buffer
-#define xlu__disk_yy_flush_buffer_ALREADY_DEFINED
-#else
-#define yy_flush_buffer xlu__disk_yy_flush_buffer
-#endif
-
-#ifdef yy_load_buffer_state
-#define xlu__disk_yy_load_buffer_state_ALREADY_DEFINED
-#else
-#define yy_load_buffer_state xlu__disk_yy_load_buffer_state
-#endif
-
-#ifdef yy_switch_to_buffer
-#define xlu__disk_yy_switch_to_buffer_ALREADY_DEFINED
-#else
-#define yy_switch_to_buffer xlu__disk_yy_switch_to_buffer
-#endif
-
-#ifdef yypush_buffer_state
-#define xlu__disk_yypush_buffer_state_ALREADY_DEFINED
-#else
-#define yypush_buffer_state xlu__disk_yypush_buffer_state
-#endif
-
-#ifdef yypop_buffer_state
-#define xlu__disk_yypop_buffer_state_ALREADY_DEFINED
-#else
-#define yypop_buffer_state xlu__disk_yypop_buffer_state
-#endif
-
-#ifdef yyensure_buffer_stack
-#define xlu__disk_yyensure_buffer_stack_ALREADY_DEFINED
-#else
-#define yyensure_buffer_stack xlu__disk_yyensure_buffer_stack
-#endif
-
-#ifdef yylex
-#define xlu__disk_yylex_ALREADY_DEFINED
-#else
-#define yylex xlu__disk_yylex
-#endif
-
-#ifdef yyrestart
-#define xlu__disk_yyrestart_ALREADY_DEFINED
-#else
-#define yyrestart xlu__disk_yyrestart
-#endif
-
-#ifdef yylex_init
-#define xlu__disk_yylex_init_ALREADY_DEFINED
-#else
-#define yylex_init xlu__disk_yylex_init
-#endif
-
-#ifdef yylex_init_extra
-#define xlu__disk_yylex_init_extra_ALREADY_DEFINED
-#else
-#define yylex_init_extra xlu__disk_yylex_init_extra
-#endif
-
-#ifdef yylex_destroy
-#define xlu__disk_yylex_destroy_ALREADY_DEFINED
-#else
-#define yylex_destroy xlu__disk_yylex_destroy
-#endif
-
-#ifdef yyget_debug
-#define xlu__disk_yyget_debug_ALREADY_DEFINED
-#else
-#define yyget_debug xlu__disk_yyget_debug
-#endif
-
-#ifdef yyset_debug
-#define xlu__disk_yyset_debug_ALREADY_DEFINED
-#else
-#define yyset_debug xlu__disk_yyset_debug
-#endif
-
-#ifdef yyget_extra
-#define xlu__disk_yyget_extra_ALREADY_DEFINED
-#else
-#define yyget_extra xlu__disk_yyget_extra
-#endif
-
-#ifdef yyset_extra
-#define xlu__disk_yyset_extra_ALREADY_DEFINED
-#else
-#define yyset_extra xlu__disk_yyset_extra
-#endif
-
-#ifdef yyget_in
-#define xlu__disk_yyget_in_ALREADY_DEFINED
-#else
-#define yyget_in xlu__disk_yyget_in
-#endif
-
-#ifdef yyset_in
-#define xlu__disk_yyset_in_ALREADY_DEFINED
-#else
-#define yyset_in xlu__disk_yyset_in
-#endif
-
-#ifdef yyget_out
-#define xlu__disk_yyget_out_ALREADY_DEFINED
-#else
-#define yyget_out xlu__disk_yyget_out
-#endif
-
-#ifdef yyset_out
-#define xlu__disk_yyset_out_ALREADY_DEFINED
-#else
-#define yyset_out xlu__disk_yyset_out
-#endif
-
-#ifdef yyget_leng
-#define xlu__disk_yyget_leng_ALREADY_DEFINED
-#else
-#define yyget_leng xlu__disk_yyget_leng
-#endif
-
-#ifdef yyget_text
-#define xlu__disk_yyget_text_ALREADY_DEFINED
-#else
-#define yyget_text xlu__disk_yyget_text
-#endif
-
-#ifdef yyget_lineno
-#define xlu__disk_yyget_lineno_ALREADY_DEFINED
-#else
-#define yyget_lineno xlu__disk_yyget_lineno
-#endif
-
-#ifdef yyset_lineno
-#define xlu__disk_yyset_lineno_ALREADY_DEFINED
-#else
-#define yyset_lineno xlu__disk_yyset_lineno
-#endif
-
-#ifdef yyget_column
-#define xlu__disk_yyget_column_ALREADY_DEFINED
-#else
-#define yyget_column xlu__disk_yyget_column
-#endif
-
-#ifdef yyset_column
-#define xlu__disk_yyset_column_ALREADY_DEFINED
-#else
-#define yyset_column xlu__disk_yyset_column
-#endif
-
-#ifdef yywrap
-#define xlu__disk_yywrap_ALREADY_DEFINED
-#else
-#define yywrap xlu__disk_yywrap
-#endif
-
-#ifdef yyalloc
-#define xlu__disk_yyalloc_ALREADY_DEFINED
-#else
-#define yyalloc xlu__disk_yyalloc
-#endif
-
-#ifdef yyrealloc
-#define xlu__disk_yyrealloc_ALREADY_DEFINED
-#else
-#define yyrealloc xlu__disk_yyrealloc
-#endif
-
-#ifdef yyfree
-#define xlu__disk_yyfree_ALREADY_DEFINED
-#else
-#define yyfree xlu__disk_yyfree
-#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
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types.
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#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;
-
-/* 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
-
-#ifndef SIZE_MAX
-#define SIZE_MAX (~(size_t)0)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-/* begin standard C++ headers. */
-
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
- are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t 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.
- */
- int 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;
-
- };
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-void yyrestart ( FILE *input_file , yyscan_t yyscanner );
-void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
-void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
-void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
-void yypop_buffer_state ( yyscan_t yyscanner );
-
-YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
-YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
-
-void *yyalloc ( yy_size_t , yyscan_t yyscanner );
-void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
-void yyfree ( void * , yyscan_t yyscanner );
-
-#define xlu__disk_yywrap(yyscanner) (/*CONSTCOND*/1)
-#define YY_SKIP_YYWRAP
-
-#define yytext_ptr yytext_r
-
-#ifdef YY_HEADER_EXPORT_START_CONDITIONS
-#define INITIAL 0
-#define LEXERR 1
-
-#endif
-
-#ifndef YY_NO_UNISTD_H
-/* 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>
-#endif
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-int yylex_init (yyscan_t* scanner);
-
-int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
-
-/* Accessor methods to globals.
- These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy ( yyscan_t yyscanner );
-
-int yyget_debug ( yyscan_t yyscanner );
-
-void yyset_debug ( int debug_flag , yyscan_t yyscanner );
-
-YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
-
-void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
-
-FILE *yyget_in ( yyscan_t yyscanner );
-
-void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
-
-FILE *yyget_out ( yyscan_t yyscanner );
-
-void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
-
- int yyget_leng ( yyscan_t yyscanner );
-
-char *yyget_text ( yyscan_t yyscanner );
-
-int yyget_lineno ( yyscan_t yyscanner );
-
-void yyset_lineno ( int _line_number , yyscan_t yyscanner );
-
-int yyget_column ( yyscan_t yyscanner );
-
-void yyset_column ( int _column_no , yyscan_t yyscanner );
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap ( yyscan_t yyscanner );
-#else
-extern int yywrap ( yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* 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 yylex (yyscan_t yyscanner);
-
-#define YY_DECL int yylex (yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-#undef YY_NEW_FILE
-#undef YY_FLUSH_BUFFER
-#undef yy_set_bol
-#undef yy_new_buffer
-#undef yy_set_interactive
-#undef YY_DO_BEFORE_ACTION
-
-#ifdef YY_DECL_IS_OURS
-#undef YY_DECL_IS_OURS
-#undef YY_DECL
-#endif
-
-#ifndef xlu__disk_yy_create_buffer_ALREADY_DEFINED
-#undef yy_create_buffer
-#endif
-#ifndef xlu__disk_yy_delete_buffer_ALREADY_DEFINED
-#undef yy_delete_buffer
-#endif
-#ifndef xlu__disk_yy_scan_buffer_ALREADY_DEFINED
-#undef yy_scan_buffer
-#endif
-#ifndef xlu__disk_yy_scan_string_ALREADY_DEFINED
-#undef yy_scan_string
-#endif
-#ifndef xlu__disk_yy_scan_bytes_ALREADY_DEFINED
-#undef yy_scan_bytes
-#endif
-#ifndef xlu__disk_yy_init_buffer_ALREADY_DEFINED
-#undef yy_init_buffer
-#endif
-#ifndef xlu__disk_yy_flush_buffer_ALREADY_DEFINED
-#undef yy_flush_buffer
-#endif
-#ifndef xlu__disk_yy_load_buffer_state_ALREADY_DEFINED
-#undef yy_load_buffer_state
-#endif
-#ifndef xlu__disk_yy_switch_to_buffer_ALREADY_DEFINED
-#undef yy_switch_to_buffer
-#endif
-#ifndef xlu__disk_yypush_buffer_state_ALREADY_DEFINED
-#undef yypush_buffer_state
-#endif
-#ifndef xlu__disk_yypop_buffer_state_ALREADY_DEFINED
-#undef yypop_buffer_state
-#endif
-#ifndef xlu__disk_yyensure_buffer_stack_ALREADY_DEFINED
-#undef yyensure_buffer_stack
-#endif
-#ifndef xlu__disk_yylex_ALREADY_DEFINED
-#undef yylex
-#endif
-#ifndef xlu__disk_yyrestart_ALREADY_DEFINED
-#undef yyrestart
-#endif
-#ifndef xlu__disk_yylex_init_ALREADY_DEFINED
-#undef yylex_init
-#endif
-#ifndef xlu__disk_yylex_init_extra_ALREADY_DEFINED
-#undef yylex_init_extra
-#endif
-#ifndef xlu__disk_yylex_destroy_ALREADY_DEFINED
-#undef yylex_destroy
-#endif
-#ifndef xlu__disk_yyget_debug_ALREADY_DEFINED
-#undef yyget_debug
-#endif
-#ifndef xlu__disk_yyset_debug_ALREADY_DEFINED
-#undef yyset_debug
-#endif
-#ifndef xlu__disk_yyget_extra_ALREADY_DEFINED
-#undef yyget_extra
-#endif
-#ifndef xlu__disk_yyset_extra_ALREADY_DEFINED
-#undef yyset_extra
-#endif
-#ifndef xlu__disk_yyget_in_ALREADY_DEFINED
-#undef yyget_in
-#endif
-#ifndef xlu__disk_yyset_in_ALREADY_DEFINED
-#undef yyset_in
-#endif
-#ifndef xlu__disk_yyget_out_ALREADY_DEFINED
-#undef yyget_out
-#endif
-#ifndef xlu__disk_yyset_out_ALREADY_DEFINED
-#undef yyset_out
-#endif
-#ifndef xlu__disk_yyget_leng_ALREADY_DEFINED
-#undef yyget_leng
-#endif
-#ifndef xlu__disk_yyget_text_ALREADY_DEFINED
-#undef yyget_text
-#endif
-#ifndef xlu__disk_yyget_lineno_ALREADY_DEFINED
-#undef yyget_lineno
-#endif
-#ifndef xlu__disk_yyset_lineno_ALREADY_DEFINED
-#undef yyset_lineno
-#endif
-#ifndef xlu__disk_yyget_column_ALREADY_DEFINED
-#undef yyget_column
-#endif
-#ifndef xlu__disk_yyset_column_ALREADY_DEFINED
-#undef yyset_column
-#endif
-#ifndef xlu__disk_yywrap_ALREADY_DEFINED
-#undef yywrap
-#endif
-#ifndef xlu__disk_yyget_lval_ALREADY_DEFINED
-#undef yyget_lval
-#endif
-#ifndef xlu__disk_yyset_lval_ALREADY_DEFINED
-#undef yyset_lval
-#endif
-#ifndef xlu__disk_yyget_lloc_ALREADY_DEFINED
-#undef yyget_lloc
-#endif
-#ifndef xlu__disk_yyset_lloc_ALREADY_DEFINED
-#undef yyset_lloc
-#endif
-#ifndef xlu__disk_yyalloc_ALREADY_DEFINED
-#undef yyalloc
-#endif
-#ifndef xlu__disk_yyrealloc_ALREADY_DEFINED
-#undef yyrealloc
-#endif
-#ifndef xlu__disk_yyfree_ALREADY_DEFINED
-#undef yyfree
-#endif
-#ifndef xlu__disk_yytext_ALREADY_DEFINED
-#undef yytext
-#endif
-#ifndef xlu__disk_yyleng_ALREADY_DEFINED
-#undef yyleng
-#endif
-#ifndef xlu__disk_yyin_ALREADY_DEFINED
-#undef yyin
-#endif
-#ifndef xlu__disk_yyout_ALREADY_DEFINED
-#undef yyout
-#endif
-#ifndef xlu__disk_yy_flex_debug_ALREADY_DEFINED
-#undef yy_flex_debug
-#endif
-#ifndef xlu__disk_yylineno_ALREADY_DEFINED
-#undef yylineno
-#endif
-#ifndef xlu__disk_yytables_fload_ALREADY_DEFINED
-#undef yytables_fload
-#endif
-#ifndef xlu__disk_yytables_destroy_ALREADY_DEFINED
-#undef yytables_destroy
-#endif
-#ifndef xlu__disk_yyTABLES_NAME_ALREADY_DEFINED
-#undef yyTABLES_NAME
-#endif
-
-#line 291 "libxlu_disk_l.l"
-
-#line 699 "libxlu_disk_l.h"
-#undef xlu__disk_yyIN_HEADER
-#endif /* xlu__disk_yyHEADER_H */
+++ /dev/null
-/* -*- fundamental -*- */
-/*
- * libxlu_disk_l.l - parser for disk specification strings
- *
- * Copyright (C) 2011 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-
-/*
- * Parsing the old xm/xend/xl-4.1 disk specs is a tricky problem,
- * because the target string might in theory contain "," which is the
- * delimiter we use for stripping off things on the RHS, and ":",
- * which is the delimiter we use for stripping off things on the LHS.
- *
- * In this parser we do not support such target strings in the old
- * syntax; if the target string has to contain "," or ":" the new
- * syntax's "target=" should be used.
- */
-
-%top{
-#define _GNU_SOURCE
-}
-
-%{
-#include "libxlu_disk_i.h"
-
-#define YY_NO_INPUT
-
-/* The code generated by flex is missing braces in single line expressions and
- * is not properly indented, which triggers the clang misleading-indentation
- * check that has been made part of -Wall since clang 10. In order to safely
- * disable it on clang versions that don't have the diagnostic implemented
- * also disable the unknown option and pragma warning. */
-#ifdef __clang__
-# pragma clang diagnostic ignored "-Wunknown-pragmas"
-# pragma clang diagnostic ignored "-Wunknown-warning-option"
-# pragma clang diagnostic ignored "-Wmisleading-indentation"
-#endif
-
-/* Some versions of flex have a bug (Fedora bugzilla 612465) which causes
- * it to fail to declare these functions, which it defines. So declare
- * them ourselves. Hopefully we won't have to simultaneously support
- * a flex version which declares these differently somehow. */
-int xlu__disk_yyget_column(yyscan_t yyscanner);
-void xlu__disk_yyset_column(int column_no, yyscan_t yyscanner);
-
-
-/*----- useful macros and functions used in actions -----
- * we use macros in the actual rules to keep the actions short
- * and particularly to avoid repeating boilerplate values such as
- * DPC->disk, yytext, etc. */
-
-/* Sets an enum, checking it hasn't already been set to a different value */
-#define DSET(dpc,member,enumname,str,valname) do{ \
- if (dpc->disk->member != LIBXL_DISK_##enumname##_UNKNOWN && \
- dpc->disk->member != LIBXL_DISK_##enumname##_##valname) { \
- xlu__disk_err(dpc, str, TOSTRING(member) " respecified"); \
- } else { \
- dpc->disk->member = LIBXL_DISK_##enumname##_##valname; \
- } \
- }while(0)
-
-/* For actions whose patterns contain '=', finds the start of the value */
-#define FROMEQUALS (strchr(yytext,'=')+1)
-
-/* Chops the delimiter off, modifying yytext and yyleng. */
-#define STRIP(delim) do{ \
- if (yyleng>0 && yytext[yyleng-1]==(delim)) \
- yytext[--yyleng] = 0; \
- }while(0)
-
-/* Sets a string value, checking it hasn't been set already. */
-#define SAVESTRING(what,loc,val) do{ \
- savestring(DPC, what " respecified", &DPC->disk->loc, (val)); \
- }while(0)
-static void savestring(DiskParseContext *dpc, const char *what_respecified,
- char **update, const char *value) {
- if (*update) {
- if (**update) { xlu__disk_err(dpc,value,what_respecified); return; }
- free(*update); /* do not complain about overwriting empty strings */
- }
- *update = strdup(value);
-}
-
-#define DPC dpc /* our convention in lexer helper functions */
-
-/* Sets ->readwrite from the string. This ought to be an enum, perhaps. */
-static void setaccess(DiskParseContext *dpc, const char *str) {
- if (!strcmp(str, "r") || !strcmp(str, "ro")) {
- dpc->disk->readwrite = 0;
- } else if (!strcmp(str, "rw") || !strcmp(str, "w") || !strcmp(str,"")) {
- dpc->disk->readwrite = 1;
- } else {
- xlu__disk_err(dpc,str,"unknown value for access");
- }
-}
-
-/* Sets ->format from the string. IDL should provide something for this. */
-static void setformat(DiskParseContext *dpc, const char *str) {
- if (!strcmp(str,"")) DSET(dpc,format,FORMAT,str,RAW);
- else if (!strcmp(str,"raw")) DSET(dpc,format,FORMAT,str,RAW);
- else if (!strcmp(str,"qcow")) DSET(dpc,format,FORMAT,str,QCOW);
- else if (!strcmp(str,"qcow2")) DSET(dpc,format,FORMAT,str,QCOW2);
- else if (!strcmp(str,"vhd")) DSET(dpc,format,FORMAT,str,VHD);
- else if (!strcmp(str,"empty")) DSET(dpc,format,FORMAT,str,EMPTY);
- else if (!strcmp(str,"qed")) DSET(dpc,format,FORMAT,str,QED);
- else xlu__disk_err(dpc,str,"unknown value for format");
-}
-
-/* Sets ->backend from the string. IDL should provide something for this. */
-static void setbackendtype(DiskParseContext *dpc, const char *str) {
- if ( !strcmp(str,"phy")) DSET(dpc,backend,BACKEND,str,PHY);
- else if (!strcmp(str,"tap")) DSET(dpc,backend,BACKEND,str,TAP);
- else if (!strcmp(str,"qdisk")) DSET(dpc,backend,BACKEND,str,QDISK);
- else xlu__disk_err(dpc,str,"unknown value for backendtype");
-}
-
-/* Sets ->colo-port from the string. COLO need this. */
-static void setcoloport(DiskParseContext *dpc, const char *str) {
- int port = atoi(str);
- if (port) {
- dpc->disk->colo_port = port;
- } else {
- xlu__disk_err(dpc,str,"unknown value for colo_port");
- }
-}
-
-#define DEPRECATE(usewhatinstead) /* not currently reported */
-
-/* Handles a vdev positional parameter which includes a devtype. */
-static int vdev_and_devtype(DiskParseContext *dpc, char *str) {
- /* returns 1 if it was <vdev>:<devtype>, 0 (doing nothing) otherwise */
- char *colon = strrchr(str, ':');
- if (!colon)
- return 0;
-
- DEPRECATE("use `devtype=...'");
- *colon++ = 0;
- SAVESTRING("vdev", vdev, str);
-
- if (!strcmp(colon,"cdrom")) {
- DPC->disk->is_cdrom = 1;
- } else if (!strcmp(colon,"disk")) {
- DPC->disk->is_cdrom = 0;
- } else {
- xlu__disk_err(DPC,colon,"unknown deprecated type");
- }
- return 1;
-}
-
-#undef DPC /* needs to be defined differently the actual lexer */
-#define DPC ((DiskParseContext*)yyextra)
-
-%}
-
-%option warn
-%option nodefault
-%option batch
-%option 8bit
-%option noyywrap
-%option reentrant
-%option prefix="xlu__disk_yy"
-%option nounput
-
-%x LEXERR
-
-%%
-
- /*----- the scanner rules which do the parsing -----*/
-
-[ \t\n]+/([^ \t\n].*)? { /* ignore whitespace before parameters */ }
-
- /* ordinary parameters setting enums or strings */
-
-format=[^,]*,? { STRIP(','); setformat(DPC, FROMEQUALS); }
-
-cdrom,? { DPC->disk->is_cdrom = 1; }
-devtype=cdrom,? { DPC->disk->is_cdrom = 1; }
-devtype=disk,? { DPC->disk->is_cdrom = 0; }
-devtype=[^,]*,? { xlu__disk_err(DPC,yytext,"unknown value for type"); }
-
-access=[^,]*,? { STRIP(','); setaccess(DPC, FROMEQUALS); }
-backend=[^,]*,? { STRIP(','); SAVESTRING("backend", backend_domname, FROMEQUALS); }
-backendtype=[^,]*,? { STRIP(','); setbackendtype(DPC,FROMEQUALS); }
-
-vdev=[^,]*,? { STRIP(','); SAVESTRING("vdev", vdev, FROMEQUALS); }
-script=[^,]*,? { STRIP(','); SAVESTRING("script", script, FROMEQUALS); }
-direct-io-safe,? { DPC->disk->direct_io_safe = 1; }
-discard,? { libxl_defbool_set(&DPC->disk->discard_enable, true); }
-no-discard,? { libxl_defbool_set(&DPC->disk->discard_enable, false); }
- /* Note that the COLO configuration settings should be considered unstable.
- * They may change incompatibly in future versions of Xen. */
-colo,? { libxl_defbool_set(&DPC->disk->colo_enable, true); }
-no-colo,? { libxl_defbool_set(&DPC->disk->colo_enable, false); }
-colo-host=[^,]*,? { STRIP(','); SAVESTRING("colo-host", colo_host, FROMEQUALS); }
-colo-port=[^,]*,? { STRIP(','); setcoloport(DPC, FROMEQUALS); }
-colo-export=[^,]*,? { STRIP(','); SAVESTRING("colo-export", colo_export, FROMEQUALS); }
-active-disk=[^,]*,? { STRIP(','); SAVESTRING("active-disk", active_disk, FROMEQUALS); }
-hidden-disk=[^,]*,? { STRIP(','); SAVESTRING("hidden-disk", hidden_disk, FROMEQUALS); }
-
- /* the target magic parameter, eats the rest of the string */
-
-target=.* { STRIP(','); SAVESTRING("target", pdev_path, FROMEQUALS); }
-
- /* unknown parameters */
-
-[a-z][-a-z0-9]*=[^,],? { xlu__disk_err(DPC,yytext,"unknown parameter"); }
-
- /* deprecated prefixes */
-
- /* the "/.*" in these patterns ensures that they count as if they
- * matched the whole string, so these patterns take precedence */
-
-(raw|qcow2?|vhd):/.* {
- STRIP(':');
- DPC->had_depr_prefix=1; DEPRECATE("use `[format=]...,'");
- setformat(DPC, yytext);
- }
-
-(iscsi|e?nbd|drbd):/.* {
- char *newscript;
- STRIP(':');
- DPC->had_depr_prefix=1; DEPRECATE("use `script=...'");
- if (asprintf(&newscript, "block-%s", yytext) < 0) {
- xlu__disk_err(DPC,yytext,"unable to format script");
- return 0;
- }
- savestring(DPC, "script respecified",
- &DPC->disk->script, newscript);
- free(newscript);
- }
-
-tapdisk:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
-tap2?:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
-aio:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
-ioemu:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
-file:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
-phy:/.* { DPC->had_depr_prefix=1; DEPRECATE(0); }
-
-[a-z][a-z0-9]*:/([^a-z0-9].*)? {
- xlu__disk_err(DPC,yytext,"unknown deprecated disk prefix");
- return 0;
- }
-
- /* positional parameters */
-
-[^=,]*,|[^=,]+,? {
- STRIP(',');
-
- if (DPC->err) {
- /* previous errors may just lead to subsequent ones */
- } else if (!DPC->disk->pdev_path) {
- SAVESTRING("target", pdev_path, yytext);
- } else if (!DPC->had_depr_prefix &&
- DPC->disk->format == LIBXL_DISK_FORMAT_UNKNOWN) {
- if (!*DPC->disk->pdev_path && vdev_and_devtype(DPC,yytext)) {
- DPC->disk->format = LIBXL_DISK_FORMAT_EMPTY;
- } else {
- setformat(DPC,yytext);
- }
- } else if (!DPC->disk->vdev) {
- if (!vdev_and_devtype(DPC,yytext))
- SAVESTRING("vdev", vdev, yytext);
- } else if (!DPC->access_set) {
- DPC->access_set = 1;
- setaccess(DPC,yytext);
- } else {
- xlu__disk_err(DPC,yytext,"too many positional parameters");
- return 0; /* don't print any more errors */
- }
-}
-
-. {
- BEGIN(LEXERR);
- yymore();
-}
-<LEXERR>.* {
- xlu__disk_err(DPC,yytext,"bad disk syntax"); return 0;
-}
+++ /dev/null
-/*
- * Copyright (C) 2010 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-
-#ifndef LIBXLU_INTERNAL_H
-#define LIBXLU_INTERNAL_H
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <string.h>
-#include <assert.h>
-#include <regex.h>
-
-#include "libxlutil.h"
-
-struct XLU_ConfigList {
- int avalues; /* available slots */
- int nvalues; /* actual occupied slots */
- XLU_ConfigValue **values;
-};
-
-typedef struct YYLTYPE
-{
- int first_line;
- int first_column;
- int last_line;
- int last_column;
-} YYLTYPE;
-#define YYLTYPE_IS_DECLARED
-
-struct XLU_ConfigValue {
- enum XLU_ConfigValueType type;
- union {
- char *string;
- XLU_ConfigList list;
- } u;
- YYLTYPE loc;
-};
-
-typedef struct XLU_ConfigSetting { /* transparent */
- struct XLU_ConfigSetting *next;
- char *name;
- XLU_ConfigValue *value;
- enum XLU_Operation op;
- int lineno;
-} XLU_ConfigSetting;
-
-struct XLU_Config {
- XLU_ConfigSetting *settings;
- FILE *report;
- char *config_source;
-};
-
-typedef struct {
- XLU_Config *cfg;
- int err, lexerrlineno, likely_python;
- void *scanner;
-} CfgParseContext;
-
-
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-
-#endif /*LIBXLU_INTERNAL_H*/
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-#define _GNU_SOURCE
-
-#include "libxlu_internal.h"
-#include "libxlu_disk_l.h"
-#include "libxlu_disk_i.h"
-#include "libxlu_cfg_i.h"
-
-
-#define XLU__PCI_ERR(_c, _x, _a...) \
- if((_c) && (_c)->report) fprintf((_c)->report, _x, ##_a)
-
-static int hex_convert(const char *str, unsigned int *val, unsigned int mask)
-{
- unsigned long ret;
- char *end;
-
- ret = strtoul(str, &end, 16);
- if ( end == str || *end != '\0' )
- return -1;
- if ( ret & ~mask )
- return -1;
- *val = (unsigned int)ret & mask;
- return 0;
-}
-
-static int pcidev_struct_fill(libxl_device_pci *pcidev, unsigned int domain,
- unsigned int bus, unsigned int dev,
- unsigned int func, unsigned int vdevfn)
-{
- pcidev->domain = domain;
- pcidev->bus = bus;
- pcidev->dev = dev;
- pcidev->func = func;
- pcidev->vdevfn = vdevfn;
- return 0;
-}
-
-#define STATE_DOMAIN 0
-#define STATE_BUS 1
-#define STATE_DEV 2
-#define STATE_FUNC 3
-#define STATE_VSLOT 4
-#define STATE_OPTIONS_K 6
-#define STATE_OPTIONS_V 7
-#define STATE_TERMINAL 8
-#define STATE_TYPE 9
-#define STATE_RDM_STRATEGY 10
-#define STATE_RESERVE_POLICY 11
-#define INVALID 0xffffffff
-int xlu_pci_parse_bdf(XLU_Config *cfg, libxl_device_pci *pcidev, const char *str)
-{
- unsigned state = STATE_DOMAIN;
- unsigned dom = INVALID, bus = INVALID, dev = INVALID, func = INVALID, vslot = 0;
- char *buf2, *tok, *ptr, *end, *optkey = NULL;
-
- if ( NULL == (buf2 = ptr = strdup(str)) )
- return ERROR_NOMEM;
-
- for(tok = ptr, end = ptr + strlen(ptr) + 1; ptr < end; ptr++) {
- switch(state) {
- case STATE_DOMAIN:
- if ( *ptr == ':' ) {
- state = STATE_BUS;
- *ptr = '\0';
- if ( hex_convert(tok, &dom, 0xffff) )
- goto parse_error;
- tok = ptr + 1;
- }
- break;
- case STATE_BUS:
- if ( *ptr == ':' ) {
- state = STATE_DEV;
- *ptr = '\0';
- if ( hex_convert(tok, &bus, 0xff) )
- goto parse_error;
- tok = ptr + 1;
- }else if ( *ptr == '.' ) {
- state = STATE_FUNC;
- *ptr = '\0';
- if ( dom & ~0xff )
- goto parse_error;
- bus = dom;
- dom = 0;
- if ( hex_convert(tok, &dev, 0xff) )
- goto parse_error;
- tok = ptr + 1;
- }
- break;
- case STATE_DEV:
- if ( *ptr == '.' ) {
- state = STATE_FUNC;
- *ptr = '\0';
- if ( hex_convert(tok, &dev, 0xff) )
- goto parse_error;
- tok = ptr + 1;
- }
- break;
- case STATE_FUNC:
- if ( *ptr == '\0' || *ptr == '@' || *ptr == ',' ) {
- switch( *ptr ) {
- case '\0':
- state = STATE_TERMINAL;
- break;
- case '@':
- state = STATE_VSLOT;
- break;
- case ',':
- state = STATE_OPTIONS_K;
- break;
- }
- *ptr = '\0';
- if ( !strcmp(tok, "*") ) {
- pcidev->vfunc_mask = LIBXL_PCI_FUNC_ALL;
- }else{
- if ( hex_convert(tok, &func, 0x7) )
- goto parse_error;
- pcidev->vfunc_mask = (1 << 0);
- }
- tok = ptr + 1;
- }
- break;
- case STATE_VSLOT:
- if ( *ptr == '\0' || *ptr == ',' ) {
- state = ( *ptr == ',' ) ? STATE_OPTIONS_K : STATE_TERMINAL;
- *ptr = '\0';
- if ( hex_convert(tok, &vslot, 0xff) )
- goto parse_error;
- tok = ptr + 1;
- }
- break;
- case STATE_OPTIONS_K:
- if ( *ptr == '=' ) {
- state = STATE_OPTIONS_V;
- *ptr = '\0';
- optkey = tok;
- tok = ptr + 1;
- }
- break;
- case STATE_OPTIONS_V:
- if ( *ptr == ',' || *ptr == '\0' ) {
- state = (*ptr == ',') ? STATE_OPTIONS_K : STATE_TERMINAL;
- *ptr = '\0';
- if ( !strcmp(optkey, "msitranslate") ) {
- pcidev->msitranslate = atoi(tok);
- }else if ( !strcmp(optkey, "power_mgmt") ) {
- pcidev->power_mgmt = atoi(tok);
- }else if ( !strcmp(optkey, "permissive") ) {
- pcidev->permissive = atoi(tok);
- }else if ( !strcmp(optkey, "seize") ) {
- pcidev->seize = atoi(tok);
- } else if (!strcmp(optkey, "rdm_policy")) {
- if (!strcmp(tok, "strict")) {
- pcidev->rdm_policy = LIBXL_RDM_RESERVE_POLICY_STRICT;
- } else if (!strcmp(tok, "relaxed")) {
- pcidev->rdm_policy = LIBXL_RDM_RESERVE_POLICY_RELAXED;
- } else {
- XLU__PCI_ERR(cfg, "%s is not an valid PCI RDM property"
- " policy: 'strict' or 'relaxed'.",
- tok);
- goto parse_error;
- }
- } else {
- XLU__PCI_ERR(cfg, "Unknown PCI BDF option: %s", optkey);
- }
- tok = ptr + 1;
- }
- default:
- break;
- }
- }
-
- if ( tok != ptr || state != STATE_TERMINAL )
- goto parse_error;
-
- assert(dom != INVALID && bus != INVALID && dev != INVALID && func != INVALID);
-
- /* Just a pretty way to fill in the values */
- pcidev_struct_fill(pcidev, dom, bus, dev, func, vslot << 3);
-
- free(buf2);
-
- return 0;
-
-parse_error:
- free(buf2);
- return ERROR_INVAL;
-}
-
-int xlu_rdm_parse(XLU_Config *cfg, libxl_rdm_reserve *rdm, const char *str)
-{
- unsigned state = STATE_TYPE;
- char *buf2, *tok, *ptr, *end;
-
- if (NULL == (buf2 = ptr = strdup(str)))
- return ERROR_NOMEM;
-
- for (tok = ptr, end = ptr + strlen(ptr) + 1; ptr < end; ptr++) {
- switch(state) {
- case STATE_TYPE:
- if (*ptr == '=') {
- *ptr = '\0';
- if (!strcmp(tok, "strategy")) {
- state = STATE_RDM_STRATEGY;
- } else if (!strcmp(tok, "policy")) {
- state = STATE_RESERVE_POLICY;
- } else {
- XLU__PCI_ERR(cfg, "Unknown RDM state option: %s", tok);
- goto parse_error;
- }
- tok = ptr + 1;
- }
- break;
- case STATE_RDM_STRATEGY:
- if (*ptr == '\0' || *ptr == ',') {
- state = *ptr == ',' ? STATE_TYPE : STATE_TERMINAL;
- *ptr = '\0';
- if (!strcmp(tok, "host")) {
- rdm->strategy = LIBXL_RDM_RESERVE_STRATEGY_HOST;
- } else {
- XLU__PCI_ERR(cfg, "Unknown RDM strategy option: %s", tok);
- goto parse_error;
- }
- tok = ptr + 1;
- }
- break;
- case STATE_RESERVE_POLICY:
- if (*ptr == ',' || *ptr == '\0') {
- state = *ptr == ',' ? STATE_TYPE : STATE_TERMINAL;
- *ptr = '\0';
- if (!strcmp(tok, "strict")) {
- rdm->policy = LIBXL_RDM_RESERVE_POLICY_STRICT;
- } else if (!strcmp(tok, "relaxed")) {
- rdm->policy = LIBXL_RDM_RESERVE_POLICY_RELAXED;
- } else {
- XLU__PCI_ERR(cfg, "Unknown RDM property policy value: %s",
- tok);
- goto parse_error;
- }
- tok = ptr + 1;
- }
- default:
- break;
- }
- }
-
- if (tok != ptr || state != STATE_TERMINAL)
- goto parse_error;
-
- free(buf2);
-
- return 0;
-
-parse_error:
- free(buf2);
- return ERROR_INVAL;
-}
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-#define _GNU_SOURCE
-
-#include "libxlu_internal.h"
-
-static const char *vif_bytes_per_sec_re = "^[0-9]+[GMK]?[Bb]/s$";
-static const char *vif_internal_usec_re = "^[0-9]+[mu]?s?$";
-
-static void xlu__vif_err(XLU_Config *cfg, const char *msg, const char *rate) {
- fprintf(cfg->report,
- "%s: config parsing error in vif: %s in `%s'\n",
- cfg->config_source, msg, rate);
-}
-
-static int vif_parse_rate_bytes_per_sec(XLU_Config *cfg, const char *bytes,
- uint64_t *bytes_per_sec)
-{
- regex_t rec;
- uint64_t tmp = 0;
- const char *p;
- int rc = 0;
-
- regcomp(&rec, vif_bytes_per_sec_re, REG_EXTENDED|REG_NOSUB);
- if (regexec(&rec, bytes, 0, NULL, 0)) {
- xlu__vif_err(cfg, "invalid rate", bytes);
- rc = EINVAL;
- goto out;
- }
-
- p = bytes;
- tmp = strtoull(p, (char**)&p, 0);
- if (tmp == 0 || tmp > UINT32_MAX || errno == ERANGE) {
- xlu__vif_err(cfg, "rate overflow", bytes);
- rc = EOVERFLOW;
- goto out;
- }
-
- if (*p == 'G')
- tmp *= 1000 * 1000 * 1000;
- else if (*p == 'M')
- tmp *= 1000 * 1000;
- else if (*p == 'K')
- tmp *= 1000;
- if (*p == 'b' || *(p+1) == 'b')
- tmp /= 8;
-
- *bytes_per_sec = tmp;
-
-out:
- regfree(&rec);
- return rc;
-}
-
-static int vif_parse_rate_interval_usecs(XLU_Config *cfg, const char *interval,
- uint32_t *interval_usecs)
-{
- regex_t rec;
- uint64_t tmp = 0;
- const char *p;
- int rc = 0;
-
- regcomp(&rec, vif_internal_usec_re, REG_EXTENDED|REG_NOSUB);
- if (regexec(&rec, interval, 0, NULL, 0)) {
- xlu__vif_err(cfg, "invalid replenishment interval", interval);
- rc = EINVAL;
- goto out;
- }
-
- p = interval;
- tmp = strtoull(p, (char**)&p, 0);
- if (tmp == 0 || tmp > UINT32_MAX || errno == ERANGE) {
- xlu__vif_err(cfg, "replenishment interval overflow", interval);
- rc = EOVERFLOW;
- goto out;
- }
-
- if (*p == 's' || *p == '\0')
- tmp *= 1000 * 1000;
- else if (*p == 'm')
- tmp *= 1000;
-
- if (tmp > UINT32_MAX) {
- xlu__vif_err(cfg, "replenishment interval overflow", interval);
- rc = EOVERFLOW;
- goto out;
- }
-
- *interval_usecs = (uint32_t) tmp;
-
-out:
- regfree(&rec);
- return rc;
-}
-
-int xlu_vif_parse_rate(XLU_Config *cfg, const char *rate, libxl_device_nic *nic)
-{
- uint64_t bytes_per_sec = 0;
- uint64_t bytes_per_interval = 0;
- uint32_t interval_usecs = 50000UL; /* Default to 50ms */
- char *p, *tmprate;
- int rc = 0;
-
- tmprate = strdup(rate);
- if (tmprate == NULL) {
- rc = ENOMEM;
- goto out;
- }
-
- p = strchr(tmprate, '@');
- if (p != NULL)
- *p++ = 0;
-
- if (!strcmp(tmprate,"")) {
- xlu__vif_err(cfg, "no rate specified", rate);
- rc = EINVAL;
- goto out;
- }
-
- rc = vif_parse_rate_bytes_per_sec(cfg, tmprate, &bytes_per_sec);
- if (rc) goto out;
-
- if (p != NULL) {
- rc = vif_parse_rate_interval_usecs(cfg, p, &interval_usecs);
- if (rc) goto out;
- }
-
- if (interval_usecs != 0 && (bytes_per_sec > (UINT64_MAX / interval_usecs))) {
- xlu__vif_err(cfg, "rate overflow", rate);
- rc = EOVERFLOW;
- goto out;
- }
-
- bytes_per_interval =
- (((uint64_t) bytes_per_sec * (uint64_t) interval_usecs) / 1000000UL);
-
- nic->rate_interval_usecs = interval_usecs;
- nic->rate_bytes_per_interval = bytes_per_interval;
-
-out:
- free(tmprate);
- return rc;
-}
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
+++ /dev/null
-/*
- * Copyright (C) 2010 Citrix Ltd.
- * Author Ian Jackson <ian.jackson@eu.citrix.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; version 2.1 only. with the special
- * exception on linking described in file LICENSE.
- *
- * 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 Lesser General Public License for more details.
- */
-
-#ifndef LIBXLUTIL_H
-#define LIBXLUTIL_H
-
-#include <stdio.h>
-
-#include "libxl.h"
-
-enum XLU_ConfigValueType {
- XLU_STRING,
- XLU_LIST,
-};
-
-enum XLU_Operation {
- XLU_OP_ASSIGNMENT = 0,
- XLU_OP_ADDITION,
-};
-
-/* Unless otherwise stated, all functions return an errno value. */
-typedef struct XLU_Config XLU_Config;
-typedef struct XLU_ConfigList XLU_ConfigList;
-typedef struct XLU_ConfigValue XLU_ConfigValue;
-
-XLU_Config *xlu_cfg_init(FILE *report, const char *report_filename);
- /* 0 means we got ENOMEM. */
- /* report_filename is copied; report is saved and must remain valid
- * until the Config is destroyed. */
-
-int xlu_cfg_readfile(XLU_Config*, const char *real_filename);
-int xlu_cfg_readdata(XLU_Config*, const char *data, int length);
- /* If these fail, then it is undefined behaviour to call xlu_cfg_get_...
- * functions. You have to just xlu_cfg_destroy. */
-
-void xlu_cfg_destroy(XLU_Config*);
-
-
-/* All of the following print warnings to "report" if there is a problem.
- * Return values are:
- * 0 OK
- * ESRCH not defined
- * EINVAL value found but wrong format for request (prints warning unless dont_warn=true)
- * ERANGE value out of range (from strtol)
- */
-
-int xlu_cfg_get_string(const XLU_Config*, const char *n, const char **value_r,
- int dont_warn);
-/* free/strdup version */
-int xlu_cfg_replace_string(const XLU_Config *cfg, const char *n,
- char **value_r, int dont_warn);
-int xlu_cfg_get_long(const XLU_Config*, const char *n, long *value_r,
- int dont_warn);
-int xlu_cfg_get_bounded_long(const XLU_Config*, const char *n, long min,
- long max, long *value_r, int dont_warn);
-int xlu_cfg_get_defbool(const XLU_Config*, const char *n, libxl_defbool *b,
- int dont_warn);
-
-int xlu_cfg_get_list(const XLU_Config*, const char *n,
- XLU_ConfigList **list_r /* may be 0 */,
- int *entries_r /* may be 0 */,
- int dont_warn);
- /* there is no need to free *list_r; lifetime is that of the XLU_Config */
-int xlu_cfg_get_list_as_string_list(const XLU_Config *cfg, const char *n,
- libxl_string_list *sl, int dont_warn);
-const char *xlu_cfg_get_listitem(const XLU_ConfigList*, int entry);
- /* xlu_cfg_get_listitem cannot fail, except that if entry is
- * out of range it returns 0 (not setting errno) */
-
-enum XLU_ConfigValueType xlu_cfg_value_type(const XLU_ConfigValue *value);
-int xlu_cfg_value_get_string(const XLU_Config *cfg, XLU_ConfigValue *value,
- char **value_r, int dont_warn);
-int xlu_cfg_value_get_list(const XLU_Config *cfg, XLU_ConfigValue *value,
- XLU_ConfigList **value_r, int dont_warn);
-XLU_ConfigValue *xlu_cfg_get_listitem2(const XLU_ConfigList *list,
- int entry);
-
-/*
- * Disk specification parsing.
- */
-
-int xlu_disk_parse(XLU_Config *cfg, int nspecs, const char *const *specs,
- libxl_device_disk *disk);
- /* disk must have been initialised.
- *
- * On error, returns errno value. Bad strings cause EINVAL and
- * print a message to cfg's report (that's all cfg is used for).
- *
- * Normally one would pass nspecs==1 and only specs[0]. But it is
- * permitted to pass more strings in which case each is parsed as a
- * string containing a collection of parameters (but they all refer
- * to of the configuration for a single disk).
- *
- * nspecs==0 is permitted but since it does not specify some mandatory
- * properties, it produces a run-time configuration error if the
- * resulting disk struct is used with libxl.
- */
-
-/*
- * PCI specification parsing
- */
-int xlu_pci_parse_bdf(XLU_Config *cfg, libxl_device_pci *pcidev, const char *str);
-
-/*
- * RDM parsing
- */
-int xlu_rdm_parse(XLU_Config *cfg, libxl_rdm_reserve *rdm, const char *str);
-
-/*
- * Vif rate parsing.
- */
-
-int xlu_vif_parse_rate(XLU_Config *cfg, const char *rate,
- libxl_device_nic *nic);
-
-#endif /* LIBXLUTIL_H */
-
-/*
- * Local variables:
- * mode: C
- * c-basic-offset: 4
- * indent-tabs-mode: nil
- * End:
- */
projects / people / jgross / xen.git / commitdiff