]> git.ipfire.org Git - thirdparty/unbound.git/commitdiff
root-hints can be read from file.
authorWouter Wijngaards <wouter@nlnetlabs.nl>
Fri, 19 Oct 2007 14:02:53 +0000 (14:02 +0000)
committerWouter Wijngaards <wouter@nlnetlabs.nl>
Fri, 19 Oct 2007 14:02:53 +0000 (14:02 +0000)
git-svn-id: file:///svn/unbound/trunk@708 be551aaa-1e26-0410-a405-d3ace91eadb9

doc/Changelog
doc/example.conf
doc/unbound.conf.5
iterator/iter_hints.c
util/config_file.c
util/config_file.h
util/configlexer.c
util/configlexer.lex
util/configparser.c
util/configparser.h
util/configparser.y

index e9e8ac17eb5a3dda653c04e90ef5bd7ffd64977e..4e6a40a07202c4a502c4223fb8268055ba2fc15e 100644 (file)
@@ -12,6 +12,7 @@
          ldns-src make is done during unbound make, and so inherits the
          make arguments from the unbound make invocation.
        - nicer error when libevent problem causes instant exit on signal.
+       - read root hints from a root hint file (like BIND does).
          
 18 October 2007: Wouter
        - addresses are logged with errors.
index 223d2b7486b418184c7dbc64bd2ae945f24cc6b0..08072b329916d06cf0a81938c603d9c355689bfd 100644 (file)
@@ -130,6 +130,10 @@ server:
        # the pid file.
        # pidfile: "unbound.pid"
        
+       # file to read root hints from.
+       # get one from ftp://FTP.INTERNIC.NET/domain/named.cache
+       # root-hints: ""
+       
        # enable to not answer id.server and hostname.bind queries.
        # hide-identity: no
        
index f0e1531b9794a4164043e27f83e71f9e72e61421..fde629d5bdea91264b64cbbbc1d683b0c6feddca 100644 (file)
@@ -173,6 +173,11 @@ The default is to log to syslog.
 The process id is written to the file. Default is "unbound.pid". So,
 kill -HUP `cat /etc/unbound/unbound.pid` will trigger a reload,
 kill -QUIT `cat /etc/unbound/unbound.pid` will gracefully terminate.
+.It \fBroot-hints:\fR <filename>
+Read the root hints from this file. Default is nothing, using builtin hints
+for the IN class. The file has the format of zone files, with root 
+nameserver names and addresses only. The default may become outdated,
+when servers change, therefore it is good practice to use a root-hints file.
 .It \fBhide-identity:\fR <yes or no>
 If enabled id.server and hostname.bind queries are refused.
 .It \fBidentity:\fR <string>
index dd9c9e121a95fbdd89aa86225abe433245642ce5..1979ef3bf70e07375b7044ac117725447eea73ff 100644 (file)
@@ -290,6 +290,126 @@ read_stubs(struct iter_hints* hints, struct config_file* cfg)
        return 1;
 }
 
+/** read root hints from file */
+static int 
+read_root_hints(struct iter_hints* hints, char* fname)
+{
+       int lineno = 0;
+       uint32_t default_ttl = 0;
+       ldns_rdf* origin = NULL;
+       ldns_rdf* prev_rr = NULL;
+       struct delegpt* dp;
+       ldns_rr* rr = NULL;
+       ldns_status status;
+       uint16_t c = LDNS_RR_CLASS_IN;
+       FILE* f = fopen(fname, "r");
+       if(!f) {
+               log_err("could not read root hints %s: %s",
+                       fname, strerror(errno));
+               return 0;
+       }
+       dp = delegpt_create(hints->region);
+       if(!dp) {
+               log_err("out of memory reading root hints");
+               fclose(f);
+               return 0;
+       }
+       verbose(VERB_DETAIL, "Reading root hints from %s", fname);
+       while(!feof(f)) {
+               status = ldns_rr_new_frm_fp_l(&rr, f, 
+                       &default_ttl, &origin, &prev_rr, &lineno);
+               if(status == LDNS_STATUS_SYNTAX_EMPTY ||
+                       status == LDNS_STATUS_SYNTAX_TTL ||
+                       status == LDNS_STATUS_SYNTAX_ORIGIN)
+                       continue;
+               if(status != LDNS_STATUS_OK) {
+                       log_err("reading root hints %s %d: %s", fname,
+                               lineno, ldns_get_errorstr_by_id(status));
+                       fclose(f);
+                       return 0;
+               }
+               if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_NS) {
+                       if(!delegpt_add_ns(dp, hints->region,
+                               ldns_rdf_data(ldns_rr_rdf(rr, 0)))) {
+                               log_err("out of memory reading root hints");
+                               fclose(f);
+                               return 0;
+                       }
+                       c = ldns_rr_get_class(rr);
+                       if(!dp->name) {
+                               if(!delegpt_set_name(dp, hints->region, 
+                                       ldns_rdf_data(ldns_rr_owner(rr)))){
+                                       log_err("out of memory.");
+                                       fclose(f);
+                                       return 0;
+                               }
+                       }
+               } else if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_A) {
+                       struct sockaddr_in sa;
+                       socklen_t len = (socklen_t)sizeof(sa);
+                       memset(&sa, 0, len);
+                       sa.sin_family = AF_INET;
+                       sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT);
+                       memmove(&sa.sin_addr, 
+                               ldns_rdf_data(ldns_rr_rdf(rr, 0)), INET_SIZE);
+                       if(!delegpt_add_target(dp, hints->region,
+                                       ldns_rdf_data(ldns_rr_owner(rr)),
+                                       ldns_rdf_size(ldns_rr_owner(rr)),
+                                       (struct sockaddr_storage*)&sa, len)) {
+                               log_err("out of memory reading root hints");
+                               fclose(f);
+                               return 0;
+                       }
+               } else if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_AAAA) {
+                       struct sockaddr_in6 sa;
+                       socklen_t len = (socklen_t)sizeof(sa);
+                       memset(&sa, 0, len);
+                       sa.sin6_family = AF_INET6;
+                       sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT);
+                       memmove(&sa.sin6_addr, 
+                               ldns_rdf_data(ldns_rr_rdf(rr, 0)), INET6_SIZE);
+                       if(!delegpt_add_target(dp, hints->region,
+                                       ldns_rdf_data(ldns_rr_owner(rr)),
+                                       ldns_rdf_size(ldns_rr_owner(rr)),
+                                       (struct sockaddr_storage*)&sa, len)) {
+                               log_err("out of memory reading root hints");
+                               fclose(f);
+                               return 0;
+                       }
+               } else {
+                       log_warn("root hints %s:%d skipping type %d",
+                               fname, lineno, ldns_rr_get_type(rr));
+               }
+
+               ldns_rr_free(rr);
+       }
+       fclose(f);
+       if(!dp->name) {
+               log_warn("root hints %s: no NS content", fname);
+               return 1;
+       }
+       if(!hints_insert(hints, c, dp)) {
+               return 0;
+       }
+       delegpt_log(VERB_DETAIL, dp);
+       return 1;
+}
+
+/** read root hints list */
+static int 
+read_root_hints_list(struct iter_hints* hints, struct config_file* cfg)
+{
+       struct config_strlist* p;
+       for(p = cfg->root_hints; p; p = p->next) {
+               log_assert(p->str);
+               if(p->str && p->str[0]) {
+                       if(!read_root_hints(hints, p->str))
+                               return 0;
+               }
+       }
+       return 1;
+}
+
 int 
 hints_apply_cfg(struct iter_hints* hints, struct config_file* cfg)
 {
@@ -297,7 +417,10 @@ hints_apply_cfg(struct iter_hints* hints, struct config_file* cfg)
        hints->tree = rbtree_create(stub_cmp);
        if(!hints->tree)
                return 0;
-       /* TODO: read root hints from file named in cfg */
+       
+       /* read root hints */
+       if(!read_root_hints_list(hints, cfg))
+               return 0;
 
        /* read stub hints */
        if(!read_stubs(hints, cfg))
index 4b263ea1fcfd0235ff40c082d2ea814f30cd1f0a..1ff08aad6df05acc95aefadc4f05bc50e18c256b 100644 (file)
@@ -103,6 +103,7 @@ config_create()
                goto error_exit;
        if(!cfg_strlist_insert(&cfg->donotqueryaddrs, strdup("::1")))
                goto error_exit;
+       cfg->root_hints = NULL;
        cfg->do_daemonize = 1;
        cfg->num_ifs = 0;
        cfg->ifs = NULL;
@@ -223,6 +224,7 @@ config_delete(struct config_file* cfg)
        config_delstubs(cfg->stubs);
        config_delstubs(cfg->forwards);
        config_delstrlist(cfg->donotqueryaddrs);
+       config_delstrlist(cfg->root_hints);
        free(cfg->identity);
        free(cfg->version);
        free(cfg->module_conf);
index e06b33269a9581658ef46380d97033cbc0bb4b7a..96890ab6a3c90625ac06bed4544b4217f0b062b6 100644 (file)
@@ -112,6 +112,8 @@ struct config_file {
        /** outgoing interface description strings (IP addresses) */
        char **out_ifs;
 
+       /** the root hints */
+       struct config_strlist* root_hints;
        /** the stub definitions, linked list */
        struct config_stub* stubs;
        /** the forward zone definitions, linked list */
index 1cd1d96dec474dba4e272eab0b21a928ed615cb9..62d9f94df13c04c358eea86a0e47af7356233a2e 100644 (file)
@@ -1,39 +1,93 @@
 #include "util/configyyrename.h"
-/* A lexical scanner generated by flex */
 
-/* Scanner skeleton version:
- * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
- * $FreeBSD: src/usr.bin/lex/flex.skl,v 1.8 2004/01/06 19:03:44 nectar Exp $
- */
+#line 3 "<stdout>"
 
-#if defined(__FreeBSD__)
-#include <sys/cdefs.h>
-#else
-#define __unused
-#endif
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
 
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 33
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
 
+/* begin standard C headers. */
 #include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
 
+/* end standard C headers. */
 
-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
-#ifdef c_plusplus
-#ifndef __cplusplus
-#define __cplusplus
-#endif
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if __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;
+#endif /* ! C99 */
 
-#ifdef __cplusplus
+/* 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
 
-#include <stdlib.h>
-#include <unistd.h>
+#endif /* ! FLEXINT_H */
 
-/* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
+#ifdef __cplusplus
 
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
 #if __STDC__
 
-#define YY_USE_PROTOS
 #define YY_USE_CONST
 
 #endif /* __STDC__ */
 #endif /* ! __cplusplus */
 
-#ifdef __TURBOC__
- #pragma warn -rch
- #pragma warn -use
-#include <io.h>
-#include <stdlib.h>
-#define YY_USE_CONST
-#define YY_USE_PROTOS
-#endif
-
 #ifdef YY_USE_CONST
 #define yyconst const
 #else
 #define yyconst
 #endif
 
-
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
-#else
-#define YY_PROTO(proto) ()
-#endif
-
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
-#define BEGIN yy_start = 1 + 2 *
+#define BEGIN (yy_start) = 1 + 2 *
 
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
-#define YY_START ((yy_start - 1) / 2)
+#define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START
 
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin )
+#define YY_NEW_FILE yyrestart(yyin  )
 
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
 #define YY_BUF_SIZE 16384
+#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
 
 extern int yyleng;
+
 extern FILE *yyin, *yyout;
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
-/* The funky do-while in the following #define is used to turn the definition
- * int a single C statement (which needs a semi-colon terminator).  This
- * avoids problems with code like:
- *
- *     if ( condition_holds )
- *             yyless( 5 );
- *     else
- *             do_something_else();
- *
- * Prior to using the do-while the compiler would get upset at the
- * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the yyless() call.
- */
-
-/* Return all but the first 'n' matched characters back to the input stream. */
-
+    #define YY_LESS_LINENO(n)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
        do \
                { \
                /* Undo effects of setting up yytext. */ \
-               *yy_cp = yy_hold_char; \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               *yy_cp = (yy_hold_char); \
                YY_RESTORE_YY_MORE_OFFSET \
-               yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+               (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, yytext_ptr )
+#define unput(c) yyunput( c, (yytext_ptr)  )
 
 /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want
  * flex-generated scanners to compile on their own).
  */
-typedef unsigned int yy_size_t;
 
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef unsigned int yy_size_t;
+#endif
 
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
        {
        FILE *yy_input_file;
@@ -185,12 +226,16 @@ struct yy_buffer_state
         */
        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
@@ -204,28 +249,38 @@ struct yy_buffer_state
         * just pointing yyin at a new input file.
         */
 #define YY_BUFFER_EOF_PENDING 2
+
        };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
-static YY_BUFFER_STATE yy_current_buffer = 0;
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
  */
-#define YY_CURRENT_BUFFER yy_current_buffer
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
 
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 
 /* yy_hold_char holds the character lost when yytext is formed. */
 static char yy_hold_char;
-
 static int yy_n_chars;         /* number of characters read into yy_ch_buf */
-
-
 int yyleng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;                /* whether we need to initialize */
+static int yy_init = 0;                /* whether we need to initialize */
 static int yy_start = 0;       /* start state number */
 
 /* Flag which is used to allow yywrap()'s to do buffer switches
@@ -233,142 +288,169 @@ static int yy_start = 0;        /* start state number */
  */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart YY_PROTO(( FILE *input_file ));
+void yyrestart (FILE *input_file  );
+void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
+void yy_delete_buffer (YY_BUFFER_STATE b  );
+void yy_flush_buffer (YY_BUFFER_STATE b  );
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state (void );
+
+static void yyensure_buffer_stack (void );
+static void yy_load_buffer_state (void );
+static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
-void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
-YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
-YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 
-static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
-static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) __unused;
-static void yy_flex_free YY_PROTO(( void * ));
+void *yyalloc (yy_size_t  );
+void *yyrealloc (void *,yy_size_t  );
+void yyfree (void *  );
 
 #define yy_new_buffer yy_create_buffer
 
 #define yy_set_interactive(is_interactive) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_is_interactive = is_interactive; \
+       if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }
 
 #define yy_set_bol(at_bol) \
        { \
-       if ( ! yy_current_buffer ) \
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
-       yy_current_buffer->yy_at_bol = at_bol; \
+       if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }
 
-#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
 
 typedef unsigned char YY_CHAR;
+
 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+
 typedef int yy_state_type;
+
+extern int yylineno;
+
+int yylineno = 1;
+
 extern char *yytext;
 #define yytext_ptr yytext
 
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
-static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+static yy_state_type yy_get_previous_state (void );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
+static int yy_get_next_buffer (void );
+static void yy_fatal_error (yyconst char msg[]  );
 
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
  */
 #define YY_DO_BEFORE_ACTION \
-       yytext_ptr = yy_bp; \
-       yytext_ptr -= yy_more_len; \
-       yyleng = (int) (yy_cp - yytext_ptr); \
-       yy_hold_char = *yy_cp; \
+       (yytext_ptr) = yy_bp; \
+       (yytext_ptr) -= (yy_more_len); \
+       yyleng = (size_t) (yy_cp - (yytext_ptr)); \
+       (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
-       yy_c_buf_p = yy_cp;
+       (yy_c_buf_p) = yy_cp;
 
-#define YY_NUM_RULES 75
-#define YY_END_OF_BUFFER 76
-static yyconst short int yy_accept[645] =
+#define YY_NUM_RULES 76
+#define YY_END_OF_BUFFER 77
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
+static yyconst flex_int16_t yy_accept[655] =
     {   0,
-        1,    1,   63,   63,   67,   67,   71,   71,   76,   74,
-        1,   61,   62,    2,   75,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   63,   64,   75,   65,   75,   70,   67,   68,   69,
-       75,   71,   72,   73,   75,   74,    0,    1,    2,    2,
-        2,    2,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   63,    0,   70,
-        0,   67,   71,    0,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   38,   74,   74,   74,   74,    6,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   17,   74,   11,   12,   74,
-       14,   13,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,    3,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   66,   74,
-       74,   74,   74,   74,   74,   20,   74,   74,   74,   74,
-       74,   74,   21,   74,   74,   74,   74,   74,   74,   74,
-
-       74,   74,   74,   74,   74,   74,   74,   74,   48,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   47,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       18,   74,   74,   74,   74,   74,   74,   19,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   15,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   39,   40,   37,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,    5,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   60,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   36,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,    4,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   42,   43,   41,   74,   74,   74,
-       46,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   52,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   45,   74,   74,   74,   74,   74,   74,   74,   74,
-
-       49,   74,   74,   74,   74,   74,   74,    7,   74,   74,
-       74,   74,   74,   74,   54,   74,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   27,   28,   57,   74,
-       74,   23,   74,   74,   74,   74,    8,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   74,   58,   22,   24,   74,   74,   74,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   10,   74,   74,   74,   74,   74,    9,   25,   74,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       74,   74,   29,   74,   74,   26,   74,   50,   51,   74,
-
-       74,   53,   74,   74,   74,   74,   74,   74,   74,   16,
-       74,   74,   74,   74,   74,   74,   74,   74,   74,   74,
-       33,   74,   74,   56,   44,   35,   34,   74,   30,   74,
-       55,   74,   31,   74,   74,   32,   74,   74,   74,   74,
-       74,   74,   59,    0
+        1,    1,   64,   64,   68,   68,   72,   72,   77,   75,
+        1,   62,   63,    2,   76,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   64,   65,   76,   66,   76,   71,   68,   69,   70,
+       76,   72,   73,   74,   76,   75,    0,    1,    2,    2,
+        2,    2,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   64,    0,
+       71,    0,   68,   72,    0,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   39,   75,   75,   75,
+       75,    6,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       17,   75,   11,   12,   75,   14,   13,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,    3,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   67,   75,   75,   75,   75,   75,
+       75,   20,   75,   75,   75,   75,   75,   75,   21,   75,
+
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   49,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   48,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   18,   75,
+       75,   75,   75,   75,   75,   19,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   15,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   40,   41,   38,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,    5,   75,   75,   75,   75,   75,
+
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   22,   75,
+       75,   75,   75,   61,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   37,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,    4,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   43,   44,   42,   75,   75,   75,
+       47,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   53,   75,   75,   75,   75,   75,   75,   75,   75,
+
+       75,   46,   75,   75,   75,   75,   75,   75,   75,   75,
+       50,   75,   75,   75,   75,   75,   75,    7,   75,   75,
+       75,   75,   75,   75,   55,   75,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   28,   29,   58,   75,
+       75,   24,   75,   75,   75,   75,    8,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   75,   75,   59,   23,   25,   75,   75,   75,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       75,   10,   75,   75,   75,   75,   75,    9,   26,   75,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+
+       75,   75,   30,   75,   75,   27,   75,   51,   52,   75,
+       75,   54,   75,   75,   75,   75,   75,   75,   75,   16,
+       75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+       34,   75,   75,   57,   45,   36,   35,   75,   31,   75,
+       56,   75,   32,   75,   75,   33,   75,   75,   75,   75,
+       75,   75,   60,    0
     } ;
 
-static yyconst int yy_ec[256] =
+static yyconst flex_int32_t yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
@@ -400,7 +482,7 @@ static yyconst int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst int yy_meta[37] =
+static yyconst flex_int32_t yy_meta[37] =
     {   0,
         1,    2,    3,    4,    4,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -408,159 +490,161 @@ static yyconst int yy_meta[37] =
         1,    1,    1,    1,    1,    1
     } ;
 
-static yyconst short int yy_base[654] =
+static yyconst flex_int16_t yy_base[664] =
     {   0,
-        0,    0,   34,   37,   48,   52,   58,   62, 1313, 1300,
-       41, 1314, 1314,   67,   71,   65,   66,   32,   68,   70,
-       71,   33,   72,   78,   36,   82,   84,   87,   88,   81,
-      102, 1299, 1314, 1314, 1314,  101, 1298, 1307, 1314, 1314,
-      118, 1296, 1314, 1314,  120, 1295,  124,  110,    0,  128,
-        0,    0,  109,  115,  124,  122,  123,  125,  130,  131,
-      133,  136,  138,  141,   85,  145,  127,  147,  144,  149,
-      152,  153,  154,  155,  158,  159,  160, 1294,  172, 1293,
-      186, 1302, 1291,  188,  168,  183,  184,  172,  162,  185,
-      174,  191,  189,  195,  201,  186,  198,  212,  208,  214,
-
-      210,  215,  211,  219,  199,  223,  222,  216,  231,  232,
-      233,  228,  236,  237,  240,  238,  243,  244,  250,  258,
-      246,  249,  256,  259,  257,  261,  262,  266,  270,  276,
-      263,  267,  278,  284,  280,  285,  291,  288,  289,  292,
-      294,  311,  295,  296,  297,  298,  303,  302,  304,  312,
-      306,  315,  320,  322,  330,  333,  337,  338,  335,  339,
-      340,  343,  346, 1290,  348,  349,  351,  353, 1289,  359,
-      352,  365,  355,  367,  356,  370,  361,  376,  377,  378,
-      380,  382,  383,  391,  384,  393,  402,  386,  404,  406,
-      407,  413,  410,  412,  396,  416,  409,  420,  418,  424,
-
-      425,  434,  388,  432,  433,  426,  436,  437,  441,  440,
-      446,  445,  447,  453,  451,  454,  455,  456,  457,  460,
-      462,  466,  463,  469,  470, 1288,  472, 1287, 1286,  474,
-     1285, 1284,  481,  475,  479,  477,  485,  488,  491,  495,
-      492,  499,  501,  497,  503,  507,  509,  511,  512,  513,
-      514,  517,  522, 1283,  520,  525,  526,  527,  528,  535,
-      531,  532,  534,  544,  546,  536,  538,  540,  548,  551,
-      552,  555,  557,  560,  558,  562,  564,  570, 1282,  576,
-      577,  565,  573,  581,  584, 1281,  578,  588,  590,  587,
-      597,  599, 1280,  600,  591,  601,  602,  604,  610,  605,
-
-      611,  617,  606,  614,  622,  612,  619,  621, 1279,  631,
-      632,  634,  626,  633,  623,  635,  636,  639,  642, 1278,
-      641,  645,  646,  655,  649,  661,  657,  659,  667,  663,
-      669,  666,  664,  678,  685,  687,  671,  674,  688,  689,
-     1277,  697,  699,  700,  698,  691,  702, 1276,  703,  704,
-      705,  706,  710,  711,  712,  713,  714,  716,  721,  730,
-      732, 1275,  717,  731,  738,  724,  734,  739,  740,  741,
-      744,  745,  743, 1274, 1273, 1272,  747,  749,  751,  755,
-      756,  759,  762,  764,  765, 1271,  766,  767,  769,  771,
-      778,  780,  773,  779,  781,  770,  791,  787,  790,  793,
-
-      796,  795,  799,  812,  801,  797,  803,  811,  814,  822,
-      818,  819,  820, 1270,  821,  825,  830,  832,  824,  839,
-      842,  844,  846, 1269,  852,  853,  831,  850,  856,  855,
-      857,  858,  859,  860,  862,  863,  864,  870,  865, 1268,
-      874,  886,  875,  878,  882,  889,  892,  895,  893,  897,
-      896,  903,  899,  905, 1267, 1266, 1265,  902,  907,  911,
-     1264,  908,  912,  914,  915,  917,  921,  924,  923,  931,
-      916,  933,  935,  936,  922,  942,  944,  945,  946,  947,
-      948, 1263,  952,  960,  956,  949,  964,  966,  969,  963,
-      970, 1262,  972,  974,  976,  977,  980,  982,  985,  987,
-
-     1261,  989,  992,  993,  995,  996,  997, 1260,  999, 1001,
-     1003, 1006, 1007, 1008, 1259, 1009, 1010, 1013, 1023, 1022,
-     1024, 1015, 1027, 1030, 1031,  951, 1258, 1257, 1256, 1033,
-     1037, 1255, 1041, 1043, 1044, 1034, 1254, 1046, 1048, 1047,
-     1052, 1053, 1056, 1054, 1055, 1057, 1059, 1060, 1061, 1067,
-     1073, 1070, 1062, 1253, 1251, 1243, 1071, 1072, 1082, 1086,
-     1083, 1087, 1088, 1089, 1091, 1092, 1095, 1098, 1099, 1102,
-     1106, 1227, 1103, 1107, 1109, 1110, 1114, 1226, 1225, 1117,
-     1120, 1127, 1129, 1122, 1136, 1133, 1130, 1124, 1138, 1113,
-     1139, 1140, 1224, 1141, 1145, 1223, 1146, 1222, 1220, 1149,
-
-     1147, 1219, 1152, 1153, 1154, 1155, 1151, 1161, 1162, 1216,
-     1164, 1165, 1166, 1174, 1178, 1181, 1183, 1184, 1187, 1190,
-     1215, 1193, 1194, 1214, 1213, 1170, 1168, 1196,  867, 1197,
-      823, 1188,  680, 1203, 1206,  567, 1198, 1200, 1204, 1208,
-     1210, 1212,  358, 1314, 1240, 1244, 1248,  329, 1252, 1256,
-      106, 1258, 1260
+        0,    0,   34,   37,   48,   52,   58,   62, 1333, 1320,
+       41, 1334, 1334,   67,   71,   65,   66,   32,   68,   70,
+       71,   33,   72,   78,   36,   82,   85,   84,   87,   92,
+      100, 1319, 1334, 1334, 1334,  101, 1318, 1327, 1334, 1334,
+      116, 1316, 1334, 1334,  119, 1315,  123,  124,    0,  127,
+        0,    0,  107,  121,  128,  122,  125,  126,  129,  137,
+      131,  141,  132,  144,  133,  135,  146,  149,  150,   81,
+      152,  155,  157,  158,  159,  161,  160,  163, 1314,  176,
+     1313,  191, 1322, 1311,  181,  162,  182,  185,  164,  188,
+      190,  178,  189,  193,  196,  202,  206,  199,  213,  209,
+
+      216,  215,  217,  207,  218,  220,  221,  227,  224,  228,
+      235,  238,  232,  239,  240,  236,  241,  244,  245,  256,
+      254,  263,  248,  260,  261,  264,  262,  266,  268,  270,
+      272,  283,  271,  278,  276,  289,  291,  284,  293,  299,
+      295,  296,  301,  297,  320,  302,  304,  305,  306,  311,
+      307,  312,  314,  321,  317,  328,  331,  332,  339,  346,
+      344,  342,  345,  347,  351,  353, 1310,  355,  357,  358,
+      359, 1309,  360,  366,  362,  372,  363,  369,  376,  377,
+      381,  383,  384,  385,  386,  387,  389,  393,  390,  398,
+      401,  412,  409,  411,  413,  419,  416,  418,  415,  421,
+
+      422,  425,  429,  424,  432,  443,  439,  441,  442,  431,
+      440,  446,  449,  452,  457,  450,  459,  460,  466,  462,
+      464,  465,  467,  469,  470,  472,  480,  471,  478,  481,
+     1308,  482, 1307, 1306,  484, 1305, 1304,  491,  490,  493,
+      489,  492,  496,  502,  503,  505,  510,  513,  512,  518,
+      521,  522,  523,  525,  527,  507,  530,  526,  533, 1303,
+      536,  535,  537,  538,  541,  548,  545,  546,  547,  557,
+      549,  555,  559,  560,  562,  563,  564,  565,  569,  574,
+      568,  570,  577,  582, 1302,  590,  588,  578,  587,  592,
+      593, 1301,  594,  600,  601,  602,  603,  612, 1300,  609,
+
+      610,  614,  615,  616,  617,  620,  619,  618,  625,  626,
+      627,  637,  630,  636,  635, 1299,  639,  641,  648,  642,
+      643,  649,  650,  651,  653,  654, 1298,  655,  662,  659,
+      661,  674,  676,  664,  675,  684,  680,  682,  681,  683,
+      687,  689,  700,  703,  691,  697,  704,  706, 1297,  712,
+      716,  719,  708,  715,  721, 1296,  718,  722,  723,  724,
+      725,  727,  728,  729,  732,  731,  739,  747,  748, 1295,
+      736,  749,  757,  740,  750,  753,  756,  759,  760,  761,
+      764,  765, 1294, 1293, 1292,  772,  766,  767,  777,  773,
+      781,  778,  783,  784, 1291,  785,  786,  791,  789,  796,
+
+      793,  797,  799,  800,  805,  806,  804,  807,  811,  812,
+      809,  819,  829,  815,  825,  831,  832,  833, 1290,  839,
+      837,  835,  836, 1289,  838,  847,  848,  850,  856,  863,
+      841,  860,  862, 1288,  869,  871,  867,  873,  875,  868,
+      874,  876,  877,  882,  878,  880,  884,  887,  891, 1287,
+      892,  899,  896,  898,  900,  907,  914,  916,  910,  919,
+      903,  917,  904,  927, 1286, 1285, 1284,  920,  922,  930,
+     1283,  931,  932,  934,  935,  937,  938,  939,  940,  952,
+      941,  953,  943,  955,  947,  956,  962,  963,  967,  957,
+      971, 1282,  973,  970,  974,  966,  981,  982,  986,  980,
+
+      988, 1281,  989,  991,  993,  994,  997,  999, 1002, 1004,
+     1280, 1006, 1010, 1007, 1012, 1013, 1014, 1279, 1016, 1018,
+     1020, 1023, 1024, 1026, 1278, 1027, 1030, 1031, 1041, 1034,
+     1040, 1043, 1044, 1047, 1048, 1051, 1277, 1276, 1275, 1055,
+     1058, 1274, 1061, 1067, 1063, 1050, 1273, 1066, 1068, 1069,
+     1072, 1073, 1076, 1074, 1075, 1077, 1078, 1079, 1081, 1087,
+     1093, 1090, 1082, 1272, 1270, 1262, 1091, 1102, 1107, 1109,
+     1097, 1092, 1111, 1112, 1113, 1114, 1118, 1120, 1121, 1122,
+     1124, 1246, 1125, 1128, 1130, 1132, 1136, 1245, 1244, 1138,
+     1139, 1145, 1148, 1149, 1155, 1152, 1153, 1154, 1156, 1135,
+
+     1158, 1160, 1243, 1163, 1165, 1242, 1166, 1238, 1237, 1168,
+     1173, 1234, 1170, 1174, 1176, 1178, 1171, 1181, 1185, 1233,
+     1187, 1177, 1184, 1197, 1201, 1205, 1207, 1193, 1209, 1210,
+     1232, 1213, 1214, 1202, 1191, 1103, 1028, 1216,  959, 1217,
+      842, 1218,  693, 1223, 1224,  660, 1220, 1227, 1226, 1228,
+     1229, 1231,  388, 1334, 1259, 1263, 1267,  329, 1271, 1275,
+      108, 1277, 1279
     } ;
 
-static yyconst short int yy_def[654] =
+static yyconst flex_int16_t yy_def[664] =
     {   0,
-      644,    1,  645,  645,  646,  646,  647,  647,  644,  648,
-      644,  644,  644,  649,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  650,  644,  644,  644,  650,  651,  644,  644,  644,
-      651,  652,  644,  644,  652,  648,  648,  644,  653,  649,
-      653,  649,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  650,  650,  651,
-      651,  644,  652,  652,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,  648,  648,  648,  648,  648,  648,  648,
-      648,  648,  648,    0,  644,  644,  644,  644,  644,  644,
-      644,  644,  644
+      654,    1,  655,  655,  656,  656,  657,  657,  654,  658,
+      654,  654,  654,  659,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  660,  654,  654,  654,  660,  661,  654,  654,  654,
+      661,  662,  654,  654,  662,  658,  658,  654,  663,  659,
+      663,  659,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  660,  660,
+      661,  661,  654,  662,  662,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,  658,  658,  658,  658,  658,  658,  658,
+      658,  658,  658,    0,  654,  654,  654,  654,  654,  654,
+      654,  654,  654
     } ;
 
-static yyconst short int yy_nxt[1351] =
+static yyconst flex_int16_t yy_nxt[1371] =
     {   0,
        10,   11,   12,   12,   13,   14,   10,   10,   10,   10,
        10,   15,   10,   10,   16,   17,   10,   18,   10,   19,
@@ -571,148 +655,150 @@ static yyconst short int yy_nxt[1351] =
        43,   43,   44,   41,   43,   43,   44,   67,   51,   45,
        51,   51,   46,   45,   46,   46,   47,   47,   52,   47,
        57,   47,   47,   47,   53,   59,   54,   61,   58,   47,
-       65,   55,   47,   47,   60,   47,   47,   63,   47,   47,
-
-       73,   64,   68,   71,   78,   78,   80,   69,   99,   66,
-       75,   48,   70,   47,   76,   49,   74,   72,   77,   80,
-       47,   80,   80,   83,   83,   46,   47,   46,   46,   51,
-       87,   51,   51,   47,   47,   47,   47,   85,   47,   52,
-       90,   47,   47,   86,   47,   92,   91,   47,   93,   47,
-       88,   89,   47,   97,   96,   47,   47,  101,   47,   98,
-       47,   94,  102,   47,   47,   47,   47,   95,  100,   47,
-       47,   47,  103,   47,  109,   78,   78,  119,  104,   47,
-      105,  110,  107,   47,  106,   47,  108,   80,  111,   80,
-       80,   83,   83,  112,   47,   47,   47,   47,  121,  113,
-
-       47,  120,   47,  127,  114,  118,   47,  126,  115,   47,
-       47,  125,   47,  122,  116,  117,  123,  124,  129,   47,
-      131,   47,   47,   47,  130,   47,   47,   47,  132,  128,
-       47,  136,  133,   47,   47,  135,  137,  140,  142,   47,
-      138,  134,   47,   47,   47,  139,  143,   47,   47,   47,
-      146,   47,  149,  145,   47,   47,  151,   47,  150,  141,
-       47,   47,  144,  147,  153,  148,  152,   47,   47,   47,
-       47,  157,   47,   47,   47,  159,  154,   47,   47,  156,
-      155,   47,  160,  162,  163,  158,  164,   47,  161,   47,
-      165,   47,  167,  166,  169,   47,   47,  172,  168,   47,
-
-       47,  171,   47,   47,  173,   47,   47,   47,   47,   47,
-      170,  186,  187,   47,   47,   47,  183,   47,  176,  174,
-      182,  175,   47,   47,  177,  178,   47,  184,  185,   46,
-      189,   47,  188,   47,  191,  179,  180,  181,  190,  192,
-      193,   47,  195,  198,   47,  196,   47,  200,   47,   47,
-       47,   47,  194,  197,   47,  199,  202,   47,  204,   47,
-       47,  201,   47,   47,   47,  209,   47,   47,  206,   47,
-       47,  207,   47,  215,  203,  208,   47,  211,   47,  205,
-      210,   47,  218,  216,  212,  214,  219,   47,   47,   47,
-      217,   47,  230,   47,   47,   47,  223,   47,  220,   47,
-
-      213,  226,   47,  228,   47,  247,  221,   47,  225,  227,
-      222,  224,  229,   47,  231,   47,  232,   47,   47,  234,
-       47,   47,  233,   47,   47,  235,  237,   47,  236,   47,
-      243,   47,  238,  239,  240,   47,   47,   47,  244,  241,
-      246,  245,  242,   47,   47,   47,  248,   47,   47,  249,
-      254,   47,   47,  252,  250,  253,   47,   47,   47,  258,
-      251,  255,   47,  259,   47,   47,   47,   47,   47,  260,
-      256,   47,  257,   47,   47,  263,  264,   47,  265,  262,
-       47,   47,  266,   47,  261,   47,   47,  272,   47,  268,
-       47,  267,   47,  273,  269,  276,   47,  274,  279,   47,
-
-      270,  271,   47,   47,  275,  277,   47,  281,   47,  280,
-       47,  283,   47,  286,   47,  284,  285,  282,   47,  278,
-       47,  287,   47,   47,   47,   47,  288,  293,   47,  291,
-      289,   47,  292,   47,  294,  295,   47,   47,   47,   47,
-      290,  300,   47,   47,  298,   47,   47,   47,  302,   47,
-      297,   47,  299,  301,  296,   47,  304,   47,  309,   47,
-      305,  307,   47,   47,  306,  303,   47,  312,   47,   47,
-      308,   47,  316,   47,  313,   47,   47,  317,   47,  315,
-      320,   47,  321,  311,   47,  310,  318,   47,   47,   47,
-      314,  322,   47,  319,  323,   47,  324,  325,   47,   47,
-
-      326,   47,   47,  327,  328,  332,  329,  330,   47,  331,
-       47,   47,   47,   47,  333,   47,   47,   47,  336,  334,
-      337,   47,   47,   47,  338,   47,  339,  341,   47,  344,
-       47,  335,   47,   47,   47,  342,  340,   47,  343,  346,
-      345,  348,   47,   47,   47,   47,   47,   47,  349,  350,
-       47,  351,   47,   47,  353,  347,   47,   47,  352,  362,
-       47,  355,  357,  354,  359,  358,   47,  363,   47,  356,
-       47,  361,   47,  366,   47,   47,  360,   47,   47,  367,
-       47,  364,   47,  373,  368,   47,  369,  365,  374,   47,
-      370,   47,  371,  378,  372,  375,   47,  376,   47,   47,
-
-       47,  377,   47,  381,  379,  382,  383,  380,   47,   47,
-       47,   47,  386,   47,   47,   47,   47,   47,  384,  388,
-      385,   47,   47,   47,   47,   47,  391,   47,   47,  392,
-      390,  387,   47,  394,  389,   47,  398,  397,  399,  395,
-      393,   47,   47,   47,  402,   47,  400,  396,  401,   47,
-       47,   47,   47,  403,   47,   47,   47,  409,   47,  410,
-       47,  411,   47,  404,  406,  414,   47,   47,  405,  408,
-       47,  416,  407,   47,  412,   47,   47,   47,   47,  418,
-       47,   47,   47,  417,   47,  413,  415,  423,  424,   47,
-       47,   47,   47,  429,  419,  421,  425,  430,   47,  422,
-
-      420,   47,   47,  426,   47,  428,   47,   47,   47,  427,
-       47,  440,   47,  433,   47,  434,  435,  431,  439,  437,
-      432,  438,   47,   47,  436,   47,  442,  441,  445,   47,
-       47,   47,   47,   47,   47,   47,   47,  446,  444,  443,
-      450,   47,   47,   47,  453,  454,  451,  447,  452,  448,
-       47,  449,  455,   47,  456,   47,  457,   47,  458,  459,
-      461,   47,  462,   47,   47,  460,   47,   47,   47,   47,
-       47,   47,  469,   47,   47,   47,   47,  463,   47,  464,
-      470,   47,  473,  471,  465,   47,   47,  466,  467,   47,
-      475,  474,  476,   47,  468,  480,  478,   47,  481,  472,
-
-       47,  483,  482,   47,   47,  477,   47,   47,   47,  487,
-       47,  479,  485,   47,   47,  484,   47,  489,   47,   47,
-      491,  492,   47,   47,  494,   47,   47,   47,   47,  490,
-      486,  488,   47,   47,   47,   47,  500,  496,  493,  497,
-      499,  501,   47,  498,   47,  495,   47,   47,  504,  503,
-      506,  502,  505,   47,  508,   47,   47,   47,   47,   47,
-       47,  509,   47,   47,  553,  513,  510,   47,  511,  514,
-      515,   47,  507,  512,   47,   47,  516,   47,  517,  518,
-       47,   47,  519,   47,  520,   47,  523,   47,   47,  526,
-      527,   47,  528,   47,  521,  529,   47,  524,   47,  525,
-
-       47,  522,  532,   47,   47,  531,   47,   47,   47,  537,
-       47,  536,   47,  535,   47,  539,  530,   47,   47,   47,
-       47,   47,  533,  534,   47,  545,   47,  541,  542,  546,
-      544,  540,  549,   47,   47,   47,  538,  547,   47,  543,
-      548,   47,   47,  554,   47,   47,  551,  555,   47,  557,
-      552,  556,   47,  550,   47,   47,  558,   47,   47,   47,
-      559,  561,  560,   47,   47,   47,   47,   47,   47,  562,
-       47,   47,   47,   47,  563,  564,  565,  572,   47,  573,
-      568,   47,   47,   47,   47,  567,  577,  569,  570,  566,
-      571,  575,  578,   47,   47,  574,  579,   47,   47,   47,
-
-       47,  576,   47,   47,  582,  583,   47,  581,  585,   47,
-       47,  586,  580,   47,   47,  588,  584,   47,   47,  593,
-       47,   47,  589,  587,   47,   47,  590,  596,   47,  594,
-      595,   47,  591,   47,  597,   47,  592,  598,   47,  599,
-       47,   47,  601,  602,   47,  603,  600,   47,  606,   47,
-       47,   47,   47,  604,  605,  610,   47,   47,   47,  607,
-       47,  612,   47,   47,   47,   47,   47,  613,  614,  609,
-      608,  617,   47,   47,  621,   47,   47,   47,  620,   47,
-      611,   47,  615,  616,  624,   47,  618,  622,  625,   47,
-      619,  626,   47,  627,   47,   47,  623,  629,   47,   47,
-
-      628,   47,  630,  631,   47,   47,  633,   47,   47,   47,
-      632,   47,  634,  636,   47,   47,  635,   47,  637,   47,
-      639,   47,  643,   47,   47,   47,   47,   47,  638,  640,
-       47,   47,  641,   47,   47,   47,   47,   47,   47,  642,
-       32,   32,   32,   32,   37,   37,   37,   37,   42,   42,
-       42,   42,   50,   50,   47,   50,   78,   78,   83,   83,
-       51,   51,   47,   51,   47,   47,   47,   47,   47,   47,
+       65,   55,   47,   47,   60,   47,   47,   63,   47,   74,
+
+       72,   64,   68,   47,   79,   79,  105,   69,   81,   66,
+       70,   47,   77,   71,   73,   75,   78,   81,   47,   81,
+       81,   76,   84,   84,   46,   48,   46,   46,   51,   49,
+       51,   51,   47,   47,   88,   86,   47,   47,   52,   47,
+       47,   91,   47,   47,   47,   92,   47,   98,   47,   87,
+       89,   93,   47,   90,   94,   47,  100,   47,  101,   97,
+       47,   47,   99,   47,  103,   96,   47,   95,   47,   47,
+       47,   47,   47,   47,   47,   47,  102,  111,  104,   79,
+       79,  106,  112,  107,   84,   84,  109,  114,  108,   47,
+      110,  113,   81,   47,   81,   81,   47,  120,  115,   47,
+
+       47,   47,  123,  121,   47,  116,  122,   47,  128,  117,
+       47,  124,  127,   47,  125,  118,  119,   47,   47,  131,
+       47,  126,  133,  129,   47,  132,   47,   47,   47,   47,
+      130,   47,   47,  134,  135,   47,  138,  136,   47,   47,
+      140,  143,  141,   47,  145,  146,   47,   47,  137,   47,
+       47,   47,   47,  139,  149,   47,   47,  142,  152,   47,
+      153,  147,  150,  144,  148,   47,  151,   47,  154,  156,
+      155,   47,   47,   47,   47,   47,  160,   47,  157,   47,
+      162,   47,   47,   47,  159,  165,  166,   47,  163,   47,
+      161,  158,  164,  167,   47,   47,  171,  173,  168,  172,
+
+       47,  169,   47,  170,   47,  176,   47,   47,   47,  175,
+       47,  177,   47,   47,  174,   47,   47,   47,   47,  190,
+      191,  180,   47,   47,  187,   47,  178,  186,   47,   46,
+      179,   47,   47,  181,  182,  188,  189,  192,  193,   47,
+      194,  196,   47,   47,  183,  184,  185,  200,  197,  195,
+       47,  199,  202,   47,  204,   47,   47,   47,   47,  201,
+      198,  203,   47,  206,   47,  208,   47,  205,   47,   47,
+       47,   47,  214,   47,   47,  220,  210,   47,  211,  213,
+       47,  212,  207,   47,  216,  221,  209,   47,   47,  223,
+      215,  217,   47,  219,   47,   47,   47,   47,   47,   47,
+
+       47,   47,  228,  231,   47,  225,  224,  218,  233,   47,
+      222,  234,   47,  226,  230,  232,  229,  227,  235,  236,
+       47,  237,   47,   47,   47,  239,   47,   47,  238,   47,
+       47,  240,   47,   47,  241,   47,   47,  243,  249,  245,
+       47,  248,   47,   47,  246,  242,  244,  247,  250,  251,
+       47,   47,   47,   47,   47,  253,  252,   47,  254,  255,
+       47,   47,  257,   47,  256,  261,  259,  260,   47,  258,
+       47,   47,  264,   47,  265,   47,   47,   47,   47,  266,
+       47,   47,   47,   47,  262,  263,  270,  269,  271,   47,
+      268,   47,   47,   47,  267,   47,  272,  278,  274,  273,
+
+       47,   47,   47,   47,   47,  275,  285,   47,  279,  282,
+      276,  277,  280,   47,   47,  287,   47,  283,   47,  281,
+      286,   47,  289,   47,   47,  298,  284,  290,  292,   47,
+      288,  291,   47,   47,   47,  293,   47,   47,   47,  294,
+      299,   47,  295,  297,   47,  301,   47,   47,   47,   47,
+      300,  302,   47,  296,  307,  305,   47,   47,   47,   47,
+       47,  304,  309,  312,  303,  306,   47,  308,   47,  311,
+       47,   47,  316,   47,   47,   47,   47,  319,  310,   47,
+       47,   47,  314,  313,  320,   47,  323,  324,   47,   47,
+      315,  322,  327,   47,  325,  318,  328,  317,   47,   47,
+
+      321,   47,  329,   47,   47,   47,  326,  330,  332,  333,
+      331,   47,   47,   47,   47,  338,  335,  336,  339,  334,
+       47,   47,  337,   47,  341,   47,   47,   47,   47,   47,
+       47,   47,  344,  345,  346,  349,   47,   47,   47,  340,
+      347,   47,  342,  348,  352,  343,   47,   47,   47,  356,
+       47,  351,   47,   47,   47,  350,  354,  357,  353,   47,
+       47,   47,   47,  358,   47,   47,   47,  359,  360,  355,
+       47,   47,   47,   47,  365,   47,  363,  369,  362,  366,
+      361,  367,  371,  364,  370,   47,   47,   47,  372,  368,
+      374,   47,   47,   47,   47,   47,  375,  376,   47,  383,
+
+       47,  377,   47,  373,   47,  378,  382,  379,   47,  380,
+      384,   47,  381,  385,   47,   47,  387,   47,  390,   47,
+      388,  386,  391,   47,  389,  392,   47,   47,  393,   47,
+       47,  395,   47,   47,   47,   47,   47,  397,   47,   47,
+       47,  400,   47,   47,  394,  401,  396,   47,  399,  403,
+       47,   47,  398,  407,  408,  406,  402,  404,   47,   47,
+       47,   47,  405,  411,   47,  409,  410,   47,   47,  412,
+       47,   47,   47,  418,  419,   47,   47,   47,   47,  413,
+      415,  420,  414,   47,   47,  417,  421,  424,   47,   47,
+      416,  422,   47,  426,   47,   47,   47,   47,  428,  427,
+
+       47,  423,   47,  425,   47,  433,  434,   47,   47,  435,
+       47,   47,  440,  429,  431,   47,   47,   47,   47,  430,
+       47,  432,   47,   47,  438,  450,   47,  436,  439,  437,
+       47,  443,  445,  444,  441,  449,   47,  442,  446,  447,
+       47,  448,   47,   47,   47,  455,   47,   47,   47,   47,
+       47,  465,   47,   47,  452,  451,  456,  454,   47,   47,
+      453,   47,  460,  457,  461,  458,  462,   47,  459,  464,
+      466,   47,  467,   47,   47,  468,  463,  469,   47,   47,
+       47,  472,   47,  471,   47,   47,   47,   47,   47,   47,
+      473,   47,  474,   47,  479,   47,  480,  475,   47,  483,
+
+      481,  470,   47,   47,  476,  486,  477,   47,  485,   47,
+       47,   47,  478,  490,   47,   47,  488,  484,   47,  482,
+      491,   47,  493,  497,  492,   47,  487,   47,   47,  489,
+       47,   47,  494,   47,  495,  501,  498,  496,   47,  499,
+      502,   47,   47,   47,  504,   47,   47,  500,   47,   47,
+       47,   47,   47,  510,   47,  509,  514,  506,   47,  507,
+      508,  503,  511,   47,   47,  505,   47,   47,   47,  513,
+       47,  515,  518,   47,   47,  516,  512,   47,   47,  519,
+      525,   47,   47,  522,   47,   47,  517,  520,  523,  521,
+      524,   47,   47,   47,  526,  527,  528,   47,  529,   47,
+
+       47,  530,   47,  533,   47,   47,  536,  537,   47,  538,
+       47,  531,  539,   47,  534,   47,  535,   47,   47,  532,
+      542,   47,  541,   47,   47,   47,  547,   47,  546,   47,
+      545,   47,  549,  540,   47,   47,  543,   47,   47,   47,
+      544,   47,   47,  555,  551,   47,  552,  556,  550,  557,
+      554,   47,   47,  548,   47,   47,  558,  553,   47,   47,
+      559,   47,   47,  561,  563,  564,   47,  562,  565,   47,
+      560,  566,   47,  567,   47,  568,  569,   47,   47,   47,
+       47,  571,  570,   47,   47,   47,   47,   47,   47,   47,
+       47,  572,   47,   47,  573,  574,  575,  582,   47,  583,
+
+      578,   47,   47,   47,   47,  577,  579,  580,   47,  576,
+      581,  585,  591,   47,   47,  584,  587,  588,   47,  589,
+       47,  586,   47,   47,   47,   47,  590,  592,  593,   47,
+      595,   47,   47,   47,  596,   47,   47,  598,  594,   47,
+      603,   47,  599,   47,  600,  597,   47,   47,  606,   47,
+       47,  604,  605,  607,  601,  608,   47,  602,  609,   47,
+       47,  611,  612,   47,   47,   47,   47,   47,  613,   47,
+      616,   47,  615,  610,   47,  620,   47,   47,  617,   47,
+      622,   47,   47,  614,   47,   47,  624,   47,   47,   47,
+      618,  619,   47,  623,  627,   47,   47,  631,   47,  632,
+
+      621,  630,   47,  625,   47,  626,  628,  634,   47,  638,
+      629,  635,   47,   47,  633,  636,   47,  637,   47,  639,
+       47,   47,  640,  641,   47,   47,  643,   47,   47,   47,
+      642,   47,  644,  646,   47,   47,  647,   47,   47,   47,
+       47,  653,   47,   47,   47,   47,  645,  649,   47,   47,
+      648,  650,  651,   47,   47,   47,   47,   47,  652,   32,
+       32,   32,   32,   37,   37,   37,   37,   42,   42,   42,
+       42,   50,   50,   47,   50,   79,   79,   84,   84,   51,
+       51,   47,   51,   47,   47,   47,   47,   47,   47,   47,
        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
+
        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
-
-       47,   47,   84,   82,   81,   79,   47,   84,   82,   81,
-       79,   47,  644,    9,  644,  644,  644,  644,  644,  644,
-      644,  644,  644,  644,  644,  644,  644,  644,  644,  644,
-      644,  644,  644,  644,  644,  644,  644,  644,  644,  644,
-      644,  644,  644,  644,  644,  644,  644,  644,  644,  644
+       47,   47,   85,   83,   82,   80,   47,   85,   83,   82,
+       80,   47,  654,    9,  654,  654,  654,  654,  654,  654,
+      654,  654,  654,  654,  654,  654,  654,  654,  654,  654,
+      654,  654,  654,  654,  654,  654,  654,  654,  654,  654,
+      654,  654,  654,  654,  654,  654,  654,  654,  654,  654
     } ;
 
-static yyconst short int yy_chk[1351] =
+static yyconst flex_int16_t yy_chk[1371] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -723,162 +809,166 @@ static yyconst short int yy_chk[1351] =
         7,    7,    7,    6,    8,    8,    8,   25,   14,    7,
        14,   14,   15,    8,   15,   15,   16,   17,   14,   19,
        19,   20,   21,   23,   16,   20,   17,   21,   19,   24,
-       24,   17,   30,   26,   20,   27,   65,   23,   28,   29,
-
-       29,   23,   26,   28,   36,   36,  651,   26,   65,   24,
-       30,   48,   27,   31,   31,   48,   29,   28,   31,   41,
-       53,   41,   41,   45,   45,   47,   54,   47,   47,   50,
-       55,   50,   50,   56,   57,   55,   58,   53,   67,   50,
-       58,   59,   60,   54,   61,   60,   59,   62,   60,   63,
-       56,   57,   64,   63,   62,   69,   66,   67,   68,   64,
-       70,   60,   68,   71,   72,   73,   74,   61,   66,   75,
-       76,   77,   69,   89,   75,   79,   79,   89,   70,   85,
-       71,   76,   73,   88,   72,   91,   74,   81,   77,   81,
-       81,   84,   84,   85,   86,   87,   90,   96,   91,   86,
-
-       93,   90,   92,   96,   87,   88,   94,   95,   87,   97,
-      105,   94,   95,   92,   87,   87,   92,   93,   98,   99,
-      100,  101,  103,   98,   99,  100,  102,  108,  101,   97,
-      104,  105,  102,  107,  106,  104,  106,  109,  110,  112,
-      107,  103,  109,  110,  111,  108,  111,  113,  114,  116,
-      113,  115,  116,  112,  117,  118,  118,  121,  117,  109,
-      122,  119,  111,  114,  120,  115,  119,  123,  125,  120,
-      124,  124,  126,  127,  131,  126,  121,  128,  132,  123,
-      122,  129,  127,  129,  129,  125,  130,  130,  128,  133,
-      131,  135,  132,  131,  134,  134,  136,  137,  133,  138,
-
-      139,  136,  137,  140,  138,  141,  143,  144,  145,  146,
-      135,  147,  147,  148,  147,  149,  144,  151,  141,  139,
-      143,  140,  142,  150,  142,  142,  152,  145,  146,  648,
-      149,  153,  148,  154,  151,  142,  142,  142,  150,  152,
-      153,  155,  154,  157,  156,  155,  159,  159,  157,  158,
-      160,  161,  153,  156,  162,  158,  161,  163,  163,  165,
-      166,  160,  167,  171,  168,  170,  173,  175,  166,  643,
-      170,  167,  177,  174,  162,  168,  172,  172,  174,  165,
-      171,  176,  176,  174,  172,  173,  177,  178,  179,  180,
-      175,  181,  188,  182,  183,  185,  181,  188,  178,  203,
-
-      172,  184,  184,  186,  186,  203,  179,  195,  183,  185,
-      180,  182,  187,  187,  189,  189,  190,  190,  191,  192,
-      197,  193,  191,  194,  192,  193,  195,  196,  194,  199,
-      199,  198,  196,  197,  198,  200,  201,  206,  200,  198,
-      202,  201,  198,  204,  205,  202,  204,  207,  208,  205,
-      210,  210,  209,  208,  206,  209,  212,  211,  213,  214,
-      207,  211,  215,  215,  214,  216,  217,  218,  219,  216,
-      212,  220,  213,  221,  223,  219,  220,  222,  221,  218,
-      224,  225,  222,  227,  217,  230,  234,  233,  236,  224,
-      235,  223,  233,  234,  225,  235,  237,  234,  238,  238,
-
-      227,  230,  239,  241,  234,  236,  240,  240,  244,  239,
-      242,  242,  243,  245,  245,  243,  244,  241,  246,  237,
-      247,  246,  248,  249,  250,  251,  247,  252,  252,  250,
-      248,  255,  251,  253,  253,  255,  256,  257,  258,  259,
-      249,  260,  261,  262,  258,  263,  260,  266,  262,  267,
-      257,  268,  259,  261,  256,  264,  264,  265,  269,  269,
-      265,  267,  270,  271,  266,  263,  272,  272,  273,  275,
-      268,  274,  274,  276,  272,  277,  282,  275,  636,  273,
-      278,  278,  280,  271,  283,  270,  276,  280,  281,  287,
-      272,  281,  284,  277,  282,  285,  283,  284,  290,  288,
-
-      285,  289,  295,  287,  288,  292,  289,  290,  291,  291,
-      292,  294,  296,  297,  294,  298,  300,  303,  297,  295,
-      298,  299,  301,  306,  299,  304,  300,  302,  302,  305,
-      307,  296,  308,  305,  315,  303,  301,  313,  304,  307,
-      306,  310,  310,  311,  314,  312,  316,  317,  311,  312,
-      318,  313,  321,  319,  315,  308,  322,  323,  314,  325,
-      325,  317,  319,  316,  322,  321,  324,  326,  327,  318,
-      328,  324,  326,  329,  330,  333,  323,  332,  329,  330,
-      331,  327,  337,  333,  331,  338,  332,  328,  334,  334,
-      332,  633,  332,  338,  332,  335,  335,  336,  336,  339,
-
-      340,  337,  346,  342,  339,  343,  344,  340,  342,  345,
-      343,  344,  347,  347,  349,  350,  351,  352,  345,  350,
-      346,  353,  354,  355,  356,  357,  353,  358,  363,  354,
-      352,  349,  359,  356,  351,  366,  360,  359,  361,  357,
-      355,  360,  364,  361,  365,  367,  363,  358,  364,  365,
-      368,  369,  370,  366,  373,  371,  372,  372,  377,  373,
-      378,  377,  379,  367,  369,  380,  380,  381,  368,  371,
-      382,  382,  370,  383,  378,  384,  385,  387,  388,  384,
-      389,  396,  390,  383,  393,  379,  381,  390,  391,  391,
-      394,  392,  395,  396,  385,  388,  392,  397,  398,  389,
-
-      387,  399,  397,  393,  400,  395,  402,  401,  406,  394,
-      403,  405,  405,  400,  407,  400,  401,  398,  404,  403,
-      399,  403,  408,  404,  402,  409,  407,  406,  410,  411,
-      412,  413,  415,  410,  631,  419,  416,  411,  409,  408,
-      416,  417,  427,  418,  419,  420,  417,  412,  418,  413,
-      420,  415,  421,  421,  422,  422,  423,  423,  425,  426,
-      428,  428,  429,  425,  426,  427,  430,  429,  431,  432,
-      433,  434,  434,  435,  436,  437,  439,  430,  629,  430,
-      435,  438,  438,  436,  430,  441,  443,  431,  432,  444,
-      441,  439,  442,  445,  433,  446,  444,  442,  447,  437,
-
-      446,  448,  447,  447,  449,  443,  448,  451,  450,  452,
-      453,  445,  450,  458,  452,  449,  454,  454,  459,  462,
-      459,  460,  460,  463,  463,  464,  465,  471,  466,  458,
-      451,  453,  467,  475,  469,  468,  469,  465,  462,  466,
-      468,  470,  470,  467,  472,  464,  473,  474,  473,  472,
-      475,  471,  474,  476,  477,  477,  478,  479,  480,  481,
-      486,  478,  526,  483,  526,  481,  479,  485,  479,  483,
-      484,  484,  476,  480,  490,  487,  485,  488,  486,  487,
-      489,  491,  488,  493,  489,  494,  493,  495,  496,  496,
-      497,  497,  498,  498,  490,  499,  499,  494,  500,  495,
-
-      502,  491,  503,  503,  504,  502,  505,  506,  507,  509,
-      509,  507,  510,  506,  511,  511,  500,  512,  513,  514,
-      516,  517,  504,  505,  518,  518,  522,  513,  514,  519,
-      517,  512,  522,  520,  519,  521,  510,  520,  523,  516,
-      521,  524,  525,  530,  530,  536,  524,  531,  531,  534,
-      525,  533,  533,  523,  534,  535,  535,  538,  540,  539,
-      536,  539,  538,  541,  542,  544,  545,  543,  546,  540,
-      547,  548,  549,  553,  541,  542,  543,  550,  550,  551,
-      546,  552,  557,  558,  551,  545,  558,  547,  548,  544,
-      549,  553,  559,  559,  561,  552,  560,  560,  562,  563,
-
-      564,  557,  565,  566,  563,  564,  567,  562,  566,  568,
-      569,  567,  561,  570,  573,  569,  565,  571,  574,  575,
-      575,  576,  570,  568,  590,  577,  571,  580,  580,  576,
-      577,  581,  573,  584,  581,  588,  574,  582,  582,  583,
-      583,  587,  585,  586,  586,  587,  584,  585,  590,  589,
-      591,  592,  594,  588,  589,  595,  595,  597,  601,  591,
-      600,  600,  607,  603,  604,  605,  606,  601,  603,  594,
-      592,  606,  608,  609,  611,  611,  612,  613,  609,  627,
-      597,  626,  604,  605,  614,  614,  607,  612,  615,  615,
-      608,  616,  616,  617,  617,  618,  613,  619,  619,  632,
-
-      618,  620,  620,  622,  622,  623,  628,  628,  630,  637,
-      623,  638,  630,  634,  634,  639,  632,  635,  635,  640,
-      638,  641,  642,  642,  625,  624,  621,  610,  637,  639,
-      602,  599,  640,  598,  596,  593,  579,  578,  572,  641,
-      645,  645,  645,  645,  646,  646,  646,  646,  647,  647,
-      647,  647,  649,  649,  556,  649,  650,  650,  652,  652,
-      653,  653,  555,  653,  554,  537,  532,  529,  528,  527,
-      515,  508,  501,  492,  482,  461,  457,  456,  455,  440,
-      424,  414,  386,  376,  375,  374,  362,  348,  341,  320,
-      309,  293,  286,  279,  254,  232,  231,  229,  228,  226,
-
-      169,  164,   83,   82,   80,   78,   46,   42,   38,   37,
-       32,   10,    9,  644,  644,  644,  644,  644,  644,  644,
-      644,  644,  644,  644,  644,  644,  644,  644,  644,  644,
-      644,  644,  644,  644,  644,  644,  644,  644,  644,  644,
-      644,  644,  644,  644,  644,  644,  644,  644,  644,  644
+       24,   17,   70,   26,   20,   28,   27,   23,   29,   29,
+
+       28,   23,   26,   30,   36,   36,   70,   26,  661,   24,
+       27,   31,   31,   27,   28,   29,   31,   41,   53,   41,
+       41,   30,   45,   45,   47,   48,   47,   47,   50,   48,
+       50,   50,   54,   56,   55,   53,   57,   58,   50,   55,
+       59,   58,   61,   63,   65,   59,   66,   63,   60,   54,
+       56,   60,   62,   57,   60,   64,   65,   67,   66,   62,
+       68,   69,   64,   71,   68,   61,   72,   60,   73,   74,
+       75,   77,   76,   86,   78,   89,   67,   76,   69,   80,
+       80,   71,   77,   72,   85,   85,   74,   86,   73,   92,
+       75,   78,   82,   87,   82,   82,   88,   89,   87,   90,
+
+       93,   91,   92,   90,   94,   88,   91,   95,   96,   88,
+       98,   93,   95,   96,   93,   88,   88,   97,  104,   99,
+      100,   94,  101,   97,   99,  100,  102,  101,  103,  105,
+       98,  106,  107,  102,  103,  109,  106,  104,  108,  110,
+      108,  111,  109,  113,  112,  113,  111,  116,  105,  112,
+      114,  115,  117,  107,  115,  118,  119,  110,  118,  123,
+      119,  113,  116,  111,  114,  121,  117,  120,  120,  122,
+      121,  124,  125,  127,  122,  126,  126,  128,  123,  129,
+      128,  130,  133,  131,  125,  131,  131,  135,  129,  134,
+      127,  124,  130,  132,  132,  138,  135,  137,  133,  136,
+
+      136,  133,  137,  134,  139,  140,  141,  142,  144,  139,
+      140,  141,  143,  146,  138,  147,  148,  149,  151,  150,
+      150,  144,  150,  152,  147,  153,  142,  146,  155,  658,
+      143,  145,  154,  145,  145,  148,  149,  151,  152,  156,
+      153,  155,  157,  158,  145,  145,  145,  158,  156,  154,
+      159,  157,  160,  162,  162,  161,  163,  160,  164,  159,
+      156,  161,  165,  164,  166,  166,  168,  163,  169,  170,
+      171,  173,  174,  175,  177,  178,  169,  174,  170,  173,
+      178,  171,  165,  176,  176,  178,  168,  179,  180,  180,
+      175,  176,  181,  177,  182,  183,  184,  185,  186,  653,
+
+      187,  189,  185,  188,  188,  182,  181,  176,  190,  190,
+      179,  191,  191,  183,  187,  189,  186,  184,  192,  193,
+      193,  194,  194,  192,  195,  196,  199,  197,  195,  198,
+      196,  197,  200,  201,  198,  204,  202,  200,  204,  202,
+      203,  203,  210,  205,  202,  199,  201,  202,  205,  206,
+      207,  211,  208,  209,  206,  208,  207,  212,  209,  210,
+      213,  216,  212,  214,  211,  216,  214,  215,  215,  213,
+      217,  218,  219,  220,  220,  221,  222,  219,  223,  221,
+      224,  225,  228,  226,  217,  218,  225,  224,  226,  229,
+      223,  227,  230,  232,  222,  235,  227,  238,  229,  228,
+
+      241,  239,  238,  242,  240,  230,  243,  243,  239,  240,
+      232,  235,  239,  244,  245,  245,  246,  241,  256,  239,
+      244,  247,  247,  249,  248,  256,  242,  248,  250,  250,
+      246,  249,  251,  252,  253,  251,  254,  258,  255,  252,
+      257,  257,  253,  255,  259,  259,  262,  261,  263,  264,
+      258,  261,  265,  254,  266,  264,  267,  268,  269,  266,
+      271,  263,  268,  271,  262,  265,  272,  267,  270,  270,
+      273,  274,  275,  275,  276,  277,  278,  278,  269,  281,
+      279,  282,  273,  272,  278,  280,  280,  281,  283,  288,
+      274,  279,  284,  284,  282,  277,  286,  276,  289,  287,
+
+      278,  286,  287,  290,  291,  293,  283,  288,  290,  291,
+      289,  294,  295,  296,  297,  297,  294,  295,  298,  293,
+      300,  301,  296,  298,  301,  302,  303,  304,  305,  308,
+      307,  306,  304,  305,  306,  309,  309,  310,  311,  300,
+      307,  313,  302,  308,  312,  303,  315,  314,  312,  317,
+      317,  311,  318,  320,  321,  310,  314,  318,  313,  319,
+      322,  323,  324,  319,  325,  326,  328,  320,  321,  315,
+      330,  646,  331,  329,  326,  334,  324,  331,  323,  328,
+      322,  329,  333,  325,  332,  332,  335,  333,  334,  330,
+      336,  337,  339,  338,  340,  336,  337,  338,  341,  342,
+
+      342,  339,  345,  335,  643,  339,  341,  339,  346,  339,
+      343,  343,  340,  344,  344,  347,  346,  348,  350,  353,
+      347,  345,  351,  350,  348,  352,  354,  351,  353,  357,
+      352,  355,  355,  358,  359,  360,  361,  358,  362,  363,
+      364,  361,  366,  365,  354,  362,  357,  371,  360,  364,
+      367,  374,  359,  368,  369,  367,  363,  365,  368,  369,
+      372,  375,  366,  373,  376,  371,  372,  377,  373,  374,
+      378,  379,  380,  380,  381,  381,  382,  387,  388,  375,
+      377,  382,  376,  386,  390,  379,  386,  389,  389,  392,
+      378,  387,  391,  391,  393,  394,  396,  397,  393,  392,
+
+      399,  388,  398,  390,  401,  399,  400,  400,  402,  401,
+      403,  404,  406,  394,  397,  407,  405,  406,  408,  396,
+      411,  398,  409,  410,  404,  414,  414,  402,  405,  403,
+      412,  409,  410,  409,  407,  413,  415,  408,  411,  412,
+      413,  412,  416,  417,  418,  420,  422,  423,  421,  425,
+      420,  431,  431,  641,  416,  415,  421,  418,  426,  427,
+      417,  428,  426,  422,  427,  423,  428,  429,  425,  430,
+      432,  432,  433,  433,  430,  435,  429,  436,  437,  440,
+      435,  439,  436,  438,  438,  441,  439,  442,  443,  445,
+      440,  446,  440,  444,  444,  447,  445,  440,  448,  448,
+
+      446,  437,  449,  451,  441,  452,  442,  453,  451,  454,
+      452,  455,  443,  456,  461,  463,  454,  449,  456,  447,
+      457,  459,  458,  462,  457,  457,  453,  458,  462,  455,
+      460,  468,  459,  469,  460,  469,  463,  461,  464,  464,
+      470,  470,  472,  473,  473,  474,  475,  468,  476,  477,
+      478,  479,  481,  479,  483,  478,  483,  475,  485,  476,
+      477,  472,  480,  480,  482,  474,  484,  486,  490,  482,
+      639,  484,  487,  487,  488,  485,  481,  496,  489,  488,
+      494,  494,  491,  490,  493,  495,  486,  489,  491,  489,
+      493,  500,  497,  498,  495,  496,  497,  499,  498,  501,
+
+      503,  499,  504,  503,  505,  506,  506,  507,  507,  508,
+      508,  500,  509,  509,  504,  510,  505,  512,  514,  501,
+      513,  513,  512,  515,  516,  517,  519,  519,  517,  520,
+      516,  521,  521,  510,  522,  523,  514,  524,  526,  637,
+      515,  527,  528,  528,  523,  530,  524,  529,  522,  530,
+      527,  531,  529,  520,  532,  533,  531,  526,  534,  535,
+      532,  546,  536,  534,  536,  540,  540,  535,  541,  541,
+      533,  543,  543,  544,  545,  545,  546,  548,  544,  549,
+      550,  549,  548,  551,  552,  554,  555,  553,  556,  557,
+      558,  550,  559,  563,  551,  552,  553,  560,  560,  561,
+
+      556,  562,  567,  572,  561,  555,  557,  558,  571,  554,
+      559,  563,  572,  568,  636,  562,  568,  569,  569,  570,
+      570,  567,  573,  574,  575,  576,  571,  573,  574,  577,
+      576,  578,  579,  580,  577,  581,  583,  579,  575,  584,
+      585,  585,  580,  586,  581,  578,  600,  587,  590,  590,
+      591,  586,  587,  591,  583,  592,  592,  584,  593,  593,
+      594,  595,  596,  596,  597,  598,  595,  599,  597,  601,
+      600,  602,  599,  594,  604,  605,  605,  607,  601,  610,
+      610,  613,  617,  598,  611,  614,  613,  615,  622,  616,
+      602,  604,  618,  611,  616,  623,  619,  621,  621,  622,
+
+      607,  619,  635,  614,  628,  615,  617,  624,  624,  628,
+      618,  625,  625,  634,  623,  626,  626,  627,  627,  629,
+      629,  630,  630,  632,  632,  633,  638,  638,  640,  642,
+      633,  647,  640,  644,  644,  645,  645,  649,  648,  650,
+      651,  652,  652,  631,  620,  612,  642,  648,  609,  608,
+      647,  649,  650,  606,  603,  589,  588,  582,  651,  655,
+      655,  655,  655,  656,  656,  656,  656,  657,  657,  657,
+      657,  659,  659,  566,  659,  660,  660,  662,  662,  663,
+      663,  565,  663,  564,  547,  542,  539,  538,  537,  525,
+      518,  511,  502,  492,  471,  467,  466,  465,  450,  434,
+
+      424,  419,  395,  385,  384,  383,  370,  356,  349,  327,
+      316,  299,  292,  285,  260,  237,  236,  234,  233,  231,
+      172,  167,   84,   83,   81,   79,   46,   42,   38,   37,
+       32,   10,    9,  654,  654,  654,  654,  654,  654,  654,
+      654,  654,  654,  654,  654,  654,  654,  654,  654,  654,
+      654,  654,  654,  654,  654,  654,  654,  654,  654,  654,
+      654,  654,  654,  654,  654,  654,  654,  654,  654,  654
     } ;
 
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
 
+extern int yy_flex_debug;
+int yy_flex_debug = 0;
+
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
  */
 #define REJECT reject_used_but_not_detected
 static int yy_more_flag = 0;
 static int yy_more_len = 0;
-#define yymore() (yy_more_flag = 1)
-#define YY_MORE_ADJ yy_more_len
+#define yymore() ((yy_more_flag) = 1)
+#define YY_MORE_ADJ (yy_more_len)
 #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;
 #line 1 "util/configlexer.lex"
-#define INITIAL 0
 #line 2 "util/configlexer.lex"
 /*
  * configlexer.lex - lexical analyzer for unbound config file
@@ -941,7 +1031,7 @@ static void config_start_include(const char* filename)
        include_stack[config_include_stack_ptr] = YY_CURRENT_BUFFER;
        cfg_parser->filename = strdup(filename);
        cfg_parser->line = 1;
-       yy_switch_to_buffer(yy_create_buffer(input, YY_BUF_SIZE));
+       yy_switch_to_buffer(yy_create_buffer(input,YY_BUF_SIZE));
        ++config_include_stack_ptr;
 }
 
@@ -959,15 +1049,32 @@ static void config_end_include(void)
 #define yy_set_bol(at_bol) \
         { \
                if ( ! yy_current_buffer ) \
-                       yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+                       yy_current_buffer = yy_create_buffer(yyin,YY_BUF_SIZE ); \
                yy_current_buffer->yy_ch_buf[0] = ((at_bol)?'\n':' '); \
         }
 #endif
 
+
+#line 1058 "<stdout>"
+
+#define INITIAL 0
 #define quotedstring 1
 #define include 2
 #define include_quoted 3
 
+#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
+
+static int yy_init_globals (void );
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -975,65 +1082,28 @@ static void config_end_include(void)
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
-extern "C" int yywrap YY_PROTO(( void ));
+extern "C" int yywrap (void );
 #else
-extern int yywrap YY_PROTO(( void ));
-#endif
+extern int yywrap (void );
 #endif
-
-#ifndef YY_NO_UNPUT
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 #endif
 
 #ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+static int yy_flex_strlen (yyconst char * );
 #endif
 
 #ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
-#else
-static int input YY_PROTO(( void ));
-#endif
-#endif
-
-#if YY_STACK_USED
-static int yy_start_stack_ptr = 0;
-static int yy_start_stack_depth = 0;
-static int *yy_start_stack = 0;
-#ifndef YY_NO_PUSH_STATE
-static void yy_push_state YY_PROTO(( int new_state ));
-#endif
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state YY_PROTO(( void ));
-#endif
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state YY_PROTO(( void ));
-#endif
 
+#ifdef __cplusplus
+static int yyinput (void );
 #else
-#define YY_NO_PUSH_STATE 1
-#define YY_NO_POP_STATE 1
-#define YY_NO_TOP_STATE 1
+static int input (void );
 #endif
 
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
-#else
-#if __STDC__
-#ifndef __cplusplus
-#include <stdlib.h>
-#endif
-#else
-/* Just try to get by without declaring the routines.  This will fail
- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
- * or sizeof(void*) != sizeof(int).
- */
-#endif
 #endif
 
 /* Amount of stuff to slurp up with each read. */
@@ -1042,7 +1112,6 @@ YY_MALLOC_DECL
 #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().
@@ -1055,9 +1124,10 @@ YY_MALLOC_DECL
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-       if ( yy_current_buffer->yy_is_interactive ) \
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
                { \
-               int c = '*', n; \
+               int c = '*'; \
+               size_t n; \
                for ( n = 0; n < max_size && \
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
                        buf[n] = (char) c; \
@@ -1067,9 +1137,22 @@ YY_MALLOC_DECL
                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
                result = n; \
                } \
-       else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
-                 && ferror( yyin ) ) \
-               YY_FATAL_ERROR( "input in flex scanner failed" );
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, 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();" -
@@ -1090,12 +1173,18 @@ YY_MALLOC_DECL
 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 #endif
 
+/* end tables serialization structures and prototypes */
+
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
 #ifndef YY_DECL
-#define YY_DECL int yylex YY_PROTO(( void ))
-#endif
+#define YY_DECL_IS_OURS 1
+
+extern int yylex (void);
+
+#define YY_DECL int yylex (void)
+#endif /* !YY_DECL */
 
 /* Code executed at the beginning of each rule, after yytext and yyleng
  * have been set up.
@@ -1112,25 +1201,28 @@ YY_MALLOC_DECL
 #define YY_RULE_SETUP \
        YY_USER_ACTION
 
+/** The main scanner function which does all the work.
+ */
 YY_DECL
-       {
+{
        register yy_state_type yy_current_state;
        register char *yy_cp, *yy_bp;
        register int yy_act;
-
+    
 #line 98 "util/configlexer.lex"
 
+#line 1214 "<stdout>"
 
-       if ( yy_init )
+       if ( !(yy_init) )
                {
-               yy_init = 0;
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
                YY_USER_INIT;
 #endif
 
-               if ( ! yy_start )
-                       yy_start = 1;   /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
 
                if ( ! yyin )
                        yyin = stdin;
@@ -1138,74 +1230,74 @@ YY_DECL
                if ( ! yyout )
                        yyout = stdout;
 
-               if ( ! yy_current_buffer )
-                       yy_current_buffer =
-                               yy_create_buffer( yyin, YY_BUF_SIZE );
+               if ( ! YY_CURRENT_BUFFER ) {
+                       yyensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               yy_create_buffer(yyin,YY_BUF_SIZE );
+               }
 
-               yy_load_buffer_state();
+               yy_load_buffer_state( );
                }
 
        while ( 1 )             /* loops until end-of-file is reached */
                {
-               yy_more_len = 0;
-               if ( yy_more_flag )
+               (yy_more_len) = 0;
+               if ( (yy_more_flag) )
                        {
-                       yy_more_len = yy_c_buf_p - yytext_ptr;
-                       yy_more_flag = 0;
+                       (yy_more_len) = (yy_c_buf_p) - (yytext_ptr);
+                       (yy_more_flag) = 0;
                        }
-               yy_cp = yy_c_buf_p;
+               yy_cp = (yy_c_buf_p);
 
                /* Support of yytext. */
-               *yy_cp = yy_hold_char;
+               *yy_cp = (yy_hold_char);
 
                /* yy_bp points to the position in yy_ch_buf of the start of
                 * the current run.
                 */
                yy_bp = yy_cp;
 
-               yy_current_state = yy_start;
+               yy_current_state = (yy_start);
 yy_match:
                do
                        {
                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                        if ( yy_accept[yy_current_state] )
                                {
-                               yy_last_accepting_state = yy_current_state;
-                               yy_last_accepting_cpos = yy_cp;
+                               (yy_last_accepting_state) = yy_current_state;
+                               (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 >= 645 )
+                               if ( yy_current_state >= 655 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                        ++yy_cp;
                        }
-               while ( yy_base[yy_current_state] != 1314 );
+               while ( yy_base[yy_current_state] != 1334 );
 
 yy_find_action:
                yy_act = yy_accept[yy_current_state];
                if ( yy_act == 0 )
                        { /* have to back up */
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        yy_act = yy_accept[yy_current_state];
                        }
 
                YY_DO_BEFORE_ACTION;
 
-
 do_action:     /* This label is used only to access EOF actions. */
 
-
                switch ( yy_act )
        { /* beginning of action switch */
                        case 0: /* must back up */
                        /* undo the effects of YY_DO_BEFORE_ACTION */
-                       *yy_cp = yy_hold_char;
-                       yy_cp = yy_last_accepting_cpos;
-                       yy_current_state = yy_last_accepting_state;
+                       *yy_cp = (yy_hold_char);
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
                        goto yy_find_action;
 
 case 1:
@@ -1316,229 +1408,236 @@ YY_RULE_SETUP
 case 22:
 YY_RULE_SETUP
 #line 120 "util/configlexer.lex"
-{ YDOUT; return VAR_MSG_BUFFER_SIZE;}
+{ YDOUT; return VAR_ROOT_HINTS;}
        YY_BREAK
 case 23:
 YY_RULE_SETUP
 #line 121 "util/configlexer.lex"
-{ YDOUT; return VAR_MSG_CACHE_SIZE;}
+{ YDOUT; return VAR_MSG_BUFFER_SIZE;}
        YY_BREAK
 case 24:
 YY_RULE_SETUP
 #line 122 "util/configlexer.lex"
-{ YDOUT; return VAR_MSG_CACHE_SLABS;}
+{ YDOUT; return VAR_MSG_CACHE_SIZE;}
        YY_BREAK
 case 25:
 YY_RULE_SETUP
 #line 123 "util/configlexer.lex"
-{ YDOUT; return VAR_RRSET_CACHE_SIZE;}
+{ YDOUT; return VAR_MSG_CACHE_SLABS;}
        YY_BREAK
 case 26:
 YY_RULE_SETUP
 #line 124 "util/configlexer.lex"
-{ YDOUT; return VAR_RRSET_CACHE_SLABS;}
+{ YDOUT; return VAR_RRSET_CACHE_SIZE;}
        YY_BREAK
 case 27:
 YY_RULE_SETUP
 #line 125 "util/configlexer.lex"
-{ YDOUT; return VAR_INFRA_HOST_TTL;}
+{ YDOUT; return VAR_RRSET_CACHE_SLABS;}
        YY_BREAK
 case 28:
 YY_RULE_SETUP
 #line 126 "util/configlexer.lex"
-{ YDOUT; return VAR_INFRA_LAME_TTL;}
+{ YDOUT; return VAR_INFRA_HOST_TTL;}
        YY_BREAK
 case 29:
 YY_RULE_SETUP
 #line 127 "util/configlexer.lex"
-{ YDOUT; return VAR_INFRA_CACHE_SLABS;}
+{ YDOUT; return VAR_INFRA_LAME_TTL;}
        YY_BREAK
 case 30:
 YY_RULE_SETUP
 #line 128 "util/configlexer.lex"
-{ YDOUT; return VAR_INFRA_CACHE_NUMHOSTS;}
+{ YDOUT; return VAR_INFRA_CACHE_SLABS;}
        YY_BREAK
 case 31:
 YY_RULE_SETUP
 #line 129 "util/configlexer.lex"
-{ YDOUT; return VAR_INFRA_CACHE_LAME_SIZE;}
+{ YDOUT; return VAR_INFRA_CACHE_NUMHOSTS;}
        YY_BREAK
 case 32:
 YY_RULE_SETUP
 #line 130 "util/configlexer.lex"
-{ YDOUT; return VAR_NUM_QUERIES_PER_THREAD;}
+{ YDOUT; return VAR_INFRA_CACHE_LAME_SIZE;}
        YY_BREAK
 case 33:
 YY_RULE_SETUP
 #line 131 "util/configlexer.lex"
-{ YDOUT; return VAR_TARGET_FETCH_POLICY;}
+{ YDOUT; return VAR_NUM_QUERIES_PER_THREAD;}
        YY_BREAK
 case 34:
 YY_RULE_SETUP
 #line 132 "util/configlexer.lex"
-{ YDOUT; return VAR_HARDEN_SHORT_BUFSIZE;}
+{ YDOUT; return VAR_TARGET_FETCH_POLICY;}
        YY_BREAK
 case 35:
 YY_RULE_SETUP
 #line 133 "util/configlexer.lex"
-{ YDOUT; return VAR_HARDEN_LARGE_QUERIES;}
+{ YDOUT; return VAR_HARDEN_SHORT_BUFSIZE;}
        YY_BREAK
 case 36:
 YY_RULE_SETUP
 #line 134 "util/configlexer.lex"
-{ YDOUT; return VAR_HARDEN_GLUE;}
+{ YDOUT; return VAR_HARDEN_LARGE_QUERIES;}
        YY_BREAK
 case 37:
 YY_RULE_SETUP
 #line 135 "util/configlexer.lex"
-{ YDOUT; return VAR_STUB_ZONE;}
+{ YDOUT; return VAR_HARDEN_GLUE;}
        YY_BREAK
 case 38:
 YY_RULE_SETUP
 #line 136 "util/configlexer.lex"
-{ YDOUT; return VAR_NAME;}
+{ YDOUT; return VAR_STUB_ZONE;}
        YY_BREAK
 case 39:
 YY_RULE_SETUP
 #line 137 "util/configlexer.lex"
-{ YDOUT; return VAR_STUB_ADDR;}
+{ YDOUT; return VAR_NAME;}
        YY_BREAK
 case 40:
 YY_RULE_SETUP
 #line 138 "util/configlexer.lex"
-{ YDOUT; return VAR_STUB_HOST;}
+{ YDOUT; return VAR_STUB_ADDR;}
        YY_BREAK
 case 41:
 YY_RULE_SETUP
 #line 139 "util/configlexer.lex"
-{ YDOUT; return VAR_FORWARD_ZONE;}
+{ YDOUT; return VAR_STUB_HOST;}
        YY_BREAK
 case 42:
 YY_RULE_SETUP
 #line 140 "util/configlexer.lex"
-{ YDOUT; return VAR_FORWARD_ADDR;}
+{ YDOUT; return VAR_FORWARD_ZONE;}
        YY_BREAK
 case 43:
 YY_RULE_SETUP
 #line 141 "util/configlexer.lex"
-{ YDOUT; return VAR_FORWARD_HOST;}
+{ YDOUT; return VAR_FORWARD_ADDR;}
        YY_BREAK
 case 44:
 YY_RULE_SETUP
 #line 142 "util/configlexer.lex"
-{ YDOUT; return VAR_DO_NOT_QUERY_ADDRESS;}
+{ YDOUT; return VAR_FORWARD_HOST;}
        YY_BREAK
 case 45:
 YY_RULE_SETUP
 #line 143 "util/configlexer.lex"
-{ YDOUT; return VAR_HIDE_IDENTITY;}
+{ YDOUT; return VAR_DO_NOT_QUERY_ADDRESS;}
        YY_BREAK
 case 46:
 YY_RULE_SETUP
 #line 144 "util/configlexer.lex"
-{ YDOUT; return VAR_HIDE_VERSION;}
+{ YDOUT; return VAR_HIDE_IDENTITY;}
        YY_BREAK
 case 47:
 YY_RULE_SETUP
 #line 145 "util/configlexer.lex"
-{ YDOUT; return VAR_IDENTITY;}
+{ YDOUT; return VAR_HIDE_VERSION;}
        YY_BREAK
 case 48:
 YY_RULE_SETUP
 #line 146 "util/configlexer.lex"
-{ YDOUT; return VAR_VERSION;}
+{ YDOUT; return VAR_IDENTITY;}
        YY_BREAK
 case 49:
 YY_RULE_SETUP
 #line 147 "util/configlexer.lex"
-{ YDOUT; return VAR_MODULE_CONF;}
+{ YDOUT; return VAR_VERSION;}
        YY_BREAK
 case 50:
 YY_RULE_SETUP
 #line 148 "util/configlexer.lex"
-{ YDOUT; return VAR_TRUST_ANCHOR_FILE;}
+{ YDOUT; return VAR_MODULE_CONF;}
        YY_BREAK
 case 51:
 YY_RULE_SETUP
 #line 149 "util/configlexer.lex"
-{ YDOUT; return VAR_TRUSTED_KEYS_FILE;}
+{ YDOUT; return VAR_TRUST_ANCHOR_FILE;}
        YY_BREAK
 case 52:
 YY_RULE_SETUP
 #line 150 "util/configlexer.lex"
-{ YDOUT; return VAR_TRUST_ANCHOR;}
+{ YDOUT; return VAR_TRUSTED_KEYS_FILE;}
        YY_BREAK
 case 53:
 YY_RULE_SETUP
 #line 151 "util/configlexer.lex"
-{ YDOUT; return VAR_VAL_OVERRIDE_DATE;}
+{ YDOUT; return VAR_TRUST_ANCHOR;}
        YY_BREAK
 case 54:
 YY_RULE_SETUP
 #line 152 "util/configlexer.lex"
-{ YDOUT; return VAR_BOGUS_TTL;}
+{ YDOUT; return VAR_VAL_OVERRIDE_DATE;}
        YY_BREAK
 case 55:
 YY_RULE_SETUP
 #line 153 "util/configlexer.lex"
-{ YDOUT; return VAR_VAL_CLEAN_ADDITIONAL;}
+{ YDOUT; return VAR_BOGUS_TTL;}
        YY_BREAK
 case 56:
 YY_RULE_SETUP
 #line 154 "util/configlexer.lex"
-{ YDOUT; return VAR_VAL_PERMISSIVE_MODE;}
+{ YDOUT; return VAR_VAL_CLEAN_ADDITIONAL;}
        YY_BREAK
 case 57:
 YY_RULE_SETUP
 #line 155 "util/configlexer.lex"
-{ YDOUT; return VAR_KEY_CACHE_SIZE;}
+{ YDOUT; return VAR_VAL_PERMISSIVE_MODE;}
        YY_BREAK
 case 58:
 YY_RULE_SETUP
 #line 156 "util/configlexer.lex"
-{ YDOUT; return VAR_KEY_CACHE_SLABS;}
+{ YDOUT; return VAR_KEY_CACHE_SIZE;}
        YY_BREAK
 case 59:
 YY_RULE_SETUP
 #line 157 "util/configlexer.lex"
-{ YDOUT; return VAR_VAL_NSEC3_KEYSIZE_ITERATIONS;}
+{ YDOUT; return VAR_KEY_CACHE_SLABS;}
        YY_BREAK
 case 60:
 YY_RULE_SETUP
 #line 158 "util/configlexer.lex"
-{ YDOUT; return VAR_USE_SYSLOG;}
+{ YDOUT; return VAR_VAL_NSEC3_KEYSIZE_ITERATIONS;}
        YY_BREAK
 case 61:
 YY_RULE_SETUP
 #line 159 "util/configlexer.lex"
+{ YDOUT; return VAR_USE_SYSLOG;}
+       YY_BREAK
+case 62:
+/* rule 62 can match eol */
+YY_RULE_SETUP
+#line 160 "util/configlexer.lex"
 { LEXOUT(("NL\n")); cfg_parser->line++;}
        YY_BREAK
 /* Quoted strings. Strip leading and ending quotes */
-case 62:
+case 63:
 YY_RULE_SETUP
-#line 162 "util/configlexer.lex"
+#line 163 "util/configlexer.lex"
 { BEGIN(quotedstring); LEXOUT(("QS ")); }
        YY_BREAK
 case YY_STATE_EOF(quotedstring):
-#line 163 "util/configlexer.lex"
+#line 164 "util/configlexer.lex"
 {
         yyerror("EOF inside quoted string");
         BEGIN(INITIAL);
 }
        YY_BREAK
-case 63:
-YY_RULE_SETUP
-#line 167 "util/configlexer.lex"
-{ LEXOUT(("STR(%s) ", yytext)); yymore(); }
-       YY_BREAK
 case 64:
 YY_RULE_SETUP
 #line 168 "util/configlexer.lex"
-{ cfg_parser->line++; yymore(); }
+{ LEXOUT(("STR(%s) ", yytext)); yymore(); }
        YY_BREAK
 case 65:
+/* rule 65 can match eol */
 YY_RULE_SETUP
 #line 169 "util/configlexer.lex"
+{ cfg_parser->line++; yymore(); }
+       YY_BREAK
+case 66:
+YY_RULE_SETUP
+#line 170 "util/configlexer.lex"
 {
         LEXOUT(("QE "));
         BEGIN(INITIAL);
@@ -1550,36 +1649,37 @@ YY_RULE_SETUP
 }
        YY_BREAK
 /* include: directive */
-case 66:
+case 67:
 YY_RULE_SETUP
-#line 180 "util/configlexer.lex"
+#line 181 "util/configlexer.lex"
 { LEXOUT(("v(%s) ", yytext)); BEGIN(include); }
        YY_BREAK
 case YY_STATE_EOF(include):
-#line 181 "util/configlexer.lex"
+#line 182 "util/configlexer.lex"
 {
         yyerror("EOF inside include directive");
         BEGIN(INITIAL);
 }
        YY_BREAK
-case 67:
-YY_RULE_SETUP
-#line 185 "util/configlexer.lex"
-{ LEXOUT(("ISP ")); /* ignore */ }
-       YY_BREAK
 case 68:
 YY_RULE_SETUP
 #line 186 "util/configlexer.lex"
-{ LEXOUT(("NL\n")); cfg_parser->line++;}
+{ LEXOUT(("ISP ")); /* ignore */ }
        YY_BREAK
 case 69:
+/* rule 69 can match eol */
 YY_RULE_SETUP
 #line 187 "util/configlexer.lex"
-{ LEXOUT(("IQS ")); BEGIN(include_quoted); }
+{ LEXOUT(("NL\n")); cfg_parser->line++;}
        YY_BREAK
 case 70:
 YY_RULE_SETUP
 #line 188 "util/configlexer.lex"
+{ LEXOUT(("IQS ")); BEGIN(include_quoted); }
+       YY_BREAK
+case 71:
+YY_RULE_SETUP
+#line 189 "util/configlexer.lex"
 {
        LEXOUT(("Iunquotedstr(%s) ", yytext));
        config_start_include(yytext);
@@ -1587,25 +1687,26 @@ YY_RULE_SETUP
 }
        YY_BREAK
 case YY_STATE_EOF(include_quoted):
-#line 193 "util/configlexer.lex"
+#line 194 "util/configlexer.lex"
 {
         yyerror("EOF inside quoted string");
         BEGIN(INITIAL);
 }
        YY_BREAK
-case 71:
-YY_RULE_SETUP
-#line 197 "util/configlexer.lex"
-{ LEXOUT(("ISTR(%s) ", yytext)); yymore(); }
-       YY_BREAK
 case 72:
 YY_RULE_SETUP
 #line 198 "util/configlexer.lex"
-{ cfg_parser->line++; yymore(); }
+{ LEXOUT(("ISTR(%s) ", yytext)); yymore(); }
        YY_BREAK
 case 73:
+/* rule 73 can match eol */
 YY_RULE_SETUP
 #line 199 "util/configlexer.lex"
+{ cfg_parser->line++; yymore(); }
+       YY_BREAK
+case 74:
+YY_RULE_SETUP
+#line 200 "util/configlexer.lex"
 {
        LEXOUT(("IQE "));
        yytext[yyleng - 1] = '\0';
@@ -1614,7 +1715,7 @@ YY_RULE_SETUP
 }
        YY_BREAK
 case YY_STATE_EOF(INITIAL):
-#line 205 "util/configlexer.lex"
+#line 206 "util/configlexer.lex"
 {
        yy_set_bol(1); /* Set beginning of line, so "^" rules match.  */
        if (config_include_stack_ptr == 0) {
@@ -1625,41 +1726,42 @@ case YY_STATE_EOF(INITIAL):
        }
 }
        YY_BREAK
-case 74:
+case 75:
 YY_RULE_SETUP
-#line 215 "util/configlexer.lex"
+#line 216 "util/configlexer.lex"
 { LEXOUT(("unquotedstr(%s) ", yytext)); 
                        yylval.str = strdup(yytext); return STRING; }
        YY_BREAK
-case 75:
+case 76:
 YY_RULE_SETUP
-#line 218 "util/configlexer.lex"
+#line 219 "util/configlexer.lex"
 ECHO;
        YY_BREAK
+#line 1740 "<stdout>"
 
        case YY_END_OF_BUFFER:
                {
                /* Amount of text matched not including the EOB char. */
-               int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
                /* Undo the effects of YY_DO_BEFORE_ACTION. */
-               *yy_cp = yy_hold_char;
+               *yy_cp = (yy_hold_char);
                YY_RESTORE_YY_MORE_OFFSET
 
-               if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+               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
+                        * consistency between YY_CURRENT_BUFFER and our
                         * globals.  Here is the right place to do so, because
                         * this is the first action (other than possibly a
                         * back-up) that will match for the new input source.
                         */
-                       yy_n_chars = yy_current_buffer->yy_n_chars;
-                       yy_current_buffer->yy_input_file = yyin;
-                       yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+                       (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
@@ -1669,13 +1771,13 @@ ECHO;
                 * end-of-buffer state).  Contrast this with the test
                 * in input().
                 */
-               if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        { /* This was really a NUL. */
                        yy_state_type yy_next_state;
 
-                       yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+                       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
-                       yy_current_state = yy_get_previous_state();
+                       yy_current_state = yy_get_previous_state(  );
 
                        /* Okay, we're now positioned to make the NUL
                         * transition.  We couldn't have
@@ -1688,30 +1790,30 @@ ECHO;
 
                        yy_next_state = yy_try_NUL_trans( yy_current_state );
 
-                       yy_bp = yytext_ptr + YY_MORE_ADJ;
+                       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
                        if ( yy_next_state )
                                {
                                /* Consume the NUL. */
-                               yy_cp = ++yy_c_buf_p;
+                               yy_cp = ++(yy_c_buf_p);
                                yy_current_state = yy_next_state;
                                goto yy_match;
                                }
 
                        else
                                {
-                               yy_cp = yy_c_buf_p;
+                               yy_cp = (yy_c_buf_p);
                                goto yy_find_action;
                                }
                        }
 
-               else switch ( yy_get_next_buffer() )
+               else switch ( yy_get_next_buffer(  ) )
                        {
                        case EOB_ACT_END_OF_FILE:
                                {
-                               yy_did_buffer_switch_on_eof = 0;
+                               (yy_did_buffer_switch_on_eof) = 0;
 
-                               if ( yywrap() )
+                               if ( yywrap( ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
@@ -1722,7 +1824,7 @@ ECHO;
                                         * YY_NULL, it'll still work - another
                                         * YY_NULL will get returned.
                                         */
-                                       yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+                                       (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
                                        yy_act = YY_STATE_EOF(YY_START);
                                        goto do_action;
@@ -1730,30 +1832,30 @@ ECHO;
 
                                else
                                        {
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
                                        }
                                break;
                                }
 
                        case EOB_ACT_CONTINUE_SCAN:
-                               yy_c_buf_p =
-                                       yytext_ptr + yy_amount_of_matched_text;
+                               (yy_c_buf_p) =
+                                       (yytext_ptr) + yy_amount_of_matched_text;
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_match;
 
                        case EOB_ACT_LAST_MATCH:
-                               yy_c_buf_p =
-                               &yy_current_buffer->yy_ch_buf[yy_n_chars];
+                               (yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
-                               yy_current_state = yy_get_previous_state();
+                               yy_current_state = yy_get_previous_state(  );
 
-                               yy_cp = yy_c_buf_p;
-                               yy_bp = yytext_ptr + YY_MORE_ADJ;
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                                goto yy_find_action;
                        }
                break;
@@ -1764,8 +1866,7 @@ ECHO;
                        "fatal flex scanner internal error--no action found" );
        } /* end of action switch */
                } /* end of scanning one token */
-       } /* end of yylex */
-
+} /* end of yylex */
 
 /* yy_get_next_buffer - try to read in a new buffer
  *
@@ -1774,21 +1875,20 @@ ECHO;
  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  *     EOB_ACT_END_OF_FILE - end of file
  */
-
-static int yy_get_next_buffer()
-       {
-       register char *dest = yy_current_buffer->yy_ch_buf;
-       register char *source = yytext_ptr;
+static int yy_get_next_buffer (void)
+{
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = (yytext_ptr);
        register int number_to_move, i;
        int ret_val;
 
-       if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+       if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
                YY_FATAL_ERROR(
                "fatal flex scanner internal error--end of buffer missed" );
 
-       if ( yy_current_buffer->yy_fill_buffer == 0 )
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
                { /* Don't try to fill the buffer, so this is an EOF. */
-               if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
                        {
                        /* We matched a single character, the EOB, so
                         * treat this as a final EOF.
@@ -1808,34 +1908,30 @@ static int yy_get_next_buffer()
        /* Try to read more data. */
 
        /* First move last chars to start of buffer. */
-       number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
 
        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);
 
-       if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+       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->yy_n_chars = yy_n_chars = 0;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 
        else
                {
-               int num_to_read =
-                       yy_current_buffer->yy_buf_size - number_to_move - 1;
+                       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. */
-#ifdef YY_USES_REJECT
-                       YY_FATAL_ERROR(
-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-#else
 
                        /* just a shorter name for the current buffer */
-                       YY_BUFFER_STATE b = yy_current_buffer;
+                       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 
                        int yy_c_buf_p_offset =
-                               (int) (yy_c_buf_p - b->yy_ch_buf);
+                               (int) ((yy_c_buf_p) - b->yy_ch_buf);
 
                        if ( b->yy_is_our_buffer )
                                {
@@ -1848,8 +1944,7 @@ static int yy_get_next_buffer()
 
                                b->yy_ch_buf = (char *)
                                        /* Include room in for 2 EOB chars. */
-                                       yy_flex_realloc( (void *) b->yy_ch_buf,
-                                                        b->yy_buf_size + 2 );
+                                       yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                                }
                        else
                                /* Can't grow it, we don't own it. */
@@ -1859,35 +1954,35 @@ static int yy_get_next_buffer()
                                YY_FATAL_ERROR(
                                "fatal error - scanner input buffer overflow" );
 
-                       yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+                       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-                       num_to_read = yy_current_buffer->yy_buf_size -
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                                                number_to_move - 1;
-#endif
+
                        }
 
                if ( num_to_read > YY_READ_BUF_SIZE )
                        num_to_read = YY_READ_BUF_SIZE;
 
                /* Read in more data. */
-               YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-                       yy_n_chars, num_to_read );
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       (yy_n_chars), num_to_read );
 
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       if ( yy_n_chars == 0 )
+       if ( (yy_n_chars) == 0 )
                {
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
-                       yyrestart( yyin );
+                       yyrestart(yyin  );
                        }
 
                else
                        {
                        ret_val = EOB_ACT_LAST_MATCH;
-                       yy_current_buffer->yy_buffer_status =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                                YY_BUFFER_EOF_PENDING;
                        }
                }
@@ -1895,152 +1990,100 @@ static int yy_get_next_buffer()
        else
                ret_val = EOB_ACT_CONTINUE_SCAN;
 
-       yy_n_chars += number_to_move;
-       yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-       yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+       (yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 
-       yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+       (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()
-       {
+    static yy_state_type yy_get_previous_state (void)
+{
        register yy_state_type yy_current_state;
        register char *yy_cp;
+    
+       yy_current_state = (yy_start);
 
-       yy_current_state = yy_start;
-
-       for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
                {
                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
                if ( yy_accept[yy_current_state] )
                        {
-                       yy_last_accepting_state = yy_current_state;
-                       yy_last_accepting_cpos = yy_cp;
+                       (yy_last_accepting_state) = yy_current_state;
+                       (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 >= 645 )
+                       if ( yy_current_state >= 655 )
                                yy_c = yy_meta[(unsigned int) yy_c];
                        }
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) 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 );
  */
-
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
-#else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
-yy_state_type yy_current_state;
-#endif
-       {
-       register int yy_is_jam;
-       register char *yy_cp = yy_c_buf_p;
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
+       register int yy_is_jam;
+       register char *yy_cp = (yy_c_buf_p);
 
        register YY_CHAR yy_c = 1;
        if ( yy_accept[yy_current_state] )
                {
-               yy_last_accepting_state = yy_current_state;
-               yy_last_accepting_cpos = yy_cp;
+               (yy_last_accepting_state) = yy_current_state;
+               (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 >= 645 )
+               if ( yy_current_state >= 655 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-       yy_is_jam = (yy_current_state == 644);
+       yy_is_jam = (yy_current_state == 654);
 
        return yy_is_jam ? 0 : yy_current_state;
-       }
-
-
-#ifndef YY_NO_UNPUT
-#ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp )
-#else
-static void yyunput( c, yy_bp )
-int c;
-register char *yy_bp;
-#endif
-       {
-       register char *yy_cp = yy_c_buf_p;
-
-       /* undo effects of setting up yytext */
-       *yy_cp = yy_hold_char;
-
-       if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
-               { /* need to shift things up to make room */
-               /* +2 for EOB chars. */
-               register int number_to_move = yy_n_chars + 2;
-               register char *dest = &yy_current_buffer->yy_ch_buf[
-                                       yy_current_buffer->yy_buf_size + 2];
-               register char *source =
-                               &yy_current_buffer->yy_ch_buf[number_to_move];
-
-               while ( source > yy_current_buffer->yy_ch_buf )
-                       *--dest = *--source;
-
-               yy_cp += (int) (dest - source);
-               yy_bp += (int) (dest - source);
-               yy_current_buffer->yy_n_chars =
-                       yy_n_chars = yy_current_buffer->yy_buf_size;
-
-               if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
-                       YY_FATAL_ERROR( "flex scanner push-back overflow" );
-               }
-
-       *--yy_cp = (char) c;
-
-
-       yytext_ptr = yy_bp;
-       yy_hold_char = *yy_cp;
-       yy_c_buf_p = yy_cp;
-       }
-#endif /* ifndef YY_NO_UNPUT */
-
+}
 
+#ifndef YY_NO_INPUT
 #ifdef __cplusplus
-static int yyinput()
+    static int yyinput (void)
 #else
-static int input()
+    static int input  (void)
 #endif
-       {
-       int c;
 
-       *yy_c_buf_p = yy_hold_char;
+{
+       int c;
+    
+       *(yy_c_buf_p) = (yy_hold_char);
 
-       if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+       if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
                {
                /* yy_c_buf_p now points to the character we want to return.
                 * If this occurs *before* the EOB characters, then it's a
                 * valid NUL; if not, then we've hit the end of the buffer.
                 */
-               if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
                        /* This was really a NUL. */
-                       *yy_c_buf_p = '\0';
+                       *(yy_c_buf_p) = '\0';
 
                else
                        { /* need more input */
-                       int offset = yy_c_buf_p - yytext_ptr;
-                       ++yy_c_buf_p;
+                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       ++(yy_c_buf_p);
 
-                       switch ( yy_get_next_buffer() )
+                       switch ( yy_get_next_buffer(  ) )
                                {
                                case EOB_ACT_LAST_MATCH:
                                        /* This happens because yy_g_n_b()
@@ -2054,16 +2097,16 @@ static int input()
                                         */
 
                                        /* Reset buffer status. */
-                                       yyrestart( yyin );
+                                       yyrestart(yyin );
 
-                                       /* fall through */
+                                       /*FALLTHROUGH*/
 
                                case EOB_ACT_END_OF_FILE:
                                        {
-                                       if ( yywrap() )
+                                       if ( yywrap( ) )
                                                return EOF;
 
-                                       if ( ! yy_did_buffer_switch_on_eof )
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
                                                YY_NEW_FILE;
 #ifdef __cplusplus
                                        return yyinput();
@@ -2073,90 +2116,92 @@ static int input()
                                        }
 
                                case EOB_ACT_CONTINUE_SCAN:
-                                       yy_c_buf_p = yytext_ptr + offset;
+                                       (yy_c_buf_p) = (yytext_ptr) + offset;
                                        break;
                                }
                        }
                }
 
-       c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
-       *yy_c_buf_p = '\0';     /* preserve yytext */
-       yy_hold_char = *++yy_c_buf_p;
-
+       c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
+       *(yy_c_buf_p) = '\0';   /* preserve yytext */
+       (yy_hold_char) = *++(yy_c_buf_p);
 
        return c;
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
-#else
-void yyrestart( input_file )
-FILE *input_file;
-#endif
-       {
-       if ( ! yy_current_buffer )
-               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+}
+#endif /* ifndef YY_NO_INPUT */
 
-       yy_init_buffer( yy_current_buffer, input_file );
-       yy_load_buffer_state();
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void yyrestart  (FILE * input_file )
+{
+    
+       if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+               YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer(yyin,YY_BUF_SIZE );
        }
 
+       yy_init_buffer(YY_CURRENT_BUFFER,input_file );
+       yy_load_buffer_state( );
+}
 
-#ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-#else
-void yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
-#endif
-       {
-       if ( yy_current_buffer == new_buffer )
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              yypop_buffer_state();
+        *              yypush_buffer_state(new_buffer);
+     */
+       yyensure_buffer_stack ();
+       if ( YY_CURRENT_BUFFER == new_buffer )
                return;
 
-       if ( yy_current_buffer )
+       if ( YY_CURRENT_BUFFER )
                {
                /* Flush out information for old buffer. */
-               *yy_c_buf_p = yy_hold_char;
-               yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-               yy_current_buffer->yy_n_chars = yy_n_chars;
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
 
-       yy_current_buffer = new_buffer;
-       yy_load_buffer_state();
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       yy_load_buffer_state( );
 
        /* 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.
         */
-       yy_did_buffer_switch_on_eof = 1;
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
-#else
-void yy_load_buffer_state()
-#endif
-       {
-       yy_n_chars = yy_current_buffer->yy_n_chars;
-       yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-       yyin = yy_current_buffer->yy_input_file;
-       yy_hold_char = *yy_c_buf_p;
-       }
+       (yy_did_buffer_switch_on_eof) = 1;
+}
 
+static void yy_load_buffer_state  (void)
+{
+       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+       (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+       yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);
+}
 
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
-#else
-YY_BUFFER_STATE yy_create_buffer( file, size )
-FILE *file;
-int size;
-#endif
-       {
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
+{
        YY_BUFFER_STATE b;
-
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+    
+       b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
@@ -2165,80 +2210,75 @@ int 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 *) yy_flex_alloc( b->yy_buf_size + 2 );
+       b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
        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 );
+       yy_init_buffer(b,file );
 
        return b;
-       }
-
+}
 
-#ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
-#else
-void yy_delete_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-       {
+/** Destroy the buffer.
+ * @param b a buffer created with yy_create_buffer()
+ * 
+ */
+    void yy_delete_buffer (YY_BUFFER_STATE  b )
+{
+    
        if ( ! b )
                return;
 
-       if ( b == yy_current_buffer )
-               yy_current_buffer = (YY_BUFFER_STATE) 0;
+       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 )
-               yy_flex_free( (void *) b->yy_ch_buf );
-
-       yy_flex_free( (void *) b );
-       }
-
+               yyfree((void *) b->yy_ch_buf  );
 
-#ifndef YY_ALWAYS_INTERACTIVE
-#ifndef YY_NEVER_INTERACTIVE
-extern int isatty YY_PROTO(( int ));
-#endif
-#endif
-
-#ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
-#else
-void yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
-FILE *file;
-#endif
+       yyfree((void *) b  );
+}
 
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
+/* 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 )
 
-       {
-       yy_flush_buffer( b );
+{
+       int oerrno = errno;
+    
+       yy_flush_buffer(b );
 
        b->yy_input_file = file;
        b->yy_fill_buffer = 1;
 
-#if YY_ALWAYS_INTERACTIVE
-       b->yy_is_interactive = 1;
-#else
-#if YY_NEVER_INTERACTIVE
-       b->yy_is_interactive = 0;
-#else
-       b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-#endif
-#endif
-       }
-
-
-#ifdef YY_USE_PROTOS
-void yy_flush_buffer( YY_BUFFER_STATE b )
-#else
-void yy_flush_buffer( b )
-YY_BUFFER_STATE b;
-#endif
+    /* 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;
+}
 
-       {
-       if ( ! b )
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void yy_flush_buffer (YY_BUFFER_STATE  b )
+{
+       if ( ! b )
                return;
 
        b->yy_n_chars = 0;
@@ -2255,29 +2295,121 @@ YY_BUFFER_STATE b;
        b->yy_at_bol = 1;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       if ( b == yy_current_buffer )
-               yy_load_buffer_state();
+       if ( b == YY_CURRENT_BUFFER )
+               yy_load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+       if (new_buffer == NULL)
+               return;
+
+       yyensure_buffer_stack();
+
+       /* This block is copied from yy_switch_to_buffer. */
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       /* Only push if top exists. Otherwise, replace top. */
+       if (YY_CURRENT_BUFFER)
+               (yy_buffer_stack_top)++;
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+       /* copied from yy_switch_to_buffer. */
+       yy_load_buffer_state( );
+       (yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void yypop_buffer_state (void)
+{
+       if (!YY_CURRENT_BUFFER)
+               return;
+
+       yy_delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
+
+       if (YY_CURRENT_BUFFER) {
+               yy_load_buffer_state( );
+               (yy_did_buffer_switch_on_eof) = 1;
        }
+}
 
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void yyensure_buffer_stack (void)
+{
+       int num_to_alloc;
+    
+       if (!(yy_buffer_stack)) {
+
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate realloc on the next call.
+         */
+               num_to_alloc = 1;
+               (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               
+               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               (yy_buffer_stack_max) = num_to_alloc;
+               (yy_buffer_stack_top) = 0;
+               return;
+       }
 
-#ifndef YY_NO_SCAN_BUFFER
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
-#else
-YY_BUFFER_STATE yy_scan_buffer( base, size )
-char *base;
-yy_size_t size;
-#endif
-       {
-       YY_BUFFER_STATE b;
+       if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+
+               /* zero only the new slots.*/
+               memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+               (yy_buffer_stack_max) = num_to_alloc;
+       }
+}
 
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object. 
+ */
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
+{
+       YY_BUFFER_STATE b;
+    
        if ( size < 2 ||
             base[size-2] != YY_END_OF_BUFFER_CHAR ||
             base[size-1] != YY_END_OF_BUFFER_CHAR )
                /* They forgot to leave room for the EOB's. */
                return 0;
 
-       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+       b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 
@@ -2291,56 +2423,51 @@ yy_size_t size;
        b->yy_fill_buffer = 0;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       yy_switch_to_buffer( b );
+       yy_switch_to_buffer( );
 
        return b;
-       }
-#endif
-
-
-#ifndef YY_NO_SCAN_STRING
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
-#else
-YY_BUFFER_STATE yy_scan_string( yy_str )
-yyconst char *yy_str;
-#endif
-       {
-       int len;
-       for ( len = 0; yy_str[len]; ++len )
-               ;
-
-       return yy_scan_bytes( yy_str, len );
-       }
-#endif
+}
 
+/** Setup the input buffer state to scan a string. The next call to yylex() will
+ * scan from a @e copy of @a str.
+ * @param str a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       yy_scan_bytes() instead.
+ */
+YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
+{
+    
+       return yy_scan_bytes(yystr,strlen(yystr) );
+}
 
-#ifndef YY_NO_SCAN_BYTES
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
-#else
-YY_BUFFER_STATE yy_scan_bytes( bytes, len )
-yyconst char *bytes;
-int len;
-#endif
-       {
+/** 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 bytes the byte buffer to scan
+ * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
+{
        YY_BUFFER_STATE b;
        char *buf;
        yy_size_t n;
        int i;
-
+    
        /* Get memory for full buffer, including space for trailing EOB's. */
-       n = len + 2;
-       buf = (char *) yy_flex_alloc( n );
+       n = _yybytes_len + 2;
+       buf = (char *) yyalloc(n  );
        if ( ! buf )
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 
-       for ( i = 0; i < len; ++i )
-               buf[i] = bytes[i];
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
 
-       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-       b = yy_scan_buffer( buf, n );
+       b = yy_scan_buffer(buf,n );
        if ( ! b )
                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
@@ -2350,148 +2477,196 @@ int len;
        b->yy_is_our_buffer = 1;
 
        return b;
-       }
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
 #endif
 
+static void yy_fatal_error (yyconst char* msg )
+{
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
+}
 
-#ifndef YY_NO_PUSH_STATE
-#ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
-#else
-static void yy_push_state( new_state )
-int new_state;
-#endif
-       {
-       if ( yy_start_stack_ptr >= yy_start_stack_depth )
-               {
-               yy_size_t new_size;
+/* Redefine yyless() so it works in section 3 code. */
 
-               yy_start_stack_depth += YY_START_STACK_INCR;
-               new_size = yy_start_stack_depth * sizeof( int );
+#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] = (yy_hold_char); \
+               (yy_c_buf_p) = yytext + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               yyleng = yyless_macro_arg; \
+               } \
+       while ( 0 )
 
-               if ( ! yy_start_stack )
-                       yy_start_stack = (int *) yy_flex_alloc( new_size );
+/* Accessor  methods (get/set functions) to struct members. */
 
-               else
-                       yy_start_stack = (int *) yy_flex_realloc(
-                                       (void *) yy_start_stack, new_size );
+/** Get the current line number.
+ * 
+ */
+int yyget_lineno  (void)
+{
+        
+    return yylineno;
+}
 
-               if ( ! yy_start_stack )
-                       YY_FATAL_ERROR(
-                       "out of memory expanding start-condition stack" );
-               }
+/** Get the input stream.
+ * 
+ */
+FILE *yyget_in  (void)
+{
+        return yyin;
+}
 
-       yy_start_stack[yy_start_stack_ptr++] = YY_START;
+/** Get the output stream.
+ * 
+ */
+FILE *yyget_out  (void)
+{
+        return yyout;
+}
 
-       BEGIN(new_state);
-       }
-#endif
+/** Get the length of the current token.
+ * 
+ */
+int yyget_leng  (void)
+{
+        return yyleng;
+}
 
+/** Get the current token.
+ * 
+ */
 
-#ifndef YY_NO_POP_STATE
-static void yy_pop_state()
-       {
-       if ( --yy_start_stack_ptr < 0 )
-               YY_FATAL_ERROR( "start-condition stack underflow" );
+char *yyget_text  (void)
+{
+        return yytext;
+}
 
-       BEGIN(yy_start_stack[yy_start_stack_ptr]);
-       }
-#endif
+/** Set the current line number.
+ * @param line_number
+ * 
+ */
+void yyset_lineno (int  line_number )
+{
+    
+    yylineno = line_number;
+}
 
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * 
+ * @see yy_switch_to_buffer
+ */
+void yyset_in (FILE *  in_str )
+{
+        yyin = in_str ;
+}
 
-#ifndef YY_NO_TOP_STATE
-static int yy_top_state()
-       {
-       return yy_start_stack[yy_start_stack_ptr - 1];
-       }
-#endif
+void yyset_out (FILE *  out_str )
+{
+        yyout = out_str ;
+}
 
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
+int yyget_debug  (void)
+{
+        return yy_flex_debug;
+}
 
-#ifdef YY_USE_PROTOS
-static void yy_fatal_error( yyconst char msg[] )
+void yyset_debug (int  bdebug )
+{
+        yy_flex_debug = bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from yylex_destroy(), so don't allocate here.
+     */
+
+    (yy_buffer_stack) = 0;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = (char *) 0;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    yyin = stdin;
+    yyout = stdout;
 #else
-static void yy_fatal_error( msg )
-char msg[];
+    yyin = (FILE *) 0;
+    yyout = (FILE *) 0;
 #endif
-       {
-       (void) fprintf( stderr, "%s\n", msg );
-       exit( YY_EXIT_FAILURE );
-       }
 
+    /* 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  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+       while(YY_CURRENT_BUFFER){
+               yy_delete_buffer(YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               yypop_buffer_state();
+       }
 
-/* Redefine yyless() so it works in section 3 code. */
+       /* Destroy the stack itself. */
+       yyfree((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;
 
-#undef yyless
-#define yyless(n) \
-       do \
-               { \
-               /* Undo effects of setting up yytext. */ \
-               yytext[yyleng] = yy_hold_char; \
-               yy_c_buf_p = yytext + n; \
-               yy_hold_char = *yy_c_buf_p; \
-               *yy_c_buf_p = '\0'; \
-               yyleng = n; \
-               } \
-       while ( 0 )
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * yylex() is called, initialization will occur. */
+    yy_init_globals( );
 
+    return 0;
+}
 
-/* Internal utility routines. */
+/*
+ * Internal utility routines.
+ */
 
 #ifndef yytext_ptr
-#ifdef YY_USE_PROTOS
-static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
-#else
-static void yy_flex_strncpy( s1, s2, n )
-char *s1;
-yyconst char *s2;
-int n;
-#endif
-       {
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+{
        register int i;
        for ( i = 0; i < n; ++i )
                s1[i] = s2[i];
-       }
+}
 #endif
 
 #ifdef YY_NEED_STRLEN
-#ifdef YY_USE_PROTOS
-static int yy_flex_strlen( yyconst char *s )
-#else
-static int yy_flex_strlen( s )
-yyconst char *s;
-#endif
-       {
+static int yy_flex_strlen (yyconst char * s )
+{
        register int n;
        for ( n = 0; s[n]; ++n )
                ;
 
        return n;
-       }
+}
 #endif
 
-
-#ifdef YY_USE_PROTOS
-static void *yy_flex_alloc( yy_size_t size )
-#else
-static void *yy_flex_alloc( size )
-yy_size_t size;
-#endif
-       {
+void *yyalloc (yy_size_t  size )
+{
        return (void *) malloc( size );
-       }
+}
 
-#ifdef YY_USE_PROTOS
-static void *yy_flex_realloc( void *ptr, yy_size_t size )
-#else
-static void *yy_flex_realloc( ptr, size )
-void *ptr;
-yy_size_t size;
-#endif
-       {
+void *yyrealloc  (void * ptr, yy_size_t  size )
+{
        /* The cast to (char *) in the following accommodates both
         * implementations that use char* generic pointers, and those
         * that use void* generic pointers.  It works with the latter
@@ -2500,24 +2675,16 @@ yy_size_t size;
         * as though doing an assignment.
         */
        return (void *) realloc( (char *) ptr, size );
-       }
+}
+
+void yyfree (void * ptr )
+{
+       free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 219 "util/configlexer.lex"
 
-#ifdef YY_USE_PROTOS
-static void yy_flex_free( void *ptr )
-#else
-static void yy_flex_free( ptr )
-void *ptr;
-#endif
-       {
-       free( ptr );
-       }
 
-#if YY_MAIN
-int main()
-       {
-       yylex();
-       return 0;
-       }
-#endif
-#line 218 "util/configlexer.lex"
 
index 88b5fa5c790625a11233db2dbac4195b51f82f90..54130cd268194d3cf1e17437b3ef2bd708f86e70 100644 (file)
@@ -117,6 +117,7 @@ username{COLON}             { YDOUT; return VAR_USERNAME;}
 directory{COLON}       { YDOUT; return VAR_DIRECTORY;}
 logfile{COLON}         { YDOUT; return VAR_LOGFILE;}
 pidfile{COLON}         { YDOUT; return VAR_PIDFILE;}
+root-hints{COLON}      { YDOUT; return VAR_ROOT_HINTS;}
 msg-buffer-size{COLON} { YDOUT; return VAR_MSG_BUFFER_SIZE;}
 msg-cache-size{COLON}  { YDOUT; return VAR_MSG_CACHE_SIZE;}
 msg-cache-slabs{COLON} { YDOUT; return VAR_MSG_CACHE_SLABS;}
index 7e13b5a6a3cb0894af87fbcbfd6efb927971fdec..cb331b425ecfd9ec43b0e251ff77a62965d08d0c 100644 (file)
      VAR_TRUSTED_KEYS_FILE = 320,
      VAR_VAL_NSEC3_KEYSIZE_ITERATIONS = 321,
      VAR_USE_SYSLOG = 322,
-     VAR_OUTGOING_INTERFACE = 323
+     VAR_OUTGOING_INTERFACE = 323,
+     VAR_ROOT_HINTS = 324
    };
 #endif
 /* Tokens.  */
 #define VAR_VAL_NSEC3_KEYSIZE_ITERATIONS 321
 #define VAR_USE_SYSLOG 322
 #define VAR_OUTGOING_INTERFACE 323
+#define VAR_ROOT_HINTS 324
 
 
 
@@ -259,7 +261,7 @@ typedef union YYSTYPE
        char*   str;
 }
 /* Line 187 of yacc.c.  */
-#line 263 "util/configparser.c"
+#line 265 "util/configparser.c"
        YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
@@ -272,7 +274,7 @@ typedef union YYSTYPE
 
 
 /* Line 216 of yacc.c.  */
-#line 276 "util/configparser.c"
+#line 278 "util/configparser.c"
 
 #ifdef short
 # undef short
@@ -487,20 +489,20 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  2
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   115
+#define YYLAST   117
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  69
+#define YYNTOKENS  70
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  68
+#define YYNNTS  69
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  127
+#define YYNRULES  129
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  184
+#define YYNSTATES  187
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   323
+#define YYMAXUTOK   324
 
 #define YYTRANSLATE(YYX)                                               \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -540,7 +542,7 @@ static const yytype_uint8 yytranslate[] =
       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68
+      65,    66,    67,    68,    69
 };
 
 #if YYDEBUG
@@ -554,50 +556,50 @@ static const yytype_uint16 yyprhs[] =
       62,    64,    66,    68,    70,    72,    74,    76,    78,    80,
       82,    84,    86,    88,    90,    92,    94,    96,    98,   100,
      102,   104,   106,   108,   110,   112,   114,   116,   118,   120,
-     122,   124,   127,   128,   130,   132,   134,   136,   139,   140,
-     142,   144,   146,   149,   152,   155,   158,   161,   164,   167,
-     170,   173,   176,   179,   182,   185,   188,   191,   194,   197,
-     200,   203,   206,   209,   212,   215,   218,   221,   224,   227,
-     230,   233,   236,   239,   242,   245,   248,   251,   254,   257,
-     260,   263,   266,   269,   272,   275,   278,   281,   284,   287,
-     290,   293,   296,   299,   302,   305,   308,   311
+     122,   124,   126,   129,   130,   132,   134,   136,   138,   141,
+     142,   144,   146,   148,   151,   154,   157,   160,   163,   166,
+     169,   172,   175,   178,   181,   184,   187,   190,   193,   196,
+     199,   202,   205,   208,   211,   214,   217,   220,   223,   226,
+     229,   232,   235,   238,   241,   244,   247,   250,   253,   256,
+     259,   262,   265,   268,   271,   274,   277,   280,   283,   286,
+     289,   292,   295,   298,   301,   304,   307,   310,   313,   316
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int16 yyrhs[] =
 {
-      70,     0,    -1,    -1,    70,    71,    -1,    72,    73,    -1,
-      75,    76,    -1,    78,    79,    -1,    11,    -1,    73,    74,
-      -1,    -1,    81,    -1,    82,    -1,    83,    -1,    86,    -1,
-      87,    -1,    90,    -1,    91,    -1,    92,    -1,    93,    -1,
-      84,    -1,    95,    -1,    96,    -1,    97,    -1,    98,    -1,
-      99,    -1,   108,    -1,   109,    -1,   110,    -1,   111,    -1,
-     112,    -1,    88,    -1,   113,    -1,   114,    -1,   117,    -1,
-     115,    -1,   116,    -1,   118,    -1,   119,    -1,   120,    -1,
-     122,    -1,   103,    -1,   104,    -1,   105,    -1,   106,    -1,
-     121,    -1,   123,    -1,   100,    -1,   102,    -1,   124,    -1,
-     125,    -1,   126,    -1,   127,    -1,    89,    -1,   107,    -1,
-     129,    -1,   130,    -1,   101,    -1,   128,    -1,    94,    -1,
-      85,    -1,    39,    -1,    76,    77,    -1,    -1,   131,    -1,
-     132,    -1,   133,    -1,    45,    -1,    79,    80,    -1,    -1,
-     134,    -1,   135,    -1,   136,    -1,    13,    10,    -1,    12,
-      10,    -1,    14,    10,    -1,    17,    10,    -1,    68,    10,
-      -1,    15,    10,    -1,    16,    10,    -1,    32,    10,    -1,
-      61,    10,    -1,    18,    10,    -1,    19,    10,    -1,    20,
-      10,    -1,    21,    10,    -1,    67,    10,    -1,    22,    10,
-      -1,    23,    10,    -1,    24,    10,    -1,    25,    10,    -1,
-      26,    10,    -1,    55,    10,    -1,    65,    10,    -1,    56,
-      10,    -1,    49,    10,    -1,    50,    10,    -1,    51,    10,
-      -1,    52,    10,    -1,    62,    10,    -1,    27,    10,    -1,
-      28,    10,    -1,    29,    10,    -1,    30,    10,    -1,    31,
-      10,    -1,    33,    10,    -1,    34,    10,    -1,    36,    10,
-      -1,    37,    10,    -1,    35,    10,    -1,    42,    10,    -1,
-      43,    10,    -1,    44,    10,    -1,    53,    10,    -1,    48,
-      10,    -1,    54,    10,    -1,    57,    10,    -1,    58,    10,
-      -1,    59,    10,    -1,    60,    10,    -1,    66,    10,    -1,
-      63,    10,    -1,    64,    10,    -1,    38,    10,    -1,    40,
-      10,    -1,    41,    10,    -1,    38,    10,    -1,    46,    10,
-      -1,    47,    10,    -1
+      71,     0,    -1,    -1,    71,    72,    -1,    73,    74,    -1,
+      76,    77,    -1,    79,    80,    -1,    11,    -1,    74,    75,
+      -1,    -1,    82,    -1,    83,    -1,    84,    -1,    87,    -1,
+      88,    -1,    91,    -1,    92,    -1,    93,    -1,    94,    -1,
+      85,    -1,    96,    -1,    97,    -1,    98,    -1,    99,    -1,
+     100,    -1,   110,    -1,   111,    -1,   112,    -1,   113,    -1,
+     114,    -1,    89,    -1,   115,    -1,   116,    -1,   119,    -1,
+     117,    -1,   118,    -1,   120,    -1,   121,    -1,   122,    -1,
+     124,    -1,   105,    -1,   106,    -1,   107,    -1,   108,    -1,
+     123,    -1,   125,    -1,   102,    -1,   104,    -1,   126,    -1,
+     127,    -1,   128,    -1,   129,    -1,    90,    -1,   109,    -1,
+     131,    -1,   132,    -1,   103,    -1,   130,    -1,    95,    -1,
+      86,    -1,   101,    -1,    39,    -1,    77,    78,    -1,    -1,
+     133,    -1,   134,    -1,   135,    -1,    45,    -1,    80,    81,
+      -1,    -1,   136,    -1,   137,    -1,   138,    -1,    13,    10,
+      -1,    12,    10,    -1,    14,    10,    -1,    17,    10,    -1,
+      68,    10,    -1,    15,    10,    -1,    16,    10,    -1,    32,
+      10,    -1,    61,    10,    -1,    18,    10,    -1,    19,    10,
+      -1,    20,    10,    -1,    21,    10,    -1,    67,    10,    -1,
+      22,    10,    -1,    23,    10,    -1,    24,    10,    -1,    25,
+      10,    -1,    26,    10,    -1,    69,    10,    -1,    55,    10,
+      -1,    65,    10,    -1,    56,    10,    -1,    49,    10,    -1,
+      50,    10,    -1,    51,    10,    -1,    52,    10,    -1,    62,
+      10,    -1,    27,    10,    -1,    28,    10,    -1,    29,    10,
+      -1,    30,    10,    -1,    31,    10,    -1,    33,    10,    -1,
+      34,    10,    -1,    36,    10,    -1,    37,    10,    -1,    35,
+      10,    -1,    42,    10,    -1,    43,    10,    -1,    44,    10,
+      -1,    53,    10,    -1,    48,    10,    -1,    54,    10,    -1,
+      57,    10,    -1,    58,    10,    -1,    59,    10,    -1,    60,
+      10,    -1,    66,    10,    -1,    63,    10,    -1,    64,    10,
+      -1,    38,    10,    -1,    40,    10,    -1,    41,    10,    -1,
+      38,    10,    -1,    46,    10,    -1,    47,    10,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
@@ -609,13 +611,13 @@ static const yytype_uint16 yyrline[] =
      111,   112,   112,   113,   113,   114,   114,   115,   115,   116,
      116,   117,   117,   117,   118,   118,   118,   119,   119,   119,
      120,   120,   121,   121,   122,   122,   123,   123,   124,   124,
-     126,   138,   139,   140,   140,   140,   142,   154,   155,   156,
-     156,   156,   158,   167,   176,   185,   198,   213,   222,   231,
-     240,   249,   258,   267,   276,   285,   299,   306,   313,   320,
-     328,   335,   343,   351,   358,   367,   376,   383,   390,   401,
-     410,   423,   432,   441,   454,   463,   472,   481,   490,   503,
-     510,   520,   530,   540,   547,   554,   572,   581,   591,   601,
-     608,   617,   630,   637,   644,   651,   658,   665
+     124,   126,   138,   139,   140,   140,   140,   142,   154,   155,
+     156,   156,   156,   158,   167,   176,   185,   198,   213,   222,
+     231,   240,   249,   258,   267,   276,   285,   299,   306,   313,
+     320,   328,   335,   342,   350,   358,   365,   374,   383,   390,
+     397,   408,   417,   430,   439,   448,   461,   470,   479,   488,
+     497,   510,   517,   527,   537,   547,   554,   561,   579,   588,
+     598,   608,   615,   624,   637,   644,   651,   658,   665,   672
 };
 #endif
 
@@ -644,27 +646,28 @@ static const char *const yytname[] =
   "VAR_VAL_PERMISSIVE_MODE", "VAR_INCOMING_NUM_TCP", "VAR_MSG_BUFFER_SIZE",
   "VAR_KEY_CACHE_SIZE", "VAR_KEY_CACHE_SLABS", "VAR_TRUSTED_KEYS_FILE",
   "VAR_VAL_NSEC3_KEYSIZE_ITERATIONS", "VAR_USE_SYSLOG",
-  "VAR_OUTGOING_INTERFACE", "$accept", "toplevelvars", "toplevelvar",
-  "serverstart", "contents_server", "content_server", "stubstart",
-  "contents_stub", "content_stub", "forwardstart", "contents_forward",
-  "content_forward", "server_num_threads", "server_verbosity",
-  "server_port", "server_interface", "server_outgoing_interface",
-  "server_outgoing_port", "server_outgoing_range",
-  "server_outgoing_num_tcp", "server_incoming_num_tcp", "server_do_ip4",
-  "server_do_ip6", "server_do_udp", "server_do_tcp", "server_use_syslog",
-  "server_chroot", "server_username", "server_directory", "server_logfile",
-  "server_pidfile", "server_trust_anchor_file", "server_trusted_keys_file",
-  "server_trust_anchor", "server_hide_identity", "server_hide_version",
-  "server_identity", "server_version", "server_msg_buffer_size",
-  "server_msg_cache_size", "server_msg_cache_slabs",
-  "server_num_queries_per_thread", "server_rrset_cache_size",
-  "server_rrset_cache_slabs", "server_infra_host_ttl",
-  "server_infra_lame_ttl", "server_infra_cache_numhosts",
-  "server_infra_cache_lame_size", "server_infra_cache_slabs",
-  "server_target_fetch_policy", "server_harden_short_bufsize",
-  "server_harden_large_queries", "server_harden_glue",
-  "server_do_not_query_address", "server_module_conf",
-  "server_val_override_date", "server_bogus_ttl",
+  "VAR_OUTGOING_INTERFACE", "VAR_ROOT_HINTS", "$accept", "toplevelvars",
+  "toplevelvar", "serverstart", "contents_server", "content_server",
+  "stubstart", "contents_stub", "content_stub", "forwardstart",
+  "contents_forward", "content_forward", "server_num_threads",
+  "server_verbosity", "server_port", "server_interface",
+  "server_outgoing_interface", "server_outgoing_port",
+  "server_outgoing_range", "server_outgoing_num_tcp",
+  "server_incoming_num_tcp", "server_do_ip4", "server_do_ip6",
+  "server_do_udp", "server_do_tcp", "server_use_syslog", "server_chroot",
+  "server_username", "server_directory", "server_logfile",
+  "server_pidfile", "server_root_hints", "server_trust_anchor_file",
+  "server_trusted_keys_file", "server_trust_anchor",
+  "server_hide_identity", "server_hide_version", "server_identity",
+  "server_version", "server_msg_buffer_size", "server_msg_cache_size",
+  "server_msg_cache_slabs", "server_num_queries_per_thread",
+  "server_rrset_cache_size", "server_rrset_cache_slabs",
+  "server_infra_host_ttl", "server_infra_lame_ttl",
+  "server_infra_cache_numhosts", "server_infra_cache_lame_size",
+  "server_infra_cache_slabs", "server_target_fetch_policy",
+  "server_harden_short_bufsize", "server_harden_large_queries",
+  "server_harden_glue", "server_do_not_query_address",
+  "server_module_conf", "server_val_override_date", "server_bogus_ttl",
   "server_val_clean_additional", "server_val_permissive_mode",
   "server_val_nsec3_keysize_iterations", "server_key_cache_size",
   "server_key_cache_slabs", "stub_name", "stub_host", "stub_addr",
@@ -683,26 +686,26 @@ static const yytype_uint16 yytoknum[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,   318,   319,   320,   321,   322,   323
+     315,   316,   317,   318,   319,   320,   321,   322,   323,   324
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,    69,    70,    70,    71,    71,    71,    72,    73,    73,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      74,    74,    74,    74,    74,    74,    74,    74,    74,    74,
-      75,    76,    76,    77,    77,    77,    78,    79,    79,    80,
-      80,    80,    81,    82,    83,    84,    85,    86,    87,    88,
+       0,    70,    71,    71,    72,    72,    72,    73,    74,    74,
+      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
+      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
+      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
+      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
+      75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
+      75,    76,    77,    77,    78,    78,    78,    79,    80,    80,
+      81,    81,    81,    82,    83,    84,    85,    86,    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,   112,   113,   114,   115,   116,   117,   118,
      119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,   132,   133,   134,   135,   136
+     129,   130,   131,   132,   133,   134,   135,   136,   137,   138
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -714,13 +717,13 @@ static const yytype_uint8 yyr2[] =
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     2,     0,     1,     1,     1,     1,     2,     0,     1,
-       1,     1,     2,     2,     2,     2,     2,     2,     2,     2,
+       1,     1,     2,     0,     1,     1,     1,     1,     2,     0,
+       1,     1,     1,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2
 };
 
 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@@ -728,37 +731,37 @@ static const yytype_uint8 yyr2[] =
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       2,     0,     1,     7,    60,    66,     3,     9,    62,    68,
+       2,     0,     1,     7,    61,    67,     3,     9,    63,    69,
        4,     5,     6,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     8,    10,    11,    12,    19,    59,    13,
-      14,    30,    52,    15,    16,    17,    18,    58,    20,    21,
-      22,    23,    24,    46,    56,    47,    40,    41,    42,    43,
-      53,    25,    26,    27,    28,    29,    31,    32,    34,    35,
-      33,    36,    37,    38,    44,    39,    45,    48,    49,    50,
-      51,    57,    54,    55,     0,     0,     0,    61,    63,    64,
-      65,     0,     0,     0,    67,    69,    70,    71,    73,    72,
-      74,    77,    78,    75,    81,    82,    83,    84,    86,    87,
-      88,    89,    90,    99,   100,   101,   102,   103,    79,   104,
-     105,   108,   106,   107,   109,   110,   111,   113,    94,    95,
-      96,    97,   112,   114,    91,    93,   115,   116,   117,   118,
-      80,    98,   120,   121,    92,   119,    85,    76,   122,   123,
-     124,   125,   126,   127
+       0,     0,     0,     0,     8,    10,    11,    12,    19,    59,
+      13,    14,    30,    52,    15,    16,    17,    18,    58,    20,
+      21,    22,    23,    24,    60,    46,    56,    47,    40,    41,
+      42,    43,    53,    25,    26,    27,    28,    29,    31,    32,
+      34,    35,    33,    36,    37,    38,    44,    39,    45,    48,
+      49,    50,    51,    57,    54,    55,     0,     0,     0,    62,
+      64,    65,    66,     0,     0,     0,    68,    70,    71,    72,
+      74,    73,    75,    78,    79,    76,    82,    83,    84,    85,
+      87,    88,    89,    90,    91,   101,   102,   103,   104,   105,
+      80,   106,   107,   110,   108,   109,   111,   112,   113,   115,
+      96,    97,    98,    99,   114,   116,    93,    95,   117,   118,
+     119,   120,    81,   100,   122,   123,    94,   121,    86,    77,
+      92,   124,   125,   126,   127,   128,   129
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int8 yydefgoto[] =
+static const yytype_int16 yydefgoto[] =
 {
-      -1,     1,     6,     7,    10,    63,     8,    11,   117,     9,
-      12,   124,    64,    65,    66,    67,    68,    69,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    85,    86,    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,
-     112,   113,   118,   119,   120,   125,   126,   127
+      -1,     1,     6,     7,    10,    64,     8,    11,   119,     9,
+      12,   126,    65,    66,    67,    68,    69,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
+      83,    84,    85,    86,    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,   112,
+     113,   114,   115,   120,   121,   122,   127,   128,   129
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
@@ -766,25 +769,25 @@ static const yytype_int8 yydefgoto[] =
 #define YYPACT_NINF -13
 static const yytype_int8 yypact[] =
 {
-     -13,    57,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
-     -12,    21,    20,    16,    17,    18,    19,    23,    24,    25,
-      50,    53,    54,    55,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,    87,    88,    89,    90,    91,    93,    94,    95,    96,
-      97,    98,    99,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
+     -13,    58,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
+     -12,    22,    21,    16,    17,    18,    19,    23,    24,    25,
+      51,    54,    55,    56,    60,    61,    62,    63,    64,    65,
+      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    88,    89,    90,    91,    92,    94,    95,    96,    97,
+      98,    99,   100,   101,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
-     -13,   -13,   -13,   -13,   100,   101,   102,   -13,   -13,   -13,
-     -13,   103,   104,   105,   -13,   -13,   -13,   -13,   -13,   -13,
+     -13,   -13,   -13,   -13,   -13,   -13,   102,   103,   104,   -13,
+     -13,   -13,   -13,   105,   106,   107,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
-     -13,   -13,   -13,   -13
+     -13,   -13,   -13,   -13,   -13,   -13,   -13
 };
 
 /* YYPGOTO[NTERM-NUM].  */
@@ -796,7 +799,7 @@ static const yytype_int8 yypgoto[] =
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
      -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,
-     -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13
+     -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13,   -13
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
@@ -808,16 +811,16 @@ static const yytype_uint8 yytable[] =
 {
       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,   128,   129,   130,   131,
-      39,    40,    41,   132,   133,   134,    42,    43,    44,    45,
+      33,    34,    35,    36,    37,    38,   130,   131,   132,   133,
+      39,    40,    41,   134,   135,   136,    42,    43,    44,    45,
       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    57,    58,    59,    60,    61,    62,     2,   121,   114,
-     135,   115,   116,   136,   137,   138,   122,   123,     3,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150,   151,   152,   153,   154,   155,   156,   157,   158,   159,
-     160,   161,   162,   163,   164,   165,     4,   166,   167,   168,
-     169,   170,     5,   171,   172,   173,   174,   175,   176,   177,
-     178,   179,   180,   181,   182,   183
+      56,    57,    58,    59,    60,    61,    62,    63,     2,   123,
+     116,   137,   117,   118,   138,   139,   140,   124,   125,     3,
+     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
+     151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
+     161,   162,   163,   164,   165,   166,   167,     4,   168,   169,
+     170,   171,   172,     5,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,   182,   183,   184,   185,   186
 };
 
 static const yytype_uint8 yycheck[] =
@@ -827,38 +830,38 @@ static const yytype_uint8 yycheck[] =
       32,    33,    34,    35,    36,    37,    10,    10,    10,    10,
       42,    43,    44,    10,    10,    10,    48,    49,    50,    51,
       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
-      62,    63,    64,    65,    66,    67,    68,     0,    38,    38,
-      10,    40,    41,    10,    10,    10,    46,    47,    11,    10,
+      62,    63,    64,    65,    66,    67,    68,    69,     0,    38,
+      38,    10,    40,    41,    10,    10,    10,    46,    47,    11,
       10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
       10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
-      10,    10,    10,    10,    10,    10,    39,    10,    10,    10,
-      10,    10,    45,    10,    10,    10,    10,    10,    10,    10,
-      10,    10,    10,    10,    10,    10
+      10,    10,    10,    10,    10,    10,    10,    39,    10,    10,
+      10,    10,    10,    45,    10,    10,    10,    10,    10,    10,
+      10,    10,    10,    10,    10,    10,    10,    10
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 static const yytype_uint8 yystos[] =
 {
-       0,    70,     0,    11,    39,    45,    71,    72,    75,    78,
-      73,    76,    79,    12,    13,    14,    15,    16,    17,    18,
+       0,    71,     0,    11,    39,    45,    72,    73,    76,    79,
+      74,    77,    80,    12,    13,    14,    15,    16,    17,    18,
       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
       29,    30,    31,    32,    33,    34,    35,    36,    37,    42,
       43,    44,    48,    49,    50,    51,    52,    53,    54,    55,
       56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
-      66,    67,    68,    74,    81,    82,    83,    84,    85,    86,
+      66,    67,    68,    69,    75,    82,    83,    84,    85,    86,
       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,   112,   113,   114,   115,   116,
      117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,    38,    40,    41,    77,   131,   132,
-     133,    38,    46,    47,    80,   134,   135,   136,    10,    10,
+     127,   128,   129,   130,   131,   132,    38,    40,    41,    78,
+     133,   134,   135,    38,    46,    47,    81,   136,   137,   138,
       10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
       10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
       10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
       10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
       10,    10,    10,    10,    10,    10,    10,    10,    10,    10,
-      10,    10,    10,    10
+      10,    10,    10,    10,    10,    10,    10
 };
 
 #define yyerrok                (yyerrstatus = 0)
@@ -1679,7 +1682,7 @@ yyreduce:
        }
     break;
 
-  case 60:
+  case 61:
 #line 127 "util/configparser.y"
     {
                struct config_stub* s;
@@ -1693,7 +1696,7 @@ yyreduce:
        }
     break;
 
-  case 66:
+  case 67:
 #line 143 "util/configparser.y"
     {
                struct config_stub* s;
@@ -1707,7 +1710,7 @@ yyreduce:
        }
     break;
 
-  case 72:
+  case 73:
 #line 159 "util/configparser.y"
     { 
                OUTYY(("P(server_num_threads:%s)\n", (yyvsp[(2) - (2)].str))); 
@@ -1718,7 +1721,7 @@ yyreduce:
        }
     break;
 
-  case 73:
+  case 74:
 #line 168 "util/configparser.y"
     { 
                OUTYY(("P(server_verbosity:%s)\n", (yyvsp[(2) - (2)].str))); 
@@ -1729,7 +1732,7 @@ yyreduce:
        }
     break;
 
-  case 74:
+  case 75:
 #line 177 "util/configparser.y"
     {
                OUTYY(("P(server_port:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1740,7 +1743,7 @@ yyreduce:
        }
     break;
 
-  case 75:
+  case 76:
 #line 186 "util/configparser.y"
     {
                OUTYY(("P(server_interface:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1755,7 +1758,7 @@ yyreduce:
        }
     break;
 
-  case 76:
+  case 77:
 #line 199 "util/configparser.y"
     {
                OUTYY(("P(server_outgoing_interface:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1772,7 +1775,7 @@ yyreduce:
        }
     break;
 
-  case 77:
+  case 78:
 #line 214 "util/configparser.y"
     {
                OUTYY(("P(server_outgoing_port:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1783,7 +1786,7 @@ yyreduce:
        }
     break;
 
-  case 78:
+  case 79:
 #line 223 "util/configparser.y"
     {
                OUTYY(("P(server_outgoing_range:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1794,7 +1797,7 @@ yyreduce:
        }
     break;
 
-  case 79:
+  case 80:
 #line 232 "util/configparser.y"
     {
                OUTYY(("P(server_outgoing_num_tcp:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1805,7 +1808,7 @@ yyreduce:
        }
     break;
 
-  case 80:
+  case 81:
 #line 241 "util/configparser.y"
     {
                OUTYY(("P(server_incoming_num_tcp:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1816,7 +1819,7 @@ yyreduce:
        }
     break;
 
-  case 81:
+  case 82:
 #line 250 "util/configparser.y"
     {
                OUTYY(("P(server_do_ip4:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1827,7 +1830,7 @@ yyreduce:
        }
     break;
 
-  case 82:
+  case 83:
 #line 259 "util/configparser.y"
     {
                OUTYY(("P(server_do_ip6:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1838,7 +1841,7 @@ yyreduce:
        }
     break;
 
-  case 83:
+  case 84:
 #line 268 "util/configparser.y"
     {
                OUTYY(("P(server_do_udp:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1849,7 +1852,7 @@ yyreduce:
        }
     break;
 
-  case 84:
+  case 85:
 #line 277 "util/configparser.y"
     {
                OUTYY(("P(server_do_tcp:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1860,7 +1863,7 @@ yyreduce:
        }
     break;
 
-  case 85:
+  case 86:
 #line 286 "util/configparser.y"
     {
                OUTYY(("P(server_use_syslog:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1876,7 +1879,7 @@ yyreduce:
        }
     break;
 
-  case 86:
+  case 87:
 #line 300 "util/configparser.y"
     {
                OUTYY(("P(server_chroot:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1885,7 +1888,7 @@ yyreduce:
        }
     break;
 
-  case 87:
+  case 88:
 #line 307 "util/configparser.y"
     {
                OUTYY(("P(server_username:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1894,7 +1897,7 @@ yyreduce:
        }
     break;
 
-  case 88:
+  case 89:
 #line 314 "util/configparser.y"
     {
                OUTYY(("P(server_directory:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1903,7 +1906,7 @@ yyreduce:
        }
     break;
 
-  case 89:
+  case 90:
 #line 321 "util/configparser.y"
     {
                OUTYY(("P(server_logfile:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1913,7 +1916,7 @@ yyreduce:
        }
     break;
 
-  case 90:
+  case 91:
 #line 329 "util/configparser.y"
     {
                OUTYY(("P(server_pidfile:%s)\n", (yyvsp[(2) - (2)].str)));
@@ -1922,8 +1925,17 @@ yyreduce:
        }
     break;
 
-  case 91:
+  case 92:
 #line 336 "util/configparser.y"
+    {
+               OUTYY(("P(server_root_hints:%s)\n", (yyvsp[(2) - (2)].str)));
+               if(!cfg_strlist_insert(&cfg_parser->cfg->root_hints, (yyvsp[(2) - (2)].str)))
+                       yyerror("out of memory");
+       }
+    break;
+
+  case 93:
+#line 343 "util/configparser.y"
     {
                OUTYY(("P(server_trust_anchor_file:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->
@@ -1932,8 +1944,8 @@ yyreduce:
        }
     break;
 
-  case 92:
-#line 344 "util/configparser.y"
+  case 94:
+#line 351 "util/configparser.y"
     {
                OUTYY(("P(server_trusted_keys_file:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->
@@ -1942,8 +1954,8 @@ yyreduce:
        }
     break;
 
-  case 93:
-#line 352 "util/configparser.y"
+  case 95:
+#line 359 "util/configparser.y"
     {
                OUTYY(("P(server_trust_anchor:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->trust_anchor_list, (yyvsp[(2) - (2)].str)))
@@ -1951,8 +1963,8 @@ yyreduce:
        }
     break;
 
-  case 94:
-#line 359 "util/configparser.y"
+  case 96:
+#line 366 "util/configparser.y"
     {
                OUTYY(("P(server_hide_identity:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0)
@@ -1962,8 +1974,8 @@ yyreduce:
        }
     break;
 
-  case 95:
-#line 368 "util/configparser.y"
+  case 97:
+#line 375 "util/configparser.y"
     {
                OUTYY(("P(server_hide_version:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0)
@@ -1973,8 +1985,8 @@ yyreduce:
        }
     break;
 
-  case 96:
-#line 377 "util/configparser.y"
+  case 98:
+#line 384 "util/configparser.y"
     {
                OUTYY(("P(server_identity:%s)\n", (yyvsp[(2) - (2)].str)));
                free(cfg_parser->cfg->identity);
@@ -1982,8 +1994,8 @@ yyreduce:
        }
     break;
 
-  case 97:
-#line 384 "util/configparser.y"
+  case 99:
+#line 391 "util/configparser.y"
     {
                OUTYY(("P(server_version:%s)\n", (yyvsp[(2) - (2)].str)));
                free(cfg_parser->cfg->version);
@@ -1991,8 +2003,8 @@ yyreduce:
        }
     break;
 
-  case 98:
-#line 391 "util/configparser.y"
+  case 100:
+#line 398 "util/configparser.y"
     {
                OUTYY(("P(server_msg_buffer_size:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2004,8 +2016,8 @@ yyreduce:
        }
     break;
 
-  case 99:
-#line 402 "util/configparser.y"
+  case 101:
+#line 409 "util/configparser.y"
     {
                OUTYY(("P(server_msg_cache_size:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2015,8 +2027,8 @@ yyreduce:
        }
     break;
 
-  case 100:
-#line 411 "util/configparser.y"
+  case 102:
+#line 418 "util/configparser.y"
     {
                OUTYY(("P(server_msg_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2030,8 +2042,8 @@ yyreduce:
        }
     break;
 
-  case 101:
-#line 424 "util/configparser.y"
+  case 103:
+#line 431 "util/configparser.y"
     {
                OUTYY(("P(server_num_queries_per_thread:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2041,8 +2053,8 @@ yyreduce:
        }
     break;
 
-  case 102:
-#line 433 "util/configparser.y"
+  case 104:
+#line 440 "util/configparser.y"
     {
                OUTYY(("P(server_rrset_cache_size:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2052,8 +2064,8 @@ yyreduce:
        }
     break;
 
-  case 103:
-#line 442 "util/configparser.y"
+  case 105:
+#line 449 "util/configparser.y"
     {
                OUTYY(("P(server_rrset_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2067,8 +2079,8 @@ yyreduce:
        }
     break;
 
-  case 104:
-#line 455 "util/configparser.y"
+  case 106:
+#line 462 "util/configparser.y"
     {
                OUTYY(("P(server_infra_host_ttl:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0)
@@ -2078,8 +2090,8 @@ yyreduce:
        }
     break;
 
-  case 105:
-#line 464 "util/configparser.y"
+  case 107:
+#line 471 "util/configparser.y"
     {
                OUTYY(("P(server_infra_lame_ttl:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0)
@@ -2089,8 +2101,8 @@ yyreduce:
        }
     break;
 
-  case 106:
-#line 473 "util/configparser.y"
+  case 108:
+#line 480 "util/configparser.y"
     {
                OUTYY(("P(server_infra_cache_numhosts:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2100,8 +2112,8 @@ yyreduce:
        }
     break;
 
-  case 107:
-#line 482 "util/configparser.y"
+  case 109:
+#line 489 "util/configparser.y"
     {
                OUTYY(("P(server_infra_cache_lame_size:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2111,8 +2123,8 @@ yyreduce:
        }
     break;
 
-  case 108:
-#line 491 "util/configparser.y"
+  case 110:
+#line 498 "util/configparser.y"
     {
                OUTYY(("P(server_infra_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2126,8 +2138,8 @@ yyreduce:
        }
     break;
 
-  case 109:
-#line 504 "util/configparser.y"
+  case 111:
+#line 511 "util/configparser.y"
     {
                OUTYY(("P(server_target_fetch_policy:%s)\n", (yyvsp[(2) - (2)].str)));
                free(cfg_parser->cfg->target_fetch_policy);
@@ -2135,8 +2147,8 @@ yyreduce:
        }
     break;
 
-  case 110:
-#line 511 "util/configparser.y"
+  case 112:
+#line 518 "util/configparser.y"
     {
                OUTYY(("P(server_harden_short_bufsize:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0)
@@ -2147,8 +2159,8 @@ yyreduce:
        }
     break;
 
-  case 111:
-#line 521 "util/configparser.y"
+  case 113:
+#line 528 "util/configparser.y"
     {
                OUTYY(("P(server_harden_large_queries:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0)
@@ -2159,8 +2171,8 @@ yyreduce:
        }
     break;
 
-  case 112:
-#line 531 "util/configparser.y"
+  case 114:
+#line 538 "util/configparser.y"
     {
                OUTYY(("P(server_harden_glue:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0)
@@ -2171,8 +2183,8 @@ yyreduce:
        }
     break;
 
-  case 113:
-#line 541 "util/configparser.y"
+  case 115:
+#line 548 "util/configparser.y"
     {
                OUTYY(("P(server_do_not_query_address:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->donotqueryaddrs, (yyvsp[(2) - (2)].str)))
@@ -2180,8 +2192,8 @@ yyreduce:
        }
     break;
 
-  case 114:
-#line 548 "util/configparser.y"
+  case 116:
+#line 555 "util/configparser.y"
     {
                OUTYY(("P(server_module_conf:%s)\n", (yyvsp[(2) - (2)].str)));
                free(cfg_parser->cfg->module_conf);
@@ -2189,8 +2201,8 @@ yyreduce:
        }
     break;
 
-  case 115:
-#line 555 "util/configparser.y"
+  case 117:
+#line 562 "util/configparser.y"
     {
                OUTYY(("P(server_val_override_date:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strlen((yyvsp[(2) - (2)].str)) == 0 || strcmp((yyvsp[(2) - (2)].str), "0") == 0) {
@@ -2209,8 +2221,8 @@ yyreduce:
        }
     break;
 
-  case 116:
-#line 573 "util/configparser.y"
+  case 118:
+#line 580 "util/configparser.y"
     {
                OUTYY(("P(server_bogus_ttl:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0 && strcmp((yyvsp[(2) - (2)].str), "0") != 0)
@@ -2220,8 +2232,8 @@ yyreduce:
        }
     break;
 
-  case 117:
-#line 582 "util/configparser.y"
+  case 119:
+#line 589 "util/configparser.y"
     {
                OUTYY(("P(server_val_clean_additional:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0)
@@ -2232,8 +2244,8 @@ yyreduce:
        }
     break;
 
-  case 118:
-#line 592 "util/configparser.y"
+  case 120:
+#line 599 "util/configparser.y"
     {
                OUTYY(("P(server_val_permissive_mode:%s)\n", (yyvsp[(2) - (2)].str)));
                if(strcmp((yyvsp[(2) - (2)].str), "yes") != 0 && strcmp((yyvsp[(2) - (2)].str), "no") != 0)
@@ -2244,8 +2256,8 @@ yyreduce:
        }
     break;
 
-  case 119:
-#line 602 "util/configparser.y"
+  case 121:
+#line 609 "util/configparser.y"
     {
                OUTYY(("P(server_val_nsec3_keysize_iterations:%s)\n", (yyvsp[(2) - (2)].str)));
                free(cfg_parser->cfg->val_nsec3_key_iterations);
@@ -2253,8 +2265,8 @@ yyreduce:
        }
     break;
 
-  case 120:
-#line 609 "util/configparser.y"
+  case 122:
+#line 616 "util/configparser.y"
     {
                OUTYY(("P(server_key_cache_size:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2264,8 +2276,8 @@ yyreduce:
        }
     break;
 
-  case 121:
-#line 618 "util/configparser.y"
+  case 123:
+#line 625 "util/configparser.y"
     {
                OUTYY(("P(server_key_cache_slabs:%s)\n", (yyvsp[(2) - (2)].str)));
                if(atoi((yyvsp[(2) - (2)].str)) == 0)
@@ -2279,8 +2291,8 @@ yyreduce:
        }
     break;
 
-  case 122:
-#line 631 "util/configparser.y"
+  case 124:
+#line 638 "util/configparser.y"
     {
                OUTYY(("P(name:%s)\n", (yyvsp[(2) - (2)].str)));
                free(cfg_parser->cfg->stubs->name);
@@ -2288,8 +2300,8 @@ yyreduce:
        }
     break;
 
-  case 123:
-#line 638 "util/configparser.y"
+  case 125:
+#line 645 "util/configparser.y"
     {
                OUTYY(("P(stub-host:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->stubs->hosts, (yyvsp[(2) - (2)].str)))
@@ -2297,8 +2309,8 @@ yyreduce:
        }
     break;
 
-  case 124:
-#line 645 "util/configparser.y"
+  case 126:
+#line 652 "util/configparser.y"
     {
                OUTYY(("P(stub-addr:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->stubs->addrs, (yyvsp[(2) - (2)].str)))
@@ -2306,8 +2318,8 @@ yyreduce:
        }
     break;
 
-  case 125:
-#line 652 "util/configparser.y"
+  case 127:
+#line 659 "util/configparser.y"
     {
                OUTYY(("P(name:%s)\n", (yyvsp[(2) - (2)].str)));
                free(cfg_parser->cfg->forwards->name);
@@ -2315,8 +2327,8 @@ yyreduce:
        }
     break;
 
-  case 126:
-#line 659 "util/configparser.y"
+  case 128:
+#line 666 "util/configparser.y"
     {
                OUTYY(("P(forward-host:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->forwards->hosts, (yyvsp[(2) - (2)].str)))
@@ -2324,8 +2336,8 @@ yyreduce:
        }
     break;
 
-  case 127:
-#line 666 "util/configparser.y"
+  case 129:
+#line 673 "util/configparser.y"
     {
                OUTYY(("P(forward-addr:%s)\n", (yyvsp[(2) - (2)].str)));
                if(!cfg_strlist_insert(&cfg_parser->cfg->forwards->addrs, (yyvsp[(2) - (2)].str)))
@@ -2335,7 +2347,7 @@ yyreduce:
 
 
 /* Line 1267 of yacc.c.  */
-#line 2339 "util/configparser.c"
+#line 2351 "util/configparser.c"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
@@ -2549,7 +2561,7 @@ yyreturn:
 }
 
 
-#line 672 "util/configparser.y"
+#line 679 "util/configparser.y"
 
 
 /* parse helper routines could be here */
index 729cba13920e8779dac84e1abb1b035fba1990ac..a4aa494225ec33e497e1510efe0f26d8a3059cab 100644 (file)
      VAR_TRUSTED_KEYS_FILE = 320,
      VAR_VAL_NSEC3_KEYSIZE_ITERATIONS = 321,
      VAR_USE_SYSLOG = 322,
-     VAR_OUTGOING_INTERFACE = 323
+     VAR_OUTGOING_INTERFACE = 323,
+     VAR_ROOT_HINTS = 324
    };
 #endif
 /* Tokens.  */
 #define VAR_VAL_NSEC3_KEYSIZE_ITERATIONS 321
 #define VAR_USE_SYSLOG 322
 #define VAR_OUTGOING_INTERFACE 323
+#define VAR_ROOT_HINTS 324
 
 
 
@@ -185,7 +187,7 @@ typedef union YYSTYPE
        char*   str;
 }
 /* Line 1489 of yacc.c.  */
-#line 189 "util/configparser.h"
+#line 191 "util/configparser.h"
        YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
index bc3bb1084c021a39b89d13daaa00de8efa0c17cf..9d4e769e41496f29a685b029e06cd55b54052312 100644 (file)
@@ -85,7 +85,7 @@ extern struct config_parser_state* cfg_parser;
 %token VAR_INCOMING_NUM_TCP VAR_MSG_BUFFER_SIZE VAR_KEY_CACHE_SIZE
 %token VAR_KEY_CACHE_SLABS VAR_TRUSTED_KEYS_FILE 
 %token VAR_VAL_NSEC3_KEYSIZE_ITERATIONS VAR_USE_SYSLOG 
-%token VAR_OUTGOING_INTERFACE
+%token VAR_OUTGOING_INTERFACE VAR_ROOT_HINTS
 
 %%
 toplevelvars: /* empty */ | toplevelvars toplevelvar ;
@@ -121,7 +121,7 @@ content_server: server_num_threads | server_verbosity | server_port |
        server_incoming_num_tcp | server_msg_buffer_size | 
        server_key_cache_size | server_key_cache_slabs | 
        server_trusted_keys_file | server_val_nsec3_keysize_iterations |
-       server_use_syslog | server_outgoing_interface
+       server_use_syslog | server_outgoing_interface | server_root_hints
        ;
 stubstart: VAR_STUB_ZONE
        {
@@ -332,6 +332,13 @@ server_pidfile: VAR_PIDFILE STRING
                cfg_parser->cfg->pidfile = $2;
        }
        ;
+server_root_hints: VAR_ROOT_HINTS STRING
+       {
+               OUTYY(("P(server_root_hints:%s)\n", $2));
+               if(!cfg_strlist_insert(&cfg_parser->cfg->root_hints, $2))
+                       yyerror("out of memory");
+       }
+       ;
 server_trust_anchor_file: VAR_TRUST_ANCHOR_FILE STRING
        {
                OUTYY(("P(server_trust_anchor_file:%s)\n", $2));