1    	/* A Bison parser, made by GNU Bison 3.0.5.  */
2    	
3    	/* Bison implementation for Yacc-like parsers in C
4    	
5    	   Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.
6    	
7    	   This program is free software: you can redistribute it and/or modify
8    	   it under the terms of the GNU General Public License as published by
9    	   the Free Software Foundation, either version 3 of the License, or
10   	   (at your option) any later version.
11   	
12   	   This program is distributed in the hope that it will be useful,
13   	   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   	   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   	   GNU General Public License for more details.
16   	
17   	   You should have received a copy of the GNU General Public License
18   	   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19   	
20   	/* As a special exception, you may create a larger work that contains
21   	   part or all of the Bison parser skeleton and distribute that work
22   	   under terms of your choice, so long as that work isn't itself a
23   	   parser generator using the skeleton or a modified version thereof
24   	   as a parser skeleton.  Alternatively, if you modify or redistribute
25   	   the parser skeleton itself, you may (at your option) remove this
26   	   special exception, which will cause the skeleton and the resulting
27   	   Bison output files to be licensed under the GNU General Public
28   	   License without this special exception.
29   	
30   	   This special exception was added by the Free Software Foundation in
31   	   version 2.2 of Bison.  */
32   	
33   	/* C LALR(1) parser skeleton written by Richard Stallman, by
34   	   simplifying the original so-called "semantic" parser.  */
35   	
36   	/* All symbols defined below should begin with yy or YY, to avoid
37   	   infringing on user name space.  This should be done even for local
38   	   variables, as they might otherwise be expanded by user macros.
39   	   There are some unavoidable exceptions within include files to
40   	   define necessary library symbols; they are noted "INFRINGES ON
41   	   USER NAME SPACE" below.  */
42   	
43   	/* Identify Bison output.  */
44   	#define YYBISON 1
45   	
46   	/* Bison version.  */
47   	#define YYBISON_VERSION "3.0.5"
48   	
49   	/* Skeleton name.  */
50   	#define YYSKELETON_NAME "yacc.c"
51   	
52   	/* Pure parsers.  */
53   	#define YYPURE 1
54   	
55   	/* Push parsers.  */
56   	#define YYPUSH 0
57   	
58   	/* Pull parsers.  */
59   	#define YYPULL 1
60   	
61   	/* "%code top" blocks.  */
62   	#line 1 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:316  */
63   	
64   	
65   	#pragma GCC diagnostic ignored "-Wunused-value"
66   	#pragma GCC diagnostic ignored "-Wunused-variable"
67   	
68   	#include "config.h"
69   	#include "config_parsing.h"
70   	#include "analyse.h"
71   	#include "abstract_mem.h"
72   	
73   	#include <stdio.h>
74   	#include "log.h"
75   	
76   	#if HAVE_STRING_H
77   	#   include <string.h>
78   	#endif
79   	
80   	
81   	#line 82 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:316  */
82   	
83   	/* Substitute the variable and function names.  */
84   	#define yyparse         ganesha_yyparse
85   	#define yylex           ganesha_yylex
86   	#define yyerror         ganesha_yyerror
87   	#define yydebug         ganesha_yydebug
88   	#define yynerrs         ganesha_yynerrs
89   	
90   	
91   	/* Copy the first part of user declarations.  */
92   	
93   	#line 94 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:339  */
94   	
95   	# ifndef YY_NULLPTR
96   	#  if defined __cplusplus && 201103L <= __cplusplus
97   	#   define YY_NULLPTR nullptr
98   	#  else
99   	#   define YY_NULLPTR 0
100  	#  endif
101  	# endif
102  	
103  	/* Enabling verbose error messages.  */
104  	#ifdef YYERROR_VERBOSE
105  	# undef YYERROR_VERBOSE
106  	# define YYERROR_VERBOSE 1
107  	#else
108  	# define YYERROR_VERBOSE 0
109  	#endif
110  	
111  	/* In a future release of Bison, this section will be replaced
112  	   by #include "conf_yacc.h".  */
113  	#ifndef YY_GANESHA_YY_HOME_KKEITHLE_SRC_GITHUB_KALEB2_NFS_GANESHA_SRC_CONFIG_PARSING_CONF_YACC_H_INCLUDED
114  	# define YY_GANESHA_YY_HOME_KKEITHLE_SRC_GITHUB_KALEB2_NFS_GANESHA_SRC_CONFIG_PARSING_CONF_YACC_H_INCLUDED
115  	/* Debug traces.  */
116  	#ifndef YYDEBUG
117  	# define YYDEBUG 0
118  	#endif
119  	#if YYDEBUG
120  	extern int ganesha_yydebug;
121  	#endif
122  	/* "%code requires" blocks.  */
123  	#line 26 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:355  */
124  	
125  	/* alert the parser that we have our own definition */
126  	# define YYLTYPE_IS_DECLARED 1
127  	
128  	
129  	#line 130 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:355  */
130  	
131  	/* Token type.  */
132  	#ifndef YYTOKENTYPE
133  	# define YYTOKENTYPE
134  	  enum yytokentype
135  	  {
136  	    _ERROR_ = 258,
137  	    LCURLY_OP = 259,
138  	    RCURLY_OP = 260,
139  	    EQUAL_OP = 261,
140  	    COMMA_OP = 262,
141  	    SEMI_OP = 263,
142  	    IDENTIFIER = 264,
143  	    STRING = 265,
144  	    DQUOTE = 266,
145  	    SQUOTE = 267,
146  	    TOKEN = 268,
147  	    REGEX_TOKEN = 269,
148  	    TOK_PATH = 270,
149  	    TOK_TRUE = 271,
150  	    TOK_FALSE = 272,
151  	    TOK_DECNUM = 273,
152  	    TOK_HEXNUM = 274,
153  	    TOK_OCTNUM = 275,
154  	    TOK_ARITH_OP = 276,
155  	    TOK_V4_ANY = 277,
156  	    TOK_V4ADDR = 278,
157  	    TOK_V4CIDR = 279,
158  	    TOK_V6ADDR = 280,
159  	    TOK_V6CIDR = 281,
160  	    TOK_FSID = 282,
161  	    TOK_NETGROUP = 283
162  	  };
163  	#endif
164  	
165  	/* Value type.  */
166  	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
167  	
168  	union YYSTYPE
169  	{
170  	#line 32 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:355  */
171  	
172  	  char *token;
173  	  struct config_node *node;
174  	
175  	#line 176 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:355  */
176  	};
177  	
178  	typedef union YYSTYPE YYSTYPE;
179  	# define YYSTYPE_IS_TRIVIAL 1
180  	# define YYSTYPE_IS_DECLARED 1
181  	#endif
182  	
183  	/* Location type.  */
184  	#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
185  	typedef struct YYLTYPE YYLTYPE;
186  	struct YYLTYPE
187  	{
188  	  int first_line;
189  	  int first_column;
190  	  int last_line;
191  	  int last_column;
192  	};
193  	# define YYLTYPE_IS_DECLARED 1
194  	# define YYLTYPE_IS_TRIVIAL 1
195  	#endif
196  	
197  	
198  	
199  	int ganesha_yyparse (struct parser_state *st);
200  	/* "%code provides" blocks.  */
201  	#line 37 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:355  */
202  	
203  	
204  	typedef struct YYLTYPE {
205  	  int first_line;
206  	  int first_column;
207  	  int last_line;
208  	  int last_column;
209  	  char *filename;
210  	} YYLTYPE;
211  	
212  	# define YYLLOC_DEFAULT(Current, Rhs, N)			       \
213  	    do								       \
214  	      if (N)							       \
215  		{							       \
216  		  (Current).first_line	 = YYRHSLOC (Rhs, 1).first_line;       \
217  		  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;     \
218  		  (Current).last_line	 = YYRHSLOC (Rhs, N).last_line;	       \
219  		  (Current).last_column	 = YYRHSLOC (Rhs, N).last_column;      \
220  		  (Current).filename	 = YYRHSLOC (Rhs, 1).filename;	       \
221  		}							       \
222  	      else							       \
223  		{ /* empty RHS */					       \
224  		  (Current).first_line	 = (Current).last_line	 =	       \
225  		    YYRHSLOC (Rhs, 0).last_line;			       \
226  		  (Current).first_column = (Current).last_column =	       \
227  		    YYRHSLOC (Rhs, 0).last_column;			       \
228  		  (Current).filename  = NULL;			     /* new */ \
229  		}							       \
230  	    while (0)
231  	
232  	int ganeshun_yylex(YYSTYPE *yylval_param,
233  			   YYLTYPE *yylloc_param,
234  			   void *scanner);
235  	
236  	int ganesha_yylex(YYSTYPE *yylval_param,
237  			  YYLTYPE *yylloc_param,
238  			  struct parser_state *st);
239  	
240  	void config_parse_error(YYLTYPE *yylloc_param,
241  				struct parser_state *st,
242  				char *format, ...);
243  	
244  	void ganesha_yyerror(YYLTYPE *yylloc_param,
245  			     void *yyscanner,
246  			     char*);
247  	
248  	struct glist_head all_blocks;
249  	
250  	struct config_node *config_block(char *blockname,
251  					 struct config_node *list,
252  					 YYLTYPE *yylloc_param,
253  					 struct parser_state *st);
254  	
255  	void link_node(struct config_node *node);
256  	
257  	 struct config_node *link_sibling(struct config_node *first,
258  					  struct config_node *second);
259  	
260  	struct config_node *config_stmt(char *varname,
261  					struct config_node *exprlist,
262  					 YYLTYPE *yylloc_param,
263  					struct parser_state *st);
264  	
265  	struct config_node *config_term(char *opcode,
266  					char *varval,
267  					enum term_type type,
268  					 YYLTYPE *yylloc_param,
269  					struct parser_state *st);
270  	
271  	
272  	#line 273 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:355  */
273  	
274  	#endif /* !YY_GANESHA_YY_HOME_KKEITHLE_SRC_GITHUB_KALEB2_NFS_GANESHA_SRC_CONFIG_PARSING_CONF_YACC_H_INCLUDED  */
275  	
276  	/* Copy the second part of user declarations.  */
277  	
278  	#line 279 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:358  */
279  	
280  	#ifdef short
281  	# undef short
282  	#endif
283  	
284  	#ifdef YYTYPE_UINT8
285  	typedef YYTYPE_UINT8 yytype_uint8;
286  	#else
287  	typedef unsigned char yytype_uint8;
288  	#endif
289  	
290  	#ifdef YYTYPE_INT8
291  	typedef YYTYPE_INT8 yytype_int8;
292  	#else
293  	typedef signed char yytype_int8;
294  	#endif
295  	
296  	#ifdef YYTYPE_UINT16
297  	typedef YYTYPE_UINT16 yytype_uint16;
298  	#else
299  	typedef unsigned short int yytype_uint16;
300  	#endif
301  	
302  	#ifdef YYTYPE_INT16
303  	typedef YYTYPE_INT16 yytype_int16;
304  	#else
305  	typedef short int yytype_int16;
306  	#endif
307  	
308  	#ifndef YYSIZE_T
309  	# ifdef __SIZE_TYPE__
310  	#  define YYSIZE_T __SIZE_TYPE__
311  	# elif defined size_t
312  	#  define YYSIZE_T size_t
313  	# elif ! defined YYSIZE_T
314  	#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
315  	#  define YYSIZE_T size_t
316  	# else
317  	#  define YYSIZE_T unsigned int
318  	# endif
319  	#endif
320  	
321  	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
322  	
323  	#ifndef YY_
324  	# if defined YYENABLE_NLS && YYENABLE_NLS
325  	#  if ENABLE_NLS
326  	#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
327  	#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
328  	#  endif
329  	# endif
330  	# ifndef YY_
331  	#  define YY_(Msgid) Msgid
332  	# endif
333  	#endif
334  	
335  	#ifndef YY_ATTRIBUTE
336  	# if (defined __GNUC__                                               \
337  	      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
338  	     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
339  	#  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
340  	# else
341  	#  define YY_ATTRIBUTE(Spec) /* empty */
342  	# endif
343  	#endif
344  	
345  	#ifndef YY_ATTRIBUTE_PURE
346  	# define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
347  	#endif
348  	
349  	#ifndef YY_ATTRIBUTE_UNUSED
350  	# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
351  	#endif
352  	
353  	#if !defined _Noreturn \
354  	     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
355  	# if defined _MSC_VER && 1200 <= _MSC_VER
356  	#  define _Noreturn __declspec (noreturn)
357  	# else
358  	#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
359  	# endif
360  	#endif
361  	
362  	/* Suppress unused-variable warnings by "using" E.  */
363  	#if ! defined lint || defined __GNUC__
364  	# define YYUSE(E) ((void) (E))
365  	#else
366  	# define YYUSE(E) /* empty */
367  	#endif
368  	
369  	#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
370  	/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
371  	# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
372  	    _Pragma ("GCC diagnostic push") \
373  	    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
374  	    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
375  	# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
376  	    _Pragma ("GCC diagnostic pop")
377  	#else
378  	# define YY_INITIAL_VALUE(Value) Value
379  	#endif
380  	#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
381  	# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
382  	# define YY_IGNORE_MAYBE_UNINITIALIZED_END
383  	#endif
384  	#ifndef YY_INITIAL_VALUE
385  	# define YY_INITIAL_VALUE(Value) /* Nothing. */
386  	#endif
387  	
388  	
389  	#if ! defined yyoverflow || YYERROR_VERBOSE
390  	
391  	/* The parser invokes alloca or malloc; define the necessary symbols.  */
392  	
393  	# ifdef YYSTACK_USE_ALLOCA
394  	#  if YYSTACK_USE_ALLOCA
395  	#   ifdef __GNUC__
396  	#    define YYSTACK_ALLOC __builtin_alloca
397  	#   elif defined __BUILTIN_VA_ARG_INCR
398  	#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
399  	#   elif defined _AIX
400  	#    define YYSTACK_ALLOC __alloca
401  	#   elif defined _MSC_VER
402  	#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
403  	#    define alloca _alloca
404  	#   else
405  	#    define YYSTACK_ALLOC alloca
406  	#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
407  	#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
408  	      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
409  	#     ifndef EXIT_SUCCESS
410  	#      define EXIT_SUCCESS 0
411  	#     endif
412  	#    endif
413  	#   endif
414  	#  endif
415  	# endif
416  	
417  	# ifdef YYSTACK_ALLOC
418  	   /* Pacify GCC's 'empty if-body' warning.  */
419  	#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
420  	#  ifndef YYSTACK_ALLOC_MAXIMUM
421  	    /* The OS might guarantee only one guard page at the bottom of the stack,
422  	       and a page size can be as small as 4096 bytes.  So we cannot safely
423  	       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
424  	       to allow for a few compiler-allocated temporary stack slots.  */
425  	#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
426  	#  endif
427  	# else
428  	#  define YYSTACK_ALLOC YYMALLOC
429  	#  define YYSTACK_FREE YYFREE
430  	#  ifndef YYSTACK_ALLOC_MAXIMUM
431  	#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
432  	#  endif
433  	#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
434  	       && ! ((defined YYMALLOC || defined malloc) \
435  	             && (defined YYFREE || defined free)))
436  	#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
437  	#   ifndef EXIT_SUCCESS
438  	#    define EXIT_SUCCESS 0
439  	#   endif
440  	#  endif
441  	#  ifndef YYMALLOC
442  	#   define YYMALLOC malloc
443  	#   if ! defined malloc && ! defined EXIT_SUCCESS
444  	void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
445  	#   endif
446  	#  endif
447  	#  ifndef YYFREE
448  	#   define YYFREE free
449  	#   if ! defined free && ! defined EXIT_SUCCESS
450  	void free (void *); /* INFRINGES ON USER NAME SPACE */
451  	#   endif
452  	#  endif
453  	# endif
454  	#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
455  	
456  	
457  	#if (! defined yyoverflow \
458  	     && (! defined __cplusplus \
459  	         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
460  	             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
461  	
462  	/* A type that is properly aligned for any stack member.  */
463  	union yyalloc
464  	{
465  	  yytype_int16 yyss_alloc;
466  	  YYSTYPE yyvs_alloc;
467  	  YYLTYPE yyls_alloc;
468  	};
469  	
470  	/* The size of the maximum gap between one aligned stack and the next.  */
471  	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
472  	
473  	/* The size of an array large to enough to hold all stacks, each with
474  	   N elements.  */
475  	# define YYSTACK_BYTES(N) \
476  	     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
477  	      + 2 * YYSTACK_GAP_MAXIMUM)
478  	
479  	# define YYCOPY_NEEDED 1
480  	
481  	/* Relocate STACK from its old location to the new one.  The
482  	   local variables YYSIZE and YYSTACKSIZE give the old and new number of
483  	   elements in the stack, and YYPTR gives the new location of the
484  	   stack.  Advance YYPTR to a properly aligned location for the next
485  	   stack.  */
486  	# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
487  	    do                                                                  \
488  	      {                                                                 \
489  	        YYSIZE_T yynewbytes;                                            \
490  	        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
491  	        Stack = &yyptr->Stack_alloc;                                    \
492  	        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
493  	        yyptr += yynewbytes / sizeof (*yyptr);                          \
494  	      }                                                                 \
495  	    while (0)
496  	
497  	#endif
498  	
499  	#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
500  	/* Copy COUNT objects from SRC to DST.  The source and destination do
501  	   not overlap.  */
502  	# ifndef YYCOPY
503  	#  if defined __GNUC__ && 1 < __GNUC__
504  	#   define YYCOPY(Dst, Src, Count) \
505  	      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
506  	#  else
507  	#   define YYCOPY(Dst, Src, Count)              \
508  	      do                                        \
509  	        {                                       \
510  	          YYSIZE_T yyi;                         \
511  	          for (yyi = 0; yyi < (Count); yyi++)   \
512  	            (Dst)[yyi] = (Src)[yyi];            \
513  	        }                                       \
514  	      while (0)
515  	#  endif
516  	# endif
517  	#endif /* !YYCOPY_NEEDED */
518  	
519  	/* YYFINAL -- State number of the termination state.  */
520  	#define YYFINAL  7
521  	/* YYLAST -- Last index in YYTABLE.  */
522  	#define YYLAST   61
523  	
524  	/* YYNTOKENS -- Number of terminals.  */
525  	#define YYNTOKENS  29
526  	/* YYNNTS -- Number of nonterminals.  */
527  	#define YYNNTS  8
528  	/* YYNRULES -- Number of rules.  */
529  	#define YYNRULES  36
530  	/* YYNSTATES -- Number of states.  */
531  	#define YYNSTATES  45
532  	
533  	/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
534  	   by yylex, with out-of-bounds checking.  */
535  	#define YYUNDEFTOK  2
536  	#define YYMAXUTOK   283
537  	
538  	#define YYTRANSLATE(YYX)                                                \
539  	  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
540  	
541  	/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
542  	   as returned by yylex, without out-of-bounds checking.  */
543  	static const yytype_uint8 yytranslate[] =
544  	{
545  	       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
546  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
547  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
548  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
549  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
550  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
551  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
552  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
553  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
554  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
555  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
556  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
557  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
558  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
559  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
560  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
561  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
562  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
563  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
564  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
565  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
566  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
567  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
568  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
569  	       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
570  	       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
571  	       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
572  	      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
573  	      25,    26,    27,    28
574  	};
575  	
576  	#if YYDEBUG
577  	  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
578  	static const yytype_uint16 yyrline[] =
579  	{
580  	       0,   147,   147,   150,   160,   164,   173,   177,   184,   188,
581  	     197,   201,   205,   217,   220,   224,   231,   235,   239,   243,
582  	     247,   251,   255,   259,   263,   267,   271,   275,   279,   283,
583  	     287,   291,   295,   299,   303,   307,   311
584  	};
585  	#endif
586  	
587  	#if YYDEBUG || YYERROR_VERBOSE || 0
588  	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
589  	   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
590  	static const char *const yytname[] =
591  	{
592  	  "$end", "error", "$undefined", "_ERROR_", "LCURLY_OP", "RCURLY_OP",
593  	  "EQUAL_OP", "COMMA_OP", "SEMI_OP", "IDENTIFIER", "STRING", "DQUOTE",
594  	  "SQUOTE", "TOKEN", "REGEX_TOKEN", "TOK_PATH", "TOK_TRUE", "TOK_FALSE",
595  	  "TOK_DECNUM", "TOK_HEXNUM", "TOK_OCTNUM", "TOK_ARITH_OP", "TOK_V4_ANY",
596  	  "TOK_V4ADDR", "TOK_V4CIDR", "TOK_V6ADDR", "TOK_V6CIDR", "TOK_FSID",
597  	  "TOK_NETGROUP", "$accept", "config", "deflist", "definition",
598  	  "statement", "block", "exprlist", "expression", YY_NULLPTR
599  	};
600  	#endif
601  	
602  	# ifdef YYPRINT
603  	/* YYTOKNUM[NUM] -- (External) token number corresponding to the
604  	   (internal) symbol number NUM (which must be that of a token).  */
605  	static const yytype_uint16 yytoknum[] =
606  	{
607  	       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
608  	     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
609  	     275,   276,   277,   278,   279,   280,   281,   282,   283
610  	};
611  	# endif
612  	
613  	#define YYPACT_NINF -17
614  	
615  	#define yypact_value_is_default(Yystate) \
616  	  (!!((Yystate) == (-17)))
617  	
618  	#define YYTABLE_NINF -14
619  	
620  	#define yytable_value_is_error(Yytable_value) \
621  	  0
622  	
623  	  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
624  	     STATE-NUM.  */
625  	static const yytype_int8 yypact[] =
626  	{
627  	      44,    48,     8,    44,   -17,    46,    -1,   -17,   -17,    52,
628  	     -17,    -4,   -17,    50,   -17,   -17,   -17,   -17,   -17,   -17,
629  	     -17,   -17,   -17,   -17,   -17,   -16,   -17,   -17,   -17,   -17,
630  	     -17,   -17,   -17,   -17,    42,   -17,   -17,   -17,   -17,   -17,
631  	     -17,   -17,    18,   -17,   -17
632  	};
633  	
634  	  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
635  	     Performed when YYTABLE does not specify something else to do.  Zero
636  	     means the default is an error.  */
637  	static const yytype_uint8 yydefact[] =
638  	{
639  	       2,     0,     0,     3,     4,     0,     0,     1,     5,     0,
640  	      10,     0,     7,     0,    19,    20,    21,    17,    18,    16,
641  	      22,    23,    26,    25,    24,     0,    30,    31,    32,    33,
642  	      34,    35,    36,     6,     0,    14,    12,    11,     9,    29,
643  	      28,    27,     0,     8,    15
644  	};
645  	
646  	  /* YYPGOTO[NTERM-NUM].  */
647  	static const yytype_int8 yypgoto[] =
648  	{
649  	     -17,   -17,    54,    45,   -17,   -17,   -17,    19
650  	};
651  	
652  	  /* YYDEFGOTO[NTERM-NUM].  */
653  	static const yytype_int8 yydefgoto[] =
654  	{
655  	      -1,     2,     3,     4,    33,    12,    34,    35
656  	};
657  	
658  	  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
659  	     positive, shift that token.  If negative, reduce the rule whose
660  	     number is the opposite.  If YYTABLE_NINF, syntax error.  */
661  	static const yytype_int8 yytable[] =
662  	{
663  	      13,    37,    39,    40,    41,     1,   -13,   -13,     7,    14,
664  	      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
665  	      25,    26,    27,    28,    29,    30,    31,    32,    14,    15,
666  	      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
667  	      26,    27,    28,    29,    30,    31,    32,     9,     8,    42,
668  	      43,    10,     5,     1,     6,     1,     8,    36,    38,    11,
669  	       0,    44
670  	};
671  	
672  	static const yytype_int8 yycheck[] =
673  	{
674  	       1,     5,    18,    19,    20,     9,     7,     8,     0,    10,
675  	      11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
676  	      21,    22,    23,    24,    25,    26,    27,    28,    10,    11,
677  	      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
678  	      22,    23,    24,    25,    26,    27,    28,     1,     3,     7,
679  	       8,     5,     4,     9,     6,     9,    11,     5,     8,     5,
680  	      -1,    42
681  	};
682  	
683  	  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
684  	     symbol of state STATE-NUM.  */
685  	static const yytype_uint8 yystos[] =
686  	{
687  	       0,     9,    30,    31,    32,     4,     6,     0,    32,     1,
688  	       5,    31,    34,     1,    10,    11,    12,    13,    14,    15,
689  	      16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
690  	      26,    27,    28,    33,    35,    36,     5,     5,     8,    18,
691  	      19,    20,     7,     8,    36
692  	};
693  	
694  	  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
695  	static const yytype_uint8 yyr1[] =
696  	{
697  	       0,    29,    30,    30,    31,    31,    32,    32,    33,    33,
698  	      34,    34,    34,    35,    35,    35,    36,    36,    36,    36,
699  	      36,    36,    36,    36,    36,    36,    36,    36,    36,    36,
700  	      36,    36,    36,    36,    36,    36,    36
701  	};
702  	
703  	  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
704  	static const yytype_uint8 yyr2[] =
705  	{
706  	       0,     2,     0,     1,     1,     2,     3,     3,     2,     2,
707  	       1,     2,     2,     0,     1,     3,     1,     1,     1,     1,
708  	       1,     1,     1,     1,     1,     1,     1,     2,     2,     2,
709  	       1,     1,     1,     1,     1,     1,     1
710  	};
711  	
712  	
713  	#define yyerrok         (yyerrstatus = 0)
714  	#define yyclearin       (yychar = YYEMPTY)
715  	#define YYEMPTY         (-2)
716  	#define YYEOF           0
717  	
718  	#define YYACCEPT        goto yyacceptlab
719  	#define YYABORT         goto yyabortlab
720  	#define YYERROR         goto yyerrorlab
721  	
722  	
723  	#define YYRECOVERING()  (!!yyerrstatus)
724  	
725  	#define YYBACKUP(Token, Value)                                  \
726  	do                                                              \
727  	  if (yychar == YYEMPTY)                                        \
728  	    {                                                           \
729  	      yychar = (Token);                                         \
730  	      yylval = (Value);                                         \
731  	      YYPOPSTACK (yylen);                                       \
732  	      yystate = *yyssp;                                         \
733  	      goto yybackup;                                            \
734  	    }                                                           \
735  	  else                                                          \
736  	    {                                                           \
737  	      yyerror (&yylloc, st, YY_("syntax error: cannot back up")); \
738  	      YYERROR;                                                  \
739  	    }                                                           \
740  	while (0)
741  	
742  	/* Error token number */
743  	#define YYTERROR        1
744  	#define YYERRCODE       256
745  	
746  	
747  	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
748  	   If N is 0, then set CURRENT to the empty location which ends
749  	   the previous symbol: RHS[0] (always defined).  */
750  	
751  	#ifndef YYLLOC_DEFAULT
752  	# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
753  	    do                                                                  \
754  	      if (N)                                                            \
755  	        {                                                               \
756  	          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
757  	          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
758  	          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
759  	          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
760  	        }                                                               \
761  	      else                                                              \
762  	        {                                                               \
763  	          (Current).first_line   = (Current).last_line   =              \
764  	            YYRHSLOC (Rhs, 0).last_line;                                \
765  	          (Current).first_column = (Current).last_column =              \
766  	            YYRHSLOC (Rhs, 0).last_column;                              \
767  	        }                                                               \
768  	    while (0)
769  	#endif
770  	
771  	#define YYRHSLOC(Rhs, K) ((Rhs)[K])
772  	
773  	
774  	/* Enable debugging if requested.  */
775  	#if YYDEBUG
776  	
777  	# ifndef YYFPRINTF
778  	#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
779  	#  define YYFPRINTF fprintf
780  	# endif
781  	
782  	# define YYDPRINTF(Args)                        \
783  	do {                                            \
784  	  if (yydebug)                                  \
785  	    YYFPRINTF Args;                             \
786  	} while (0)
787  	
788  	
789  	/* YY_LOCATION_PRINT -- Print the location on the stream.
790  	   This macro was not mandated originally: define only if we know
791  	   we won't break user code: when these are the locations we know.  */
792  	
793  	#ifndef YY_LOCATION_PRINT
794  	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
795  	
796  	/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */
797  	
798  	YY_ATTRIBUTE_UNUSED
799  	static unsigned
800  	yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
801  	{
802  	  unsigned res = 0;
803  	  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
804  	  if (0 <= yylocp->first_line)
805  	    {
806  	      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
807  	      if (0 <= yylocp->first_column)
808  	        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
809  	    }
810  	  if (0 <= yylocp->last_line)
811  	    {
812  	      if (yylocp->first_line < yylocp->last_line)
813  	        {
814  	          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
815  	          if (0 <= end_col)
816  	            res += YYFPRINTF (yyo, ".%d", end_col);
817  	        }
818  	      else if (0 <= end_col && yylocp->first_column < end_col)
819  	        res += YYFPRINTF (yyo, "-%d", end_col);
820  	    }
821  	  return res;
822  	 }
823  	
824  	#  define YY_LOCATION_PRINT(File, Loc)          \
825  	  yy_location_print_ (File, &(Loc))
826  	
827  	# else
828  	#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
829  	# endif
830  	#endif
831  	
832  	
833  	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
834  	do {                                                                      \
835  	  if (yydebug)                                                            \
836  	    {                                                                     \
837  	      YYFPRINTF (stderr, "%s ", Title);                                   \
838  	      yy_symbol_print (stderr,                                            \
839  	                  Type, Value, Location, st); \
840  	      YYFPRINTF (stderr, "\n");                                           \
841  	    }                                                                     \
842  	} while (0)
843  	
844  	
845  	/*----------------------------------------.
846  	| Print this symbol's value on YYOUTPUT.  |
847  	`----------------------------------------*/
848  	
849  	static void
850  	yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_state *st)
851  	{
852  	  FILE *yyo = yyoutput;
853  	  YYUSE (yyo);
854  	  YYUSE (yylocationp);
855  	  YYUSE (st);
856  	  if (!yyvaluep)
857  	    return;
858  	# ifdef YYPRINT
859  	  if (yytype < YYNTOKENS)
860  	    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
861  	# endif
862  	  YYUSE (yytype);
863  	}
864  	
865  	
866  	/*--------------------------------.
867  	| Print this symbol on YYOUTPUT.  |
868  	`--------------------------------*/
869  	
870  	static void
871  	yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_state *st)
872  	{
873  	  YYFPRINTF (yyoutput, "%s %s (",
874  	             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
875  	
876  	  YY_LOCATION_PRINT (yyoutput, *yylocationp);
877  	  YYFPRINTF (yyoutput, ": ");
878  	  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, st);
879  	  YYFPRINTF (yyoutput, ")");
880  	}
881  	
882  	/*------------------------------------------------------------------.
883  	| yy_stack_print -- Print the state stack from its BOTTOM up to its |
884  	| TOP (included).                                                   |
885  	`------------------------------------------------------------------*/
886  	
887  	static void
888  	yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
889  	{
890  	  YYFPRINTF (stderr, "Stack now");
891  	  for (; yybottom <= yytop; yybottom++)
892  	    {
893  	      int yybot = *yybottom;
894  	      YYFPRINTF (stderr, " %d", yybot);
895  	    }
896  	  YYFPRINTF (stderr, "\n");
897  	}
898  	
899  	# define YY_STACK_PRINT(Bottom, Top)                            \
900  	do {                                                            \
901  	  if (yydebug)                                                  \
902  	    yy_stack_print ((Bottom), (Top));                           \
903  	} while (0)
904  	
905  	
906  	/*------------------------------------------------.
907  	| Report that the YYRULE is going to be reduced.  |
908  	`------------------------------------------------*/
909  	
910  	static void
911  	yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct parser_state *st)
912  	{
913  	  unsigned long int yylno = yyrline[yyrule];
914  	  int yynrhs = yyr2[yyrule];
915  	  int yyi;
916  	  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
917  	             yyrule - 1, yylno);
918  	  /* The symbols being reduced.  */
919  	  for (yyi = 0; yyi < yynrhs; yyi++)
920  	    {
921  	      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
922  	      yy_symbol_print (stderr,
923  	                       yystos[yyssp[yyi + 1 - yynrhs]],
924  	                       &(yyvsp[(yyi + 1) - (yynrhs)])
925  	                       , &(yylsp[(yyi + 1) - (yynrhs)])                       , st);
926  	      YYFPRINTF (stderr, "\n");
927  	    }
928  	}
929  	
930  	# define YY_REDUCE_PRINT(Rule)          \
931  	do {                                    \
932  	  if (yydebug)                          \
933  	    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, st); \
934  	} while (0)
935  	
936  	/* Nonzero means print parse trace.  It is left uninitialized so that
937  	   multiple parsers can coexist.  */
938  	int yydebug;
939  	#else /* !YYDEBUG */
940  	# define YYDPRINTF(Args)
941  	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
942  	# define YY_STACK_PRINT(Bottom, Top)
943  	# define YY_REDUCE_PRINT(Rule)
944  	#endif /* !YYDEBUG */
945  	
946  	
947  	/* YYINITDEPTH -- initial size of the parser's stacks.  */
948  	#ifndef YYINITDEPTH
949  	# define YYINITDEPTH 200
950  	#endif
951  	
952  	/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
953  	   if the built-in stack extension method is used).
954  	
955  	   Do not make this value too large; the results are undefined if
956  	   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
957  	   evaluated with infinite-precision integer arithmetic.  */
958  	
959  	#ifndef YYMAXDEPTH
960  	# define YYMAXDEPTH 10000
961  	#endif
962  	
963  	
964  	#if YYERROR_VERBOSE
965  	
966  	# ifndef yystrlen
967  	#  if defined __GLIBC__ && defined _STRING_H
968  	#   define yystrlen strlen
969  	#  else
970  	/* Return the length of YYSTR.  */
971  	static YYSIZE_T
972  	yystrlen (const char *yystr)
973  	{
974  	  YYSIZE_T yylen;
975  	  for (yylen = 0; yystr[yylen]; yylen++)
976  	    continue;
977  	  return yylen;
978  	}
979  	#  endif
980  	# endif
981  	
982  	# ifndef yystpcpy
983  	#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
984  	#   define yystpcpy stpcpy
985  	#  else
986  	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
987  	   YYDEST.  */
988  	static char *
989  	yystpcpy (char *yydest, const char *yysrc)
990  	{
991  	  char *yyd = yydest;
992  	  const char *yys = yysrc;
993  	
994  	  while ((*yyd++ = *yys++) != '\0')
995  	    continue;
996  	
997  	  return yyd - 1;
998  	}
999  	#  endif
1000 	# endif
1001 	
1002 	# ifndef yytnamerr
1003 	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1004 	   quotes and backslashes, so that it's suitable for yyerror.  The
1005 	   heuristic is that double-quoting is unnecessary unless the string
1006 	   contains an apostrophe, a comma, or backslash (other than
1007 	   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1008 	   null, do not copy; instead, return the length of what the result
1009 	   would have been.  */
1010 	static YYSIZE_T
1011 	yytnamerr (char *yyres, const char *yystr)
1012 	{
1013 	  if (*yystr == '"')
1014 	    {
1015 	      YYSIZE_T yyn = 0;
1016 	      char const *yyp = yystr;
1017 	
1018 	      for (;;)
1019 	        switch (*++yyp)
1020 	          {
1021 	          case '\'':
1022 	          case ',':
1023 	            goto do_not_strip_quotes;
1024 	
1025 	          case '\\':
1026 	            if (*++yyp != '\\')
1027 	              goto do_not_strip_quotes;
1028 	            /* Fall through.  */
1029 	          default:
1030 	            if (yyres)
1031 	              yyres[yyn] = *yyp;
1032 	            yyn++;
1033 	            break;
1034 	
1035 	          case '"':
1036 	            if (yyres)
1037 	              yyres[yyn] = '\0';
1038 	            return yyn;
1039 	          }
1040 	    do_not_strip_quotes: ;
1041 	    }
1042 	
1043 	  if (! yyres)
1044 	    return yystrlen (yystr);
1045 	
1046 	  return yystpcpy (yyres, yystr) - yyres;
1047 	}
1048 	# endif
1049 	
1050 	/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1051 	   about the unexpected token YYTOKEN for the state stack whose top is
1052 	   YYSSP.
1053 	
1054 	   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1055 	   not large enough to hold the message.  In that case, also set
1056 	   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1057 	   required number of bytes is too large to store.  */
1058 	static int
1059 	yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1060 	                yytype_int16 *yyssp, int yytoken)
1061 	{
1062 	  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1063 	  YYSIZE_T yysize = yysize0;
1064 	  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1065 	  /* Internationalized format string. */
1066 	  const char *yyformat = YY_NULLPTR;
1067 	  /* Arguments of yyformat. */
1068 	  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1069 	  /* Number of reported tokens (one for the "unexpected", one per
1070 	     "expected"). */
1071 	  int yycount = 0;
1072 	
1073 	  /* There are many possibilities here to consider:
1074 	     - If this state is a consistent state with a default action, then
1075 	       the only way this function was invoked is if the default action
1076 	       is an error action.  In that case, don't check for expected
1077 	       tokens because there are none.
1078 	     - The only way there can be no lookahead present (in yychar) is if
1079 	       this state is a consistent state with a default action.  Thus,
1080 	       detecting the absence of a lookahead is sufficient to determine
1081 	       that there is no unexpected or expected token to report.  In that
1082 	       case, just report a simple "syntax error".
1083 	     - Don't assume there isn't a lookahead just because this state is a
1084 	       consistent state with a default action.  There might have been a
1085 	       previous inconsistent state, consistent state with a non-default
1086 	       action, or user semantic action that manipulated yychar.
1087 	     - Of course, the expected token list depends on states to have
1088 	       correct lookahead information, and it depends on the parser not
1089 	       to perform extra reductions after fetching a lookahead from the
1090 	       scanner and before detecting a syntax error.  Thus, state merging
1091 	       (from LALR or IELR) and default reductions corrupt the expected
1092 	       token list.  However, the list is correct for canonical LR with
1093 	       one exception: it will still contain any token that will not be
1094 	       accepted due to an error action in a later state.
1095 	  */
1096 	  if (yytoken != YYEMPTY)
1097 	    {
1098 	      int yyn = yypact[*yyssp];
1099 	      yyarg[yycount++] = yytname[yytoken];
1100 	      if (!yypact_value_is_default (yyn))
1101 	        {
1102 	          /* Start YYX at -YYN if negative to avoid negative indexes in
1103 	             YYCHECK.  In other words, skip the first -YYN actions for
1104 	             this state because they are default actions.  */
1105 	          int yyxbegin = yyn < 0 ? -yyn : 0;
1106 	          /* Stay within bounds of both yycheck and yytname.  */
1107 	          int yychecklim = YYLAST - yyn + 1;
1108 	          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1109 	          int yyx;
1110 	
1111 	          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1112 	            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1113 	                && !yytable_value_is_error (yytable[yyx + yyn]))
1114 	              {
1115 	                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1116 	                  {
1117 	                    yycount = 1;
1118 	                    yysize = yysize0;
1119 	                    break;
1120 	                  }
1121 	                yyarg[yycount++] = yytname[yyx];
1122 	                {
1123 	                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1124 	                  if (! (yysize <= yysize1
1125 	                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1126 	                    return 2;
1127 	                  yysize = yysize1;
1128 	                }
1129 	              }
1130 	        }
1131 	    }
1132 	
1133 	  switch (yycount)
1134 	    {
1135 	# define YYCASE_(N, S)                      \
1136 	      case N:                               \
1137 	        yyformat = S;                       \
1138 	      break
1139 	    default: /* Avoid compiler warnings. */
1140 	      YYCASE_(0, YY_("syntax error"));
1141 	      YYCASE_(1, YY_("syntax error, unexpected %s"));
1142 	      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1143 	      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1144 	      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1145 	      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1146 	# undef YYCASE_
1147 	    }
1148 	
1149 	  {
1150 	    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1151 	    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1152 	      return 2;
1153 	    yysize = yysize1;
1154 	  }
1155 	
1156 	  if (*yymsg_alloc < yysize)
1157 	    {
1158 	      *yymsg_alloc = 2 * yysize;
1159 	      if (! (yysize <= *yymsg_alloc
1160 	             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1161 	        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1162 	      return 1;
1163 	    }
1164 	
1165 	  /* Avoid sprintf, as that infringes on the user's name space.
1166 	     Don't have undefined behavior even if the translation
1167 	     produced a string with the wrong number of "%s"s.  */
1168 	  {
1169 	    char *yyp = *yymsg;
1170 	    int yyi = 0;
1171 	    while ((*yyp = *yyformat) != '\0')
1172 	      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1173 	        {
1174 	          yyp += yytnamerr (yyp, yyarg[yyi++]);
1175 	          yyformat += 2;
1176 	        }
1177 	      else
1178 	        {
1179 	          yyp++;
1180 	          yyformat++;
1181 	        }
1182 	  }
1183 	  return 0;
1184 	}
1185 	#endif /* YYERROR_VERBOSE */
1186 	
1187 	/*-----------------------------------------------.
1188 	| Release the memory associated to this symbol.  |
1189 	`-----------------------------------------------*/
1190 	
1191 	static void
1192 	yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parser_state *st)
1193 	{
1194 	  YYUSE (yyvaluep);
1195 	  YYUSE (yylocationp);
1196 	  YYUSE (st);
1197 	  if (!yymsg)
1198 	    yymsg = "Deleting";
1199 	  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1200 	
1201 	  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1202 	  YYUSE (yytype);
1203 	  YY_IGNORE_MAYBE_UNINITIALIZED_END
1204 	}
1205 	
1206 	
1207 	
1208 	
1209 	/*----------.
1210 	| yyparse.  |
1211 	`----------*/
1212 	
1213 	int
1214 	yyparse (struct parser_state *st)
1215 	{
1216 	/* The lookahead symbol.  */
1217 	int yychar;
1218 	
1219 	
1220 	/* The semantic value of the lookahead symbol.  */
1221 	/* Default value used for initialization, for pacifying older GCCs
1222 	   or non-GCC compilers.  */
1223 	YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1224 	YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1225 	
1226 	/* Location data for the lookahead symbol.  */
1227 	static YYLTYPE yyloc_default
1228 	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1229 	  = { 1, 1, 1, 1 }
1230 	# endif
1231 	;
1232 	YYLTYPE yylloc = yyloc_default;
1233 	
1234 	    /* Number of syntax errors so far.  */
1235 	    int yynerrs;
1236 	
1237 	    int yystate;
1238 	    /* Number of tokens to shift before error messages enabled.  */
1239 	    int yyerrstatus;
1240 	
1241 	    /* The stacks and their tools:
1242 	       'yyss': related to states.
1243 	       'yyvs': related to semantic values.
1244 	       'yyls': related to locations.
1245 	
1246 	       Refer to the stacks through separate pointers, to allow yyoverflow
1247 	       to reallocate them elsewhere.  */
1248 	
1249 	    /* The state stack.  */
1250 	    yytype_int16 yyssa[YYINITDEPTH];
1251 	    yytype_int16 *yyss;
1252 	    yytype_int16 *yyssp;
1253 	
1254 	    /* The semantic value stack.  */
1255 	    YYSTYPE yyvsa[YYINITDEPTH];
1256 	    YYSTYPE *yyvs;
1257 	    YYSTYPE *yyvsp;
1258 	
1259 	    /* The location stack.  */
1260 	    YYLTYPE yylsa[YYINITDEPTH];
1261 	    YYLTYPE *yyls;
1262 	    YYLTYPE *yylsp;
1263 	
1264 	    /* The locations where the error started and ended.  */
1265 	    YYLTYPE yyerror_range[3];
1266 	
1267 	    YYSIZE_T yystacksize;
1268 	
1269 	  int yyn;
1270 	  int yyresult;
1271 	  /* Lookahead token as an internal (translated) token number.  */
1272 	  int yytoken = 0;
1273 	  /* The variables used to return semantic value and location from the
1274 	     action routines.  */
1275 	  YYSTYPE yyval;
1276 	  YYLTYPE yyloc;
1277 	
1278 	#if YYERROR_VERBOSE
1279 	  /* Buffer for error messages, and its allocated size.  */
1280 	  char yymsgbuf[128];
1281 	  char *yymsg = yymsgbuf;
1282 	  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1283 	#endif
1284 	
1285 	#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1286 	
1287 	  /* The number of symbols on the RHS of the reduced rule.
1288 	     Keep to zero when no symbol should be popped.  */
1289 	  int yylen = 0;
1290 	
1291 	  yyssp = yyss = yyssa;
1292 	  yyvsp = yyvs = yyvsa;
1293 	  yylsp = yyls = yylsa;
1294 	  yystacksize = YYINITDEPTH;
1295 	
1296 	  YYDPRINTF ((stderr, "Starting parse\n"));
1297 	
1298 	  yystate = 0;
1299 	  yyerrstatus = 0;
1300 	  yynerrs = 0;
1301 	  yychar = YYEMPTY; /* Cause a token to be read.  */
1302 	  yylsp[0] = yylloc;
(1) Event goto: Jumping to label "yysetstate".
1303 	  goto yysetstate;
1304 	
1305 	/*------------------------------------------------------------.
1306 	| yynewstate -- Push a new state, which is found in yystate.  |
1307 	`------------------------------------------------------------*/
1308 	 yynewstate:
1309 	  /* In all cases, when you get here, the value and location stacks
1310 	     have just been pushed.  So pushing a state here evens the stacks.  */
1311 	  yyssp++;
1312 	
(2) Event label: Reached label "yysetstate".
1313 	 yysetstate:
1314 	  *yyssp = yystate;
1315 	
(3) Event cond_true: Condition "yyss + yystacksize - 1 <= yyssp", taking true branch.
1316 	  if (yyss + yystacksize - 1 <= yyssp)
1317 	    {
1318 	      /* Get the current used size of the three stacks, in elements.  */
1319 	      YYSIZE_T yysize = yyssp - yyss + 1;
1320 	
1321 	#ifdef yyoverflow
1322 	      {
1323 	        /* Give user a chance to reallocate the stack.  Use copies of
1324 	           these so that the &'s don't force the real ones into
1325 	           memory.  */
1326 	        YYSTYPE *yyvs1 = yyvs;
1327 	        yytype_int16 *yyss1 = yyss;
1328 	        YYLTYPE *yyls1 = yyls;
1329 	
1330 	        /* Each stack pointer address is followed by the size of the
1331 	           data in use in that stack, in bytes.  This used to be a
1332 	           conditional around just the two extra args, but that might
1333 	           be undefined if yyoverflow is a macro.  */
1334 	        yyoverflow (YY_("memory exhausted"),
1335 	                    &yyss1, yysize * sizeof (*yyssp),
1336 	                    &yyvs1, yysize * sizeof (*yyvsp),
1337 	                    &yyls1, yysize * sizeof (*yylsp),
1338 	                    &yystacksize);
1339 	
1340 	        yyls = yyls1;
1341 	        yyss = yyss1;
1342 	        yyvs = yyvs1;
1343 	      }
1344 	#else /* no yyoverflow */
1345 	# ifndef YYSTACK_RELOCATE
1346 	      goto yyexhaustedlab;
1347 	# else
1348 	      /* Extend the stack our own way.  */
(4) Event cond_false: Condition "10000 <= yystacksize", taking false branch.
1349 	      if (YYMAXDEPTH <= yystacksize)
(5) Event if_end: End of if statement.
1350 	        goto yyexhaustedlab;
1351 	      yystacksize *= 2;
(6) Event cond_false: Condition "10000 < yystacksize", taking false branch.
1352 	      if (YYMAXDEPTH < yystacksize)
(7) Event if_end: End of if statement.
1353 	        yystacksize = YYMAXDEPTH;
1354 	
1355 	      {
1356 	        yytype_int16 *yyss1 = yyss;
1357 	        union yyalloc *yyptr =
1358 	          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
(8) Event cond_false: Condition "!yyptr", taking false branch.
1359 	        if (! yyptr)
(9) Event if_end: End of if statement.
1360 	          goto yyexhaustedlab;
(10) Event address_of: Taking address with "&yyptr->yyss_alloc" yields a singleton pointer.
(11) Event assign: Assigning: "yyss" = "&yyptr->yyss_alloc".
Also see events: [ptr_arith]
1361 	        YYSTACK_RELOCATE (yyss_alloc, yyss);
1362 	        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1363 	        YYSTACK_RELOCATE (yyls_alloc, yyls);
1364 	#  undef YYSTACK_RELOCATE
(12) Event cond_true: Condition "yyss1 != yyssa", taking true branch.
1365 	        if (yyss1 != yyssa)
1366 	          YYSTACK_FREE (yyss1);
1367 	      }
1368 	# endif
1369 	#endif /* no yyoverflow */
1370 	
(13) Event ptr_arith: Using "yyss" as an array. This might corrupt or misinterpret adjacent memory locations.
Also see events: [address_of][assign]
1371 	      yyssp = yyss + yysize - 1;
1372 	      yyvsp = yyvs + yysize - 1;
1373 	      yylsp = yyls + yysize - 1;
1374 	
1375 	      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1376 	                  (unsigned long int) yystacksize));
1377 	
1378 	      if (yyss + yystacksize - 1 <= yyssp)
1379 	        YYABORT;
1380 	    }
1381 	
1382 	  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1383 	
1384 	  if (yystate == YYFINAL)
1385 	    YYACCEPT;
1386 	
1387 	  goto yybackup;
1388 	
1389 	/*-----------.
1390 	| yybackup.  |
1391 	`-----------*/
1392 	yybackup:
1393 	
1394 	  /* Do appropriate processing given the current state.  Read a
1395 	     lookahead token if we need one and don't already have one.  */
1396 	
1397 	  /* First try to decide what to do without reference to lookahead token.  */
1398 	  yyn = yypact[yystate];
1399 	  if (yypact_value_is_default (yyn))
1400 	    goto yydefault;
1401 	
1402 	  /* Not known => get a lookahead token if don't already have one.  */
1403 	
1404 	  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1405 	  if (yychar == YYEMPTY)
1406 	    {
1407 	      YYDPRINTF ((stderr, "Reading a token: "));
1408 	      yychar = yylex (&yylval, &yylloc, st);
1409 	    }
1410 	
1411 	  if (yychar <= YYEOF)
1412 	    {
1413 	      yychar = yytoken = YYEOF;
1414 	      YYDPRINTF ((stderr, "Now at end of input.\n"));
1415 	    }
1416 	  else
1417 	    {
1418 	      yytoken = YYTRANSLATE (yychar);
1419 	      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1420 	    }
1421 	
1422 	  /* If the proper action on seeing token YYTOKEN is to reduce or to
1423 	     detect an error, take that action.  */
1424 	  yyn += yytoken;
1425 	  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1426 	    goto yydefault;
1427 	  yyn = yytable[yyn];
1428 	  if (yyn <= 0)
1429 	    {
1430 	      if (yytable_value_is_error (yyn))
1431 	        goto yyerrlab;
1432 	      yyn = -yyn;
1433 	      goto yyreduce;
1434 	    }
1435 	
1436 	  /* Count tokens shifted since error; after three, turn off error
1437 	     status.  */
1438 	  if (yyerrstatus)
1439 	    yyerrstatus--;
1440 	
1441 	  /* Shift the lookahead token.  */
1442 	  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1443 	
1444 	  /* Discard the shifted token.  */
1445 	  yychar = YYEMPTY;
1446 	
1447 	  yystate = yyn;
1448 	  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1449 	  *++yyvsp = yylval;
1450 	  YY_IGNORE_MAYBE_UNINITIALIZED_END
1451 	  *++yylsp = yylloc;
1452 	  goto yynewstate;
1453 	
1454 	
1455 	/*-----------------------------------------------------------.
1456 	| yydefault -- do the default action for the current state.  |
1457 	`-----------------------------------------------------------*/
1458 	yydefault:
1459 	  yyn = yydefact[yystate];
1460 	  if (yyn == 0)
1461 	    goto yyerrlab;
1462 	  goto yyreduce;
1463 	
1464 	
1465 	/*-----------------------------.
1466 	| yyreduce -- Do a reduction.  |
1467 	`-----------------------------*/
1468 	yyreduce:
1469 	  /* yyn is the number of a rule to reduce with.  */
1470 	  yylen = yyr2[yyn];
1471 	
1472 	  /* If YYLEN is nonzero, implement the default value of the action:
1473 	     '$$ = $1'.
1474 	
1475 	     Otherwise, the following line sets YYVAL to garbage.
1476 	     This behavior is undocumented and Bison
1477 	     users should not rely upon it.  Assigning to YYVAL
1478 	     unconditionally makes the parser a bit smaller, and it avoids a
1479 	     GCC warning that YYVAL may be used uninitialized.  */
1480 	  yyval = yyvsp[1-yylen];
1481 	
1482 	  /* Default location. */
1483 	  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1484 	  yyerror_range[1] = yyloc;
1485 	  YY_REDUCE_PRINT (yyn);
1486 	  switch (yyn)
1487 	    {
1488 	        case 2:
1489 	#line 147 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1490 	    { /* empty */
1491 	  config_parse_error(&yyloc, st, "Empty configuration file");
1492 	}
1493 	#line 1494 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1494 	    break;
1495 	
1496 	  case 3:
1497 	#line 151 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1498 	    {
1499 	  if ((yyvsp[0].node) != NULL)
1500 	    glist_add_tail(&((yyvsp[0].node))->node, &st->root_node->root.u.nterm.sub_nodes);
1501 	  link_node(&st->root_node->root);
1502 	}
1503 	#line 1504 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1504 	    break;
1505 	
1506 	  case 4:
1507 	#line 161 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1508 	    {
1509 	  (yyval.node) = (yyvsp[0].node);
1510 	}
1511 	#line 1512 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1512 	    break;
1513 	
1514 	  case 5:
1515 	#line 165 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1516 	    {
1517 	  (yyval.node) = link_sibling((yyvsp[-1].node), (yyvsp[0].node));
1518 	}
1519 	#line 1520 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1520 	    break;
1521 	
1522 	  case 6:
1523 	#line 174 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1524 	    {
1525 	  (yyval.node) = config_stmt((yyvsp[-2].token), (yyvsp[0].node), &(yyloc), st);
1526 	}
1527 	#line 1528 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1528 	    break;
1529 	
1530 	  case 7:
1531 	#line 178 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1532 	    {
1533 	  (yyval.node)=config_block((yyvsp[-2].token), (yyvsp[0].node), &(yyloc), st);
1534 	}
1535 	#line 1536 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1536 	    break;
1537 	
1538 	  case 8:
1539 	#line 185 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1540 	    {
1541 	  (yyval.node) = (yyvsp[-1].node);
1542 	}
1543 	#line 1544 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1544 	    break;
1545 	
1546 	  case 9:
1547 	#line 189 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1548 	    {
1549 	  config_parse_error(&(yyloc), st, "Syntax error in statement");
1550 	  yyerrok;
1551 	  (yyval.node) = NULL;
1552 	}
1553 	#line 1554 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1554 	    break;
1555 	
1556 	  case 10:
1557 	#line 198 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1558 	    { /* empty */
1559 	  (yyval.node) = NULL;
1560 	}
1561 	#line 1562 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1562 	    break;
1563 	
1564 	  case 11:
1565 	#line 202 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1566 	    {
1567 	  (yyval.node) = (yyvsp[-1].node);
1568 	}
1569 	#line 1570 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1570 	    break;
1571 	
1572 	  case 12:
1573 	#line 206 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1574 	    {
1575 	  config_parse_error(&(yyloc), st, "Syntax error in block");
1576 	  yyerrok;
1577 	  (yyval.node) = NULL;
1578 	}
1579 	#line 1580 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1580 	    break;
1581 	
1582 	  case 13:
1583 	#line 217 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1584 	    { /* empty */
1585 	  (yyval.node) = NULL;
1586 	}
1587 	#line 1588 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1588 	    break;
1589 	
1590 	  case 14:
1591 	#line 221 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1592 	    {
1593 	  (yyval.node) = (yyvsp[0].node);
1594 	}
1595 	#line 1596 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1596 	    break;
1597 	
1598 	  case 15:
1599 	#line 225 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1600 	    {
1601 	  (yyval.node) = link_sibling((yyvsp[-2].node), (yyvsp[0].node));
1602 	}
1603 	#line 1604 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1604 	    break;
1605 	
1606 	  case 16:
1607 	#line 232 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1608 	    {
1609 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_PATH, &(yyloc), st);
1610 	}
1611 	#line 1612 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1612 	    break;
1613 	
1614 	  case 17:
1615 	#line 236 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1616 	    {
1617 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_TOKEN, &(yyloc), st);
1618 	}
1619 	#line 1620 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1620 	    break;
1621 	
1622 	  case 18:
1623 	#line 240 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1624 	    {
1625 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_REGEX, &(yyloc), st);
1626 	}
1627 	#line 1628 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1628 	    break;
1629 	
1630 	  case 19:
1631 	#line 244 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1632 	    {
1633 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_STRING, &(yyloc), st);
1634 	}
1635 	#line 1636 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1636 	    break;
1637 	
1638 	  case 20:
1639 	#line 248 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1640 	    {
1641 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_DQUOTE, &(yyloc), st);
1642 	}
1643 	#line 1644 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1644 	    break;
1645 	
1646 	  case 21:
1647 	#line 252 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1648 	    {
1649 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_SQUOTE, &(yyloc), st);
1650 	}
1651 	#line 1652 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1652 	    break;
1653 	
1654 	  case 22:
1655 	#line 256 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1656 	    {
1657 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_TRUE, &(yyloc), st);
1658 	}
1659 	#line 1660 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1660 	    break;
1661 	
1662 	  case 23:
1663 	#line 260 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1664 	    {
1665 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_FALSE, &(yyloc), st);
1666 	}
1667 	#line 1668 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1668 	    break;
1669 	
1670 	  case 24:
1671 	#line 264 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1672 	    {
1673 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_OCTNUM, &(yyloc), st);
1674 	}
1675 	#line 1676 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1676 	    break;
1677 	
1678 	  case 25:
1679 	#line 268 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1680 	    {
1681 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_HEXNUM, &(yyloc), st);
1682 	}
1683 	#line 1684 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1684 	    break;
1685 	
1686 	  case 26:
1687 	#line 272 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1688 	    {
1689 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_DECNUM, &(yyloc), st);
1690 	}
1691 	#line 1692 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1692 	    break;
1693 	
1694 	  case 27:
1695 	#line 276 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1696 	    {
1697 	  (yyval.node) = config_term((yyvsp[-1].token), (yyvsp[0].token), TERM_OCTNUM, &(yyloc), st);
1698 	}
1699 	#line 1700 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1700 	    break;
1701 	
1702 	  case 28:
1703 	#line 280 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1704 	    {
1705 	  (yyval.node) = config_term((yyvsp[-1].token), (yyvsp[0].token), TERM_HEXNUM, &(yyloc), st);
1706 	}
1707 	#line 1708 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1708 	    break;
1709 	
1710 	  case 29:
1711 	#line 284 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1712 	    {
1713 	  (yyval.node) = config_term((yyvsp[-1].token), (yyvsp[0].token), TERM_DECNUM, &(yyloc), st);
1714 	}
1715 	#line 1716 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1716 	    break;
1717 	
1718 	  case 30:
1719 	#line 288 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1720 	    {
1721 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_V4_ANY, &(yyloc), st);
1722 	}
1723 	#line 1724 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1724 	    break;
1725 	
1726 	  case 31:
1727 	#line 292 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1728 	    {
1729 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_V4ADDR, &(yyloc), st);
1730 	}
1731 	#line 1732 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1732 	    break;
1733 	
1734 	  case 32:
1735 	#line 296 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1736 	    {
1737 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_V4CIDR, &(yyloc), st);
1738 	}
1739 	#line 1740 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1740 	    break;
1741 	
1742 	  case 33:
1743 	#line 300 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1744 	    {
1745 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_V6ADDR, &(yyloc), st);
1746 	}
1747 	#line 1748 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1748 	    break;
1749 	
1750 	  case 34:
1751 	#line 304 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1752 	    {
1753 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_V6CIDR, &(yyloc), st);
1754 	}
1755 	#line 1756 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1756 	    break;
1757 	
1758 	  case 35:
1759 	#line 308 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1760 	    {
1761 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_FSID, &(yyloc), st);
1762 	}
1763 	#line 1764 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1764 	    break;
1765 	
1766 	  case 36:
1767 	#line 312 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1648  */
1768 	    {
1769 	  (yyval.node) = config_term(NULL, (yyvsp[0].token), TERM_NETGROUP, &(yyloc), st);
1770 	}
1771 	#line 1772 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1772 	    break;
1773 	
1774 	
1775 	#line 1776 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.c" /* yacc.c:1648  */
1776 	      default: break;
1777 	    }
1778 	  /* User semantic actions sometimes alter yychar, and that requires
1779 	     that yytoken be updated with the new translation.  We take the
1780 	     approach of translating immediately before every use of yytoken.
1781 	     One alternative is translating here after every semantic action,
1782 	     but that translation would be missed if the semantic action invokes
1783 	     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1784 	     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
1785 	     incorrect destructor might then be invoked immediately.  In the
1786 	     case of YYERROR or YYBACKUP, subsequent parser actions might lead
1787 	     to an incorrect destructor call or verbose syntax error message
1788 	     before the lookahead is translated.  */
1789 	  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1790 	
1791 	  YYPOPSTACK (yylen);
1792 	  yylen = 0;
1793 	  YY_STACK_PRINT (yyss, yyssp);
1794 	
1795 	  *++yyvsp = yyval;
1796 	  *++yylsp = yyloc;
1797 	
1798 	  /* Now 'shift' the result of the reduction.  Determine what state
1799 	     that goes to, based on the state we popped back to and the rule
1800 	     number reduced by.  */
1801 	
1802 	  yyn = yyr1[yyn];
1803 	
1804 	  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1805 	  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1806 	    yystate = yytable[yystate];
1807 	  else
1808 	    yystate = yydefgoto[yyn - YYNTOKENS];
1809 	
1810 	  goto yynewstate;
1811 	
1812 	
1813 	/*--------------------------------------.
1814 	| yyerrlab -- here on detecting error.  |
1815 	`--------------------------------------*/
1816 	yyerrlab:
1817 	  /* Make sure we have latest lookahead translation.  See comments at
1818 	     user semantic actions for why this is necessary.  */
1819 	  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1820 	
1821 	  /* If not already recovering from an error, report this error.  */
1822 	  if (!yyerrstatus)
1823 	    {
1824 	      ++yynerrs;
1825 	#if ! YYERROR_VERBOSE
1826 	      yyerror (&yylloc, st, YY_("syntax error"));
1827 	#else
1828 	# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1829 	                                        yyssp, yytoken)
1830 	      {
1831 	        char const *yymsgp = YY_("syntax error");
1832 	        int yysyntax_error_status;
1833 	        yysyntax_error_status = YYSYNTAX_ERROR;
1834 	        if (yysyntax_error_status == 0)
1835 	          yymsgp = yymsg;
1836 	        else if (yysyntax_error_status == 1)
1837 	          {
1838 	            if (yymsg != yymsgbuf)
1839 	              YYSTACK_FREE (yymsg);
1840 	            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1841 	            if (!yymsg)
1842 	              {
1843 	                yymsg = yymsgbuf;
1844 	                yymsg_alloc = sizeof yymsgbuf;
1845 	                yysyntax_error_status = 2;
1846 	              }
1847 	            else
1848 	              {
1849 	                yysyntax_error_status = YYSYNTAX_ERROR;
1850 	                yymsgp = yymsg;
1851 	              }
1852 	          }
1853 	        yyerror (&yylloc, st, yymsgp);
1854 	        if (yysyntax_error_status == 2)
1855 	          goto yyexhaustedlab;
1856 	      }
1857 	# undef YYSYNTAX_ERROR
1858 	#endif
1859 	    }
1860 	
1861 	  yyerror_range[1] = yylloc;
1862 	
1863 	  if (yyerrstatus == 3)
1864 	    {
1865 	      /* If just tried and failed to reuse lookahead token after an
1866 	         error, discard it.  */
1867 	
1868 	      if (yychar <= YYEOF)
1869 	        {
1870 	          /* Return failure if at end of input.  */
1871 	          if (yychar == YYEOF)
1872 	            YYABORT;
1873 	        }
1874 	      else
1875 	        {
1876 	          yydestruct ("Error: discarding",
1877 	                      yytoken, &yylval, &yylloc, st);
1878 	          yychar = YYEMPTY;
1879 	        }
1880 	    }
1881 	
1882 	  /* Else will try to reuse lookahead token after shifting the error
1883 	     token.  */
1884 	  goto yyerrlab1;
1885 	
1886 	
1887 	/*---------------------------------------------------.
1888 	| yyerrorlab -- error raised explicitly by YYERROR.  |
1889 	`---------------------------------------------------*/
1890 	yyerrorlab:
1891 	
1892 	  /* Pacify compilers like GCC when the user code never invokes
1893 	     YYERROR and the label yyerrorlab therefore never appears in user
1894 	     code.  */
1895 	  if (/*CONSTCOND*/ 0)
1896 	     goto yyerrorlab;
1897 	
1898 	  /* Do not reclaim the symbols of the rule whose action triggered
1899 	     this YYERROR.  */
1900 	  YYPOPSTACK (yylen);
1901 	  yylen = 0;
1902 	  YY_STACK_PRINT (yyss, yyssp);
1903 	  yystate = *yyssp;
1904 	  goto yyerrlab1;
1905 	
1906 	
1907 	/*-------------------------------------------------------------.
1908 	| yyerrlab1 -- common code for both syntax error and YYERROR.  |
1909 	`-------------------------------------------------------------*/
1910 	yyerrlab1:
1911 	  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1912 	
1913 	  for (;;)
1914 	    {
1915 	      yyn = yypact[yystate];
1916 	      if (!yypact_value_is_default (yyn))
1917 	        {
1918 	          yyn += YYTERROR;
1919 	          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1920 	            {
1921 	              yyn = yytable[yyn];
1922 	              if (0 < yyn)
1923 	                break;
1924 	            }
1925 	        }
1926 	
1927 	      /* Pop the current state because it cannot handle the error token.  */
1928 	      if (yyssp == yyss)
1929 	        YYABORT;
1930 	
1931 	      yyerror_range[1] = *yylsp;
1932 	      yydestruct ("Error: popping",
1933 	                  yystos[yystate], yyvsp, yylsp, st);
1934 	      YYPOPSTACK (1);
1935 	      yystate = *yyssp;
1936 	      YY_STACK_PRINT (yyss, yyssp);
1937 	    }
1938 	
1939 	  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1940 	  *++yyvsp = yylval;
1941 	  YY_IGNORE_MAYBE_UNINITIALIZED_END
1942 	
1943 	  yyerror_range[2] = yylloc;
1944 	  /* Using YYLLOC is tempting, but would change the location of
1945 	     the lookahead.  YYLOC is available though.  */
1946 	  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
1947 	  *++yylsp = yyloc;
1948 	
1949 	  /* Shift the error token.  */
1950 	  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1951 	
1952 	  yystate = yyn;
1953 	  goto yynewstate;
1954 	
1955 	
1956 	/*-------------------------------------.
1957 	| yyacceptlab -- YYACCEPT comes here.  |
1958 	`-------------------------------------*/
1959 	yyacceptlab:
1960 	  yyresult = 0;
1961 	  goto yyreturn;
1962 	
1963 	/*-----------------------------------.
1964 	| yyabortlab -- YYABORT comes here.  |
1965 	`-----------------------------------*/
1966 	yyabortlab:
1967 	  yyresult = 1;
1968 	  goto yyreturn;
1969 	
1970 	#if !defined yyoverflow || YYERROR_VERBOSE
1971 	/*-------------------------------------------------.
1972 	| yyexhaustedlab -- memory exhaustion comes here.  |
1973 	`-------------------------------------------------*/
1974 	yyexhaustedlab:
1975 	  yyerror (&yylloc, st, YY_("memory exhausted"));
1976 	  yyresult = 2;
1977 	  /* Fall through.  */
1978 	#endif
1979 	
1980 	yyreturn:
1981 	  if (yychar != YYEMPTY)
1982 	    {
1983 	      /* Make sure we have latest lookahead translation.  See comments at
1984 	         user semantic actions for why this is necessary.  */
1985 	      yytoken = YYTRANSLATE (yychar);
1986 	      yydestruct ("Cleanup: discarding lookahead",
1987 	                  yytoken, &yylval, &yylloc, st);
1988 	    }
1989 	  /* Do not reclaim the symbols of the rule whose action triggered
1990 	     this YYABORT or YYACCEPT.  */
1991 	  YYPOPSTACK (yylen);
1992 	  YY_STACK_PRINT (yyss, yyssp);
1993 	  while (yyssp != yyss)
1994 	    {
1995 	      yydestruct ("Cleanup: popping",
1996 	                  yystos[*yyssp], yyvsp, yylsp, st);
1997 	      YYPOPSTACK (1);
1998 	    }
1999 	#ifndef yyoverflow
2000 	  if (yyss != yyssa)
2001 	    YYSTACK_FREE (yyss);
2002 	#endif
2003 	#if YYERROR_VERBOSE
2004 	  if (yymsg != yymsgbuf)
2005 	    YYSTACK_FREE (yymsg);
2006 	#endif
2007 	  return yyresult;
2008 	}
2009 	#line 317 "/home/kkeithle/src/github/kaleb2/nfs-ganesha/src/config_parsing/conf_yacc.y" /* yacc.c:1907  */
2010 	
2011 	
2012 	  /**
2013 	   * @brief Report an scanner/parser error
2014 	   *
2015 	   * Replacement for yyerror() to get more info.
2016 	   * HACK ALERT: new_file() does not have yylloc initialized yet for
2017 	   * first file so create a string and init line number for it.
2018 	   */
2019 	
2020 	void config_parse_error(YYLTYPE *yylloc_param,
2021 				struct parser_state *st,
2022 				char *format, ...)
2023 	{
2024 		FILE *fp = st->err_type->fp;
2025 		va_list arguments;
2026 		char *filename = "<unknown file>";
2027 		int linenum = 0;;
2028 	
2029 		if (fp == NULL)
2030 			return;  /* no stream, no message */
2031 		if (yylloc_param != NULL) {
2032 		  filename = yylloc_param->filename;
2033 		  linenum = yylloc_param->first_line;
2034 		}
2035 		va_start(arguments, format);
2036 		config_error(fp, filename, linenum, format, arguments);
2037 		va_end(arguments);
2038 	}
2039 	
2040 	/* This is here because bison wants it declared.
2041 	 * We do not use it because we can't get around the API.
2042 	 * Use config_parse_error() instead.
2043 	 */
2044 	
2045 	void ganesha_yyerror(YYLTYPE *yylloc_param,
2046 			     void *yyscanner,
2047 			     char *s){
2048 	
2049 	  LogCrit(COMPONENT_CONFIG,
2050 		  "Config file (%s:%d) error: %s\n",
2051 		  yylloc_param->filename,
2052 		  yylloc_param->first_line,
2053 		  s);
2054 	}
2055 	
2056 	/**
2057 	 * @brief Notes on parse tree linkage
2058 	 *
2059 	 * We use glist a little differently so beware.
2060 	 * Elsewhere in the server, we only glist_init() the head
2061 	 * and leave the 'node' members alone (both next and prev == NULL).
2062 	 * However, the parse FSM handles siblings as a list via the LR rules.
2063 	 * This means that while sub_nodes is the "head" of the list, it only
2064 	 * gets linked in when the rules add the already formed list is fully
2065 	 * parsed. Therefore, to make this all work, each node's 'node' member
2066 	 * gets a turn as the head which requires it to be glist_init()'d
2067 	 * contrary to what the rest of the code does.  The last node to play
2068 	 * 'head' is then the 'sub_nodes' member of the parent.
2069 	 */
2070 	
2071 	/**
2072 	 *  Create a block item with the given content
2073 	 */
2074 	
2075 	void dump_all_blocks(void)
2076 	{
2077 		struct glist_head *glh;
2078 		struct config_node *node;
2079 	
2080 		int ix = 0;
2081 		glist_for_each(glh, &all_blocks) {
2082 			node = glist_entry(glh, struct config_node, blocks);
2083 			printf("%s: ix: %d node blockname: %s\n",
2084 				__func__, ix, node->u.nterm.name);
2085 			++ix;
2086 		}
2087 	}
2088 	
2089 	struct config_node *config_block(char *blockname,
2090 					 struct config_node *list,
2091 					 YYLTYPE *yylloc_param,
2092 					 struct parser_state *st)
2093 	{
2094 		struct config_node *node;
2095 	
2096 		node = gsh_calloc(1, sizeof(struct config_node));
2097 		if (node == NULL) {
2098 			st->err_type->resource = true;
2099 			return NULL;
2100 		}
2101 		glist_init(&node->node);
2102 		glist_init(&node->blocks);
2103 		node->u.nterm.name = blockname;
2104 		node->filename = yylloc_param->filename;
2105 		node->linenumber = yylloc_param->first_line;
2106 		node->type = TYPE_BLOCK;
2107 		glist_init(&node->u.nterm.sub_nodes);
2108 		if (list != NULL) {
2109 			glist_add_tail(&list->node, &node->u.nterm.sub_nodes);
2110 			link_node(node);
2111 		}
2112 		glist_add_tail(&all_blocks, &node->blocks);
2113 		return node;
2114 	}
2115 	
2116 	/**
2117 	 * @brief Walk the subnode list and update all the sub-blocks in it
2118 	 * so we can find the root of the parse tree when we need it.
2119 	 */
2120 	
2121 	void link_node(struct config_node *node)
2122 	{
2123 		struct config_node *subnode;
2124 		struct glist_head *ns;
2125 	
2126 		assert(node->type == TYPE_BLOCK ||
2127 		       node->type == TYPE_ROOT);
2128 		glist_for_each(ns, &node->u.nterm.sub_nodes) {
2129 			subnode = glist_entry(ns, struct config_node, node);
2130 			if (subnode->type == TYPE_BLOCK)
2131 				subnode->u.nterm.parent = node;
2132 		}
2133 	}
2134 	
2135 	/**
2136 	 * @brief Link siblings together
2137 	 *
2138 	 */
2139 	
2140 	struct config_node *link_sibling(struct config_node *first,
2141 					 struct config_node *second)
2142 	{
2143 		if (first == NULL) {
2144 			return second;
2145 		} else {
2146 			if (second != NULL)
2147 				glist_add_tail(&first->node, &second->node);
2148 			return first;
2149 		}
2150 	}
2151 	
2152 	/**
2153 	 *  Create a term (value)
2154 	 */
2155 	
2156 	struct config_node *config_term(char *opcode,
2157 					char *varval,
2158 					enum term_type type,
2159 					YYLTYPE *yylloc_param,
2160 					struct parser_state *st)
2161 	{
2162 		struct config_node *node;
2163 	
2164 		node = gsh_calloc(1, sizeof(struct config_node));
2165 		if (node == NULL) {
2166 			st->err_type->resource = true;
2167 			return NULL;
2168 		}
2169 		glist_init(&node->node);
2170 		node->filename = yylloc_param->filename;
2171 		node->linenumber = yylloc_param->first_line;
2172 		node->type = TYPE_TERM;
2173 		node->u.term.type = type;
2174 		node->u.term.op_code = opcode;
2175 		node->u.term.varvalue = varval;
2176 		return node;
2177 	}
2178 	
2179 	/**
2180 	 *  Create a statement node (key = list of terms)
2181 	 */
2182 	
2183 	struct config_node *config_stmt(char *varname,
2184 					struct config_node *exprlist,
2185 					 YYLTYPE *yylloc_param,
2186 					struct parser_state *st)
2187 	{
2188 		struct config_node *node;
2189 	
2190 		node = gsh_calloc(1, sizeof(struct config_node));
2191 		if (node == NULL) {
2192 			st->err_type->resource = true;
2193 			return NULL;
2194 		}
2195 		glist_init(&node->node);
2196 		glist_init(&node->u.nterm.sub_nodes);
2197 		node->filename = yylloc_param->filename;
2198 		node->linenumber = yylloc_param->first_line;
2199 		node->type = TYPE_STMT;
2200 		node->u.nterm.name = varname;
2201 		if (exprlist != NULL)
2202 			glist_add_tail(&exprlist->node, &node->u.nterm.sub_nodes);
2203 		return node;
2204 	}
2205 	
2206 	
2207 	int ganesha_yylex(YYSTYPE *yylval_param,
2208 			  YYLTYPE *yylloc_param,
2209 			  struct parser_state *st)
2210 	{
2211 		return ganeshun_yylex(yylval_param,
2212 				      yylloc_param,
2213 				      st->scanner);
2214 	
2215 	}
2216