"Fossies" - the Fresh Open Source Software Archive

Member "hitch-1.5.2/src/cfg_parser.c" (27 Nov 2019, 81360 Bytes) of package /linux/www/hitch-1.5.2.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "cfg_parser.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 1.5.0_vs_1.5.1.

    1 /* A Bison parser, made by GNU Bison 3.3.2.  */
    2 
    3 /* Bison implementation for Yacc-like parsers in C
    4 
    5    Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
    6    Inc.
    7 
    8    This program is free software: you can redistribute it and/or modify
    9    it under the terms of the GNU General Public License as published by
   10    the Free Software Foundation, either version 3 of the License, or
   11    (at your option) any later version.
   12 
   13    This program is distributed in the hope that it will be useful,
   14    but WITHOUT ANY WARRANTY; without even the implied warranty of
   15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   16    GNU General Public License for more details.
   17 
   18    You should have received a copy of the GNU General Public License
   19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   20 
   21 /* As a special exception, you may create a larger work that contains
   22    part or all of the Bison parser skeleton and distribute that work
   23    under terms of your choice, so long as that work isn't itself a
   24    parser generator using the skeleton or a modified version thereof
   25    as a parser skeleton.  Alternatively, if you modify or redistribute
   26    the parser skeleton itself, you may (at your option) remove this
   27    special exception, which will cause the skeleton and the resulting
   28    Bison output files to be licensed under the GNU General Public
   29    License without this special exception.
   30 
   31    This special exception was added by the Free Software Foundation in
   32    version 2.2 of Bison.  */
   33 
   34 /* C LALR(1) parser skeleton written by Richard Stallman, by
   35    simplifying the original so-called "semantic" parser.  */
   36 
   37 /* All symbols defined below should begin with yy or YY, to avoid
   38    infringing on user name space.  This should be done even for local
   39    variables, as they might otherwise be expanded by user macros.
   40    There are some unavoidable exceptions within include files to
   41    define necessary library symbols; they are noted "INFRINGES ON
   42    USER NAME SPACE" below.  */
   43 
   44 /* Undocumented macros, especially those whose name start with YY_,
   45    are private implementation details.  Do not rely on them.  */
   46 
   47 /* Identify Bison output.  */
   48 #define YYBISON 1
   49 
   50 /* Bison version.  */
   51 #define YYBISON_VERSION "3.3.2"
   52 
   53 /* Skeleton name.  */
   54 #define YYSKELETON_NAME "yacc.c"
   55 
   56 /* Pure parsers.  */
   57 #define YYPURE 0
   58 
   59 /* Push parsers.  */
   60 #define YYPUSH 0
   61 
   62 /* Pull parsers.  */
   63 #define YYPULL 1
   64 
   65 
   66 
   67 
   68 /* First part of user prologue.  */
   69 #line 1 "cfg_parser.y" /* yacc.c:337  */
   70 
   71 #include "config.h"
   72 
   73 #include <stdio.h>
   74 #include <stdlib.h>
   75 
   76 #include "configuration.h"
   77 #include "foreign/vas.h"
   78 #include "foreign/miniobj.h"
   79 #include "foreign/uthash.h"
   80 
   81 extern int yylex (void);
   82 extern int yyparse(hitch_config *);
   83 extern FILE *yyin;
   84 int yyget_lineno(void);
   85 
   86 void config_error_set(char *, ...);
   87 int config_param_validate(char *k, char *v, hitch_config *cfg,
   88     char *file, int line);
   89 int front_arg_add(hitch_config *cfg, struct front_arg *fa);
   90 struct front_arg *front_arg_new(void);
   91 void front_arg_destroy(struct front_arg *fa);
   92 struct cfg_cert_file *
   93 cfg_cert_file_new(void);
   94 void cfg_cert_file_free(struct cfg_cert_file **cfptr);
   95 int cfg_cert_vfy(struct cfg_cert_file *cf);
   96 void yyerror(hitch_config *, const char *);
   97 void cfg_cert_add(struct cfg_cert_file *cf, struct cfg_cert_file **dst);
   98 
   99 static struct front_arg *cur_fa;
  100 static struct cfg_cert_file *cur_pem;
  101 extern char input_line[512];
  102 
  103 
  104 #line 105 "cfg_parser.c" /* yacc.c:337  */
  105 # ifndef YY_NULLPTR
  106 #  if defined __cplusplus
  107 #   if 201103L <= __cplusplus
  108 #    define YY_NULLPTR nullptr
  109 #   else
  110 #    define YY_NULLPTR 0
  111 #   endif
  112 #  else
  113 #   define YY_NULLPTR ((void*)0)
  114 #  endif
  115 # endif
  116 
  117 /* Enabling verbose error messages.  */
  118 #ifdef YYERROR_VERBOSE
  119 # undef YYERROR_VERBOSE
  120 # define YYERROR_VERBOSE 1
  121 #else
  122 # define YYERROR_VERBOSE 0
  123 #endif
  124 
  125 /* In a future release of Bison, this section will be replaced
  126    by #include "y.tab.h".  */
  127 #ifndef YY_YY_CFG_PARSER_H_INCLUDED
  128 # define YY_YY_CFG_PARSER_H_INCLUDED
  129 /* Debug traces.  */
  130 #ifndef YYDEBUG
  131 # define YYDEBUG 1
  132 #endif
  133 #if YYDEBUG
  134 extern int yydebug;
  135 #endif
  136 
  137 /* Token type.  */
  138 #ifndef YYTOKENTYPE
  139 # define YYTOKENTYPE
  140   enum yytokentype
  141   {
  142     INT = 258,
  143     UINT = 259,
  144     BOOL = 260,
  145     STRING = 261,
  146     TOK_CIPHERS = 262,
  147     TOK_SSL_ENGINE = 263,
  148     TOK_PREFER_SERVER_CIPHERS = 264,
  149     TOK_BACKEND = 265,
  150     TOK_FRONTEND = 266,
  151     TOK_WORKERS = 267,
  152     TOK_BACKLOG = 268,
  153     TOK_KEEPALIVE = 269,
  154     TOK_CHROOT = 270,
  155     TOK_USER = 271,
  156     TOK_GROUP = 272,
  157     TOK_QUIET = 273,
  158     TOK_SYSLOG = 274,
  159     TOK_SYSLOG_FACILITY = 275,
  160     TOK_PARAM_SYSLOG_FACILITY = 276,
  161     TOK_DAEMON = 277,
  162     TOK_WRITE_IP = 278,
  163     TOK_WRITE_PROXY = 279,
  164     TOK_WRITE_PROXY_V1 = 280,
  165     TOK_WRITE_PROXY_V2 = 281,
  166     TOK_PEM_FILE = 282,
  167     TOK_PROXY_PROXY = 283,
  168     TOK_BACKEND_CONNECT_TIMEOUT = 284,
  169     TOK_SSL_HANDSHAKE_TIMEOUT = 285,
  170     TOK_RECV_BUFSIZE = 286,
  171     TOK_SEND_BUFSIZE = 287,
  172     TOK_LOG_FILENAME = 288,
  173     TOK_RING_SLOTS = 289,
  174     TOK_RING_DATA_LEN = 290,
  175     TOK_PIDFILE = 291,
  176     TOK_SNI_NOMATCH_ABORT = 292,
  177     TOK_SSL = 293,
  178     TOK_TLS = 294,
  179     TOK_HOST = 295,
  180     TOK_PORT = 296,
  181     TOK_MATCH_GLOBAL = 297,
  182     TOK_PB_CERT = 298,
  183     TOK_PB_OCSP_FILE = 299,
  184     TOK_OCSP_VERIFY = 300,
  185     TOK_OCSP_DIR = 301,
  186     TOK_OCSP_RESP_TMO = 302,
  187     TOK_OCSP_CONN_TMO = 303,
  188     TOK_ALPN_PROTOS = 304,
  189     TOK_TLS_PROTOS = 305,
  190     TOK_SSLv3 = 306,
  191     TOK_TLSv1_0 = 307,
  192     TOK_TLSv1_1 = 308,
  193     TOK_TLSv1_2 = 309,
  194     TOK_TLSv1_3 = 310,
  195     TOK_SESSION_CACHE = 311,
  196     TOK_SHARED_CACHE_LISTEN = 312,
  197     TOK_SHARED_CACHE_PEER = 313,
  198     TOK_SHARED_CACHE_IF = 314,
  199     TOK_PRIVATE_KEY = 315,
  200     TOK_BACKEND_REFRESH = 316,
  201     TOK_OCSP_REFRESH_INTERVAL = 317,
  202     TOK_PEM_DIR = 318,
  203     TOK_PEM_DIR_GLOB = 319,
  204     TOK_LOG_LEVEL = 320,
  205     TOK_PROXY_TLV = 321,
  206     TOK_PROXY_AUTHORITY = 322,
  207     TOK_TFO = 323
  208   };
  209 #endif
  210 /* Tokens.  */
  211 #define INT 258
  212 #define UINT 259
  213 #define BOOL 260
  214 #define STRING 261
  215 #define TOK_CIPHERS 262
  216 #define TOK_SSL_ENGINE 263
  217 #define TOK_PREFER_SERVER_CIPHERS 264
  218 #define TOK_BACKEND 265
  219 #define TOK_FRONTEND 266
  220 #define TOK_WORKERS 267
  221 #define TOK_BACKLOG 268
  222 #define TOK_KEEPALIVE 269
  223 #define TOK_CHROOT 270
  224 #define TOK_USER 271
  225 #define TOK_GROUP 272
  226 #define TOK_QUIET 273
  227 #define TOK_SYSLOG 274
  228 #define TOK_SYSLOG_FACILITY 275
  229 #define TOK_PARAM_SYSLOG_FACILITY 276
  230 #define TOK_DAEMON 277
  231 #define TOK_WRITE_IP 278
  232 #define TOK_WRITE_PROXY 279
  233 #define TOK_WRITE_PROXY_V1 280
  234 #define TOK_WRITE_PROXY_V2 281
  235 #define TOK_PEM_FILE 282
  236 #define TOK_PROXY_PROXY 283
  237 #define TOK_BACKEND_CONNECT_TIMEOUT 284
  238 #define TOK_SSL_HANDSHAKE_TIMEOUT 285
  239 #define TOK_RECV_BUFSIZE 286
  240 #define TOK_SEND_BUFSIZE 287
  241 #define TOK_LOG_FILENAME 288
  242 #define TOK_RING_SLOTS 289
  243 #define TOK_RING_DATA_LEN 290
  244 #define TOK_PIDFILE 291
  245 #define TOK_SNI_NOMATCH_ABORT 292
  246 #define TOK_SSL 293
  247 #define TOK_TLS 294
  248 #define TOK_HOST 295
  249 #define TOK_PORT 296
  250 #define TOK_MATCH_GLOBAL 297
  251 #define TOK_PB_CERT 298
  252 #define TOK_PB_OCSP_FILE 299
  253 #define TOK_OCSP_VERIFY 300
  254 #define TOK_OCSP_DIR 301
  255 #define TOK_OCSP_RESP_TMO 302
  256 #define TOK_OCSP_CONN_TMO 303
  257 #define TOK_ALPN_PROTOS 304
  258 #define TOK_TLS_PROTOS 305
  259 #define TOK_SSLv3 306
  260 #define TOK_TLSv1_0 307
  261 #define TOK_TLSv1_1 308
  262 #define TOK_TLSv1_2 309
  263 #define TOK_TLSv1_3 310
  264 #define TOK_SESSION_CACHE 311
  265 #define TOK_SHARED_CACHE_LISTEN 312
  266 #define TOK_SHARED_CACHE_PEER 313
  267 #define TOK_SHARED_CACHE_IF 314
  268 #define TOK_PRIVATE_KEY 315
  269 #define TOK_BACKEND_REFRESH 316
  270 #define TOK_OCSP_REFRESH_INTERVAL 317
  271 #define TOK_PEM_DIR 318
  272 #define TOK_PEM_DIR_GLOB 319
  273 #define TOK_LOG_LEVEL 320
  274 #define TOK_PROXY_TLV 321
  275 #define TOK_PROXY_AUTHORITY 322
  276 #define TOK_TFO 323
  277 
  278 /* Value type.  */
  279 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
  280 
  281 union YYSTYPE
  282 {
  283 #line 36 "cfg_parser.y" /* yacc.c:352  */
  284 
  285     int i;
  286     char    *s;
  287 
  288 #line 289 "cfg_parser.c" /* yacc.c:352  */
  289 };
  290 
  291 typedef union YYSTYPE YYSTYPE;
  292 # define YYSTYPE_IS_TRIVIAL 1
  293 # define YYSTYPE_IS_DECLARED 1
  294 #endif
  295 
  296 
  297 extern YYSTYPE yylval;
  298 
  299 int yyparse (hitch_config *cfg);
  300 
  301 #endif /* !YY_YY_CFG_PARSER_H_INCLUDED  */
  302 
  303 
  304 
  305 #ifdef short
  306 # undef short
  307 #endif
  308 
  309 #ifdef YYTYPE_UINT8
  310 typedef YYTYPE_UINT8 yytype_uint8;
  311 #else
  312 typedef unsigned char yytype_uint8;
  313 #endif
  314 
  315 #ifdef YYTYPE_INT8
  316 typedef YYTYPE_INT8 yytype_int8;
  317 #else
  318 typedef signed char yytype_int8;
  319 #endif
  320 
  321 #ifdef YYTYPE_UINT16
  322 typedef YYTYPE_UINT16 yytype_uint16;
  323 #else
  324 typedef unsigned short yytype_uint16;
  325 #endif
  326 
  327 #ifdef YYTYPE_INT16
  328 typedef YYTYPE_INT16 yytype_int16;
  329 #else
  330 typedef short yytype_int16;
  331 #endif
  332 
  333 #ifndef YYSIZE_T
  334 # ifdef __SIZE_TYPE__
  335 #  define YYSIZE_T __SIZE_TYPE__
  336 # elif defined size_t
  337 #  define YYSIZE_T size_t
  338 # elif ! defined YYSIZE_T
  339 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
  340 #  define YYSIZE_T size_t
  341 # else
  342 #  define YYSIZE_T unsigned
  343 # endif
  344 #endif
  345 
  346 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
  347 
  348 #ifndef YY_
  349 # if defined YYENABLE_NLS && YYENABLE_NLS
  350 #  if ENABLE_NLS
  351 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
  352 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
  353 #  endif
  354 # endif
  355 # ifndef YY_
  356 #  define YY_(Msgid) Msgid
  357 # endif
  358 #endif
  359 
  360 #ifndef YY_ATTRIBUTE
  361 # if (defined __GNUC__                                               \
  362       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
  363      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
  364 #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
  365 # else
  366 #  define YY_ATTRIBUTE(Spec) /* empty */
  367 # endif
  368 #endif
  369 
  370 #ifndef YY_ATTRIBUTE_PURE
  371 # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
  372 #endif
  373 
  374 #ifndef YY_ATTRIBUTE_UNUSED
  375 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
  376 #endif
  377 
  378 /* Suppress unused-variable warnings by "using" E.  */
  379 #if ! defined lint || defined __GNUC__
  380 # define YYUSE(E) ((void) (E))
  381 #else
  382 # define YYUSE(E) /* empty */
  383 #endif
  384 
  385 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
  386 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
  387 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
  388     _Pragma ("GCC diagnostic push") \
  389     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
  390     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
  391 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
  392     _Pragma ("GCC diagnostic pop")
  393 #else
  394 # define YY_INITIAL_VALUE(Value) Value
  395 #endif
  396 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  397 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  398 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
  399 #endif
  400 #ifndef YY_INITIAL_VALUE
  401 # define YY_INITIAL_VALUE(Value) /* Nothing. */
  402 #endif
  403 
  404 
  405 #if ! defined yyoverflow || YYERROR_VERBOSE
  406 
  407 /* The parser invokes alloca or malloc; define the necessary symbols.  */
  408 
  409 # ifdef YYSTACK_USE_ALLOCA
  410 #  if YYSTACK_USE_ALLOCA
  411 #   ifdef __GNUC__
  412 #    define YYSTACK_ALLOC __builtin_alloca
  413 #   elif defined __BUILTIN_VA_ARG_INCR
  414 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
  415 #   elif defined _AIX
  416 #    define YYSTACK_ALLOC __alloca
  417 #   elif defined _MSC_VER
  418 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
  419 #    define alloca _alloca
  420 #   else
  421 #    define YYSTACK_ALLOC alloca
  422 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
  423 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
  424       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
  425 #     ifndef EXIT_SUCCESS
  426 #      define EXIT_SUCCESS 0
  427 #     endif
  428 #    endif
  429 #   endif
  430 #  endif
  431 # endif
  432 
  433 # ifdef YYSTACK_ALLOC
  434    /* Pacify GCC's 'empty if-body' warning.  */
  435 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
  436 #  ifndef YYSTACK_ALLOC_MAXIMUM
  437     /* The OS might guarantee only one guard page at the bottom of the stack,
  438        and a page size can be as small as 4096 bytes.  So we cannot safely
  439        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
  440        to allow for a few compiler-allocated temporary stack slots.  */
  441 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
  442 #  endif
  443 # else
  444 #  define YYSTACK_ALLOC YYMALLOC
  445 #  define YYSTACK_FREE YYFREE
  446 #  ifndef YYSTACK_ALLOC_MAXIMUM
  447 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
  448 #  endif
  449 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
  450        && ! ((defined YYMALLOC || defined malloc) \
  451              && (defined YYFREE || defined free)))
  452 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
  453 #   ifndef EXIT_SUCCESS
  454 #    define EXIT_SUCCESS 0
  455 #   endif
  456 #  endif
  457 #  ifndef YYMALLOC
  458 #   define YYMALLOC malloc
  459 #   if ! defined malloc && ! defined EXIT_SUCCESS
  460 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
  461 #   endif
  462 #  endif
  463 #  ifndef YYFREE
  464 #   define YYFREE free
  465 #   if ! defined free && ! defined EXIT_SUCCESS
  466 void free (void *); /* INFRINGES ON USER NAME SPACE */
  467 #   endif
  468 #  endif
  469 # endif
  470 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
  471 
  472 
  473 #if (! defined yyoverflow \
  474      && (! defined __cplusplus \
  475          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
  476 
  477 /* A type that is properly aligned for any stack member.  */
  478 union yyalloc
  479 {
  480   yytype_int16 yyss_alloc;
  481   YYSTYPE yyvs_alloc;
  482 };
  483 
  484 /* The size of the maximum gap between one aligned stack and the next.  */
  485 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
  486 
  487 /* The size of an array large to enough to hold all stacks, each with
  488    N elements.  */
  489 # define YYSTACK_BYTES(N) \
  490      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
  491       + YYSTACK_GAP_MAXIMUM)
  492 
  493 # define YYCOPY_NEEDED 1
  494 
  495 /* Relocate STACK from its old location to the new one.  The
  496    local variables YYSIZE and YYSTACKSIZE give the old and new number of
  497    elements in the stack, and YYPTR gives the new location of the
  498    stack.  Advance YYPTR to a properly aligned location for the next
  499    stack.  */
  500 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
  501     do                                                                  \
  502       {                                                                 \
  503         YYSIZE_T yynewbytes;                                            \
  504         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
  505         Stack = &yyptr->Stack_alloc;                                    \
  506         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
  507         yyptr += yynewbytes / sizeof (*yyptr);                          \
  508       }                                                                 \
  509     while (0)
  510 
  511 #endif
  512 
  513 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
  514 /* Copy COUNT objects from SRC to DST.  The source and destination do
  515    not overlap.  */
  516 # ifndef YYCOPY
  517 #  if defined __GNUC__ && 1 < __GNUC__
  518 #   define YYCOPY(Dst, Src, Count) \
  519       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
  520 #  else
  521 #   define YYCOPY(Dst, Src, Count)              \
  522       do                                        \
  523         {                                       \
  524           YYSIZE_T yyi;                         \
  525           for (yyi = 0; yyi < (Count); yyi++)   \
  526             (Dst)[yyi] = (Src)[yyi];            \
  527         }                                       \
  528       while (0)
  529 #  endif
  530 # endif
  531 #endif /* !YYCOPY_NEEDED */
  532 
  533 /* YYFINAL -- State number of the termination state.  */
  534 #define YYFINAL  138
  535 /* YYLAST -- Last index in YYTABLE.  */
  536 #define YYLAST   200
  537 
  538 /* YYNTOKENS -- Number of terminals.  */
  539 #define YYNTOKENS  72
  540 /* YYNNTS -- Number of nonterminals.  */
  541 #define YYNNTS  76
  542 /* YYNRULES -- Number of rules.  */
  543 #define YYNRULES  148
  544 /* YYNSTATES -- Number of states.  */
  545 #define YYNSTATES  272
  546 
  547 #define YYUNDEFTOK  2
  548 #define YYMAXUTOK   323
  549 
  550 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
  551    as returned by yylex, with out-of-bounds checking.  */
  552 #define YYTRANSLATE(YYX)                                                \
  553   ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
  554 
  555 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
  556    as returned by yylex.  */
  557 static const yytype_uint8 yytranslate[] =
  558 {
  559        0,     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,    69,     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,     2,     2,     2,     2,
  571        2,     2,     2,    70,     2,    71,     2,     2,     2,     2,
  572        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  573        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  574        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  575        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  576        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  577        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  578        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  579        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  580        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  581        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  582        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  583        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  584        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
  585        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
  586       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  587       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
  588       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
  589       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
  590       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
  591       65,    66,    67,    68
  592 };
  593 
  594 #if YYDEBUG
  595   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
  596 static const yytype_uint16 yyrline[] =
  597 {
  598        0,    67,    67,    71,    72,    76,    77,    78,    79,    80,
  599       81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
  600       91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
  601      101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
  602      111,   112,   113,   114,   115,   116,   117,   118,   119,   123,
  603      129,   129,   140,   142,   143,   147,   148,   149,   150,   151,
  604      152,   153,   154,   155,   156,   159,   168,   170,   173,   174,
  605      178,   179,   180,   181,   184,   186,   191,   198,   202,   215,
  606      223,   230,   234,   238,   243,   257,   257,   272,   274,   279,
  607      296,   313,   313,   325,   325,   327,   328,   329,   330,   331,
  608      333,   337,   341,   348,   350,   352,   354,   369,   384,   384,
  609      394,   394,   396,   397,   398,   399,   400,   402,   404,   408,
  610      415,   423,   429,   429,   448,   449,   450,   454,   456,   463,
  611      470,   472,   474,   478,   482,   484,   486,   488,   495,   503,
  612      505,   507,   515,   517,   527,   540,   553,   566,   576
  613 };
  614 #endif
  615 
  616 #if YYDEBUG || YYERROR_VERBOSE || 0
  617 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
  618    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
  619 static const char *const yytname[] =
  620 {
  621   "$end", "error", "$undefined", "INT", "UINT", "BOOL", "STRING",
  622   "TOK_CIPHERS", "TOK_SSL_ENGINE", "TOK_PREFER_SERVER_CIPHERS",
  623   "TOK_BACKEND", "TOK_FRONTEND", "TOK_WORKERS", "TOK_BACKLOG",
  624   "TOK_KEEPALIVE", "TOK_CHROOT", "TOK_USER", "TOK_GROUP", "TOK_QUIET",
  625   "TOK_SYSLOG", "TOK_SYSLOG_FACILITY", "TOK_PARAM_SYSLOG_FACILITY",
  626   "TOK_DAEMON", "TOK_WRITE_IP", "TOK_WRITE_PROXY", "TOK_WRITE_PROXY_V1",
  627   "TOK_WRITE_PROXY_V2", "TOK_PEM_FILE", "TOK_PROXY_PROXY",
  628   "TOK_BACKEND_CONNECT_TIMEOUT", "TOK_SSL_HANDSHAKE_TIMEOUT",
  629   "TOK_RECV_BUFSIZE", "TOK_SEND_BUFSIZE", "TOK_LOG_FILENAME",
  630   "TOK_RING_SLOTS", "TOK_RING_DATA_LEN", "TOK_PIDFILE",
  631   "TOK_SNI_NOMATCH_ABORT", "TOK_SSL", "TOK_TLS", "TOK_HOST", "TOK_PORT",
  632   "TOK_MATCH_GLOBAL", "TOK_PB_CERT", "TOK_PB_OCSP_FILE", "TOK_OCSP_VERIFY",
  633   "TOK_OCSP_DIR", "TOK_OCSP_RESP_TMO", "TOK_OCSP_CONN_TMO",
  634   "TOK_ALPN_PROTOS", "TOK_TLS_PROTOS", "TOK_SSLv3", "TOK_TLSv1_0",
  635   "TOK_TLSv1_1", "TOK_TLSv1_2", "TOK_TLSv1_3", "TOK_SESSION_CACHE",
  636   "TOK_SHARED_CACHE_LISTEN", "TOK_SHARED_CACHE_PEER",
  637   "TOK_SHARED_CACHE_IF", "TOK_PRIVATE_KEY", "TOK_BACKEND_REFRESH",
  638   "TOK_OCSP_REFRESH_INTERVAL", "TOK_PEM_DIR", "TOK_PEM_DIR_GLOB",
  639   "TOK_LOG_LEVEL", "TOK_PROXY_TLV", "TOK_PROXY_AUTHORITY", "TOK_TFO",
  640   "'='", "'{'", "'}'", "$accept", "CFG", "CFG_RECORDS", "CFG_RECORD",
  641   "FRONTEND_REC", "$@1", "FRONTEND_BLK", "FB_RECS", "FB_REC", "FB_HOST",
  642   "FB_PORT", "PEM_BLK", "PB_RECS", "PB_REC", "PB_CERT",
  643   "PB_OCSP_RESP_FILE", "OCSP_VERIFY", "PRIVATE_KEY", "PEM_DIR",
  644   "PEM_DIR_GLOB", "OCSP_DIR", "OCSP_RESP_TMO", "OCSP_CONN_TMO",
  645   "OCSP_REFRESH_INTERVAL", "FB_CERT", "$@2", "FB_MATCH_GLOBAL",
  646   "FB_SNI_NOMATCH_ABORT", "FB_TLS", "FB_SSL", "FB_TLS_PROTOS", "$@3",
  647   "FB_TLS_PROTOS_LIST", "FB_TLS_PROTO", "FB_CIPHERS", "FB_PREF_SRV_CIPH",
  648   "QUIET_REC", "WORKERS_REC", "BACKLOG_REC", "KEEPALIVE_REC", "TLS_REC",
  649   "SSL_REC", "TLS_PROTOS_REC", "$@4", "TLS_PROTOS_LIST", "TLS_PROTO",
  650   "SSL_ENGINE_REC", "PREFER_SERVER_CIPHERS_REC", "CHROOT_REC",
  651   "BACKEND_REC", "PEM_FILE_REC", "$@5", "SYSLOG_REC", "DAEMON_REC",
  652   "SNI_NOMATCH_ABORT_REC", "CIPHERS_REC", "USER_REC", "GROUP_REC",
  653   "WRITE_IP_REC", "WRITE_PROXY_REC", "WRITE_PROXY_V1_REC",
  654   "WRITE_PROXY_V2_REC", "PROXY_TLV_REC", "PROXY_PROXY_REC",
  655   "ALPN_PROTOS_REC", "SYSLOG_FACILITY_REC", "SEND_BUFSIZE_REC",
  656   "RECV_BUFSIZE_REC", "LOG_FILENAME_REC", "LOG_LEVEL_REC",
  657   "SESSION_CACHE_REC", "SHARED_CACHE_LISTEN_REC", "SHARED_CACHE_PEER_REC",
  658   "SHARED_CACHE_IF_REC", "TFO", "BACKEND_REFRESH_REC", YY_NULLPTR
  659 };
  660 #endif
  661 
  662 # ifdef YYPRINT
  663 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
  664    (internal) symbol number NUM (which must be that of a token).  */
  665 static const yytype_uint16 yytoknum[] =
  666 {
  667        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
  668      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
  669      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
  670      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
  671      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
  672      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
  673      315,   316,   317,   318,   319,   320,   321,   322,   323,    61,
  674      123,   125
  675 };
  676 # endif
  677 
  678 #define YYPACT_NINF -73
  679 
  680 #define yypact_value_is_default(Yystate) \
  681   (!!((Yystate) == (-73)))
  682 
  683 #define YYTABLE_NINF -1
  684 
  685 #define yytable_value_is_error(Yytable_value) \
  686   0
  687 
  688   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
  689      STATE-NUM.  */
  690 static const yytype_int16 yypact[] =
  691 {
  692       11,   -66,   -29,   -24,   -23,   -22,   -17,   -16,   -15,   -14,
  693       -7,     2,    12,    14,    15,    16,    17,    18,    19,    20,
  694       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
  695       32,    33,    34,   -73,    35,    36,    37,    38,    39,    40,
  696       47,    48,    49,    50,    51,    52,    41,    11,   -73,   -73,
  697      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  698      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  699      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  700      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  701      -73,   -73,   -73,    57,   116,   119,   120,    -6,   121,   123,
  702      124,   125,   126,   127,   129,   130,   131,   133,   134,   135,
  703      136,   137,    -5,   138,   132,   140,   139,   141,   142,   143,
  704      144,   145,   146,   148,   147,    60,   150,   149,   151,   152,
  705      155,   156,   157,   158,   161,   162,   163,   164,   -73,   -73,
  706      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  707      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  708      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  709      -73,   -73,   -73,   -73,   -46,   -73,   -73,   -73,   -73,   -73,
  710      -73,   -73,   -73,   -73,   -73,   -73,   -73,    73,   -28,   -73,
  711      -73,   -73,   -73,   -73,   -46,   -73,    61,    87,    92,    93,
  712       97,   101,   102,   103,   104,   -73,   105,    73,   -73,   -73,
  713      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   106,
  714      108,   109,   110,   -28,   -73,   -73,   -73,   -73,   -73,   -73,
  715      168,   174,    -4,   175,   177,   178,   179,   180,   182,   115,
  716      -73,   -73,   183,   184,   185,   -73,   -73,   -73,   -73,   -73,
  717      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -41,   -73,   -73,
  718      -73,   -28,   -73,   -73,   -73,   -73,   -73,   -41,   -73,   117,
  719      -73,   -73
  720 };
  721 
  722   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
  723      Performed when YYTABLE does not specify something else to do.  Zero
  724      means the default is an error.  */
  725 static const yytype_uint8 yydefact[] =
  726 {
  727        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  728        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  729        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  730        0,     0,     0,   108,     0,     0,     0,     0,     0,     0,
  731        0,     0,     0,     0,     0,     0,     0,     2,     3,     5,
  732       32,    37,    38,    36,    33,    34,    35,    20,    14,    15,
  733       16,     9,    10,    11,    13,    12,    17,     6,     7,    21,
  734       23,    31,     8,    18,    19,    24,    25,    26,    27,    30,
  735       28,    29,    22,    45,    46,    43,    44,    39,    40,    41,
  736       42,    48,    47,     0,     0,     0,     0,     0,     0,     0,
  737        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  738        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  739        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  740        0,     0,     0,     0,     0,     0,     0,     0,     1,     4,
  741      127,   117,   118,   120,    49,    50,   103,   104,   105,   119,
  742      128,   129,   102,   124,   138,   125,   130,   131,   132,   133,
  743      121,   122,   136,   140,   139,   141,   126,   107,   106,    76,
  744       80,    81,    82,   137,     0,   143,   144,   145,   146,   148,
  745       83,    78,    79,   142,   134,   135,   147,     0,     0,   112,
  746      113,   114,   115,   116,   109,   110,     0,     0,     0,     0,
  747        0,     0,     0,     0,     0,    91,     0,    52,    53,    55,
  748       56,    57,    58,    59,    60,    61,    62,    63,    64,     0,
  749        0,     0,     0,    67,    68,    70,    71,    72,    73,   111,
  750        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  751       51,    54,     0,     0,     0,   123,    69,   100,   101,    84,
  752       85,    88,    90,    89,    65,    66,    87,     0,    74,    75,
  753       77,     0,    95,    96,    97,    98,    99,    92,    93,     0,
  754       94,    86
  755 };
  756 
  757   /* YYPGOTO[NTERM-NUM].  */
  758 static const yytype_int16 yypgoto[] =
  759 {
  760      -73,   -73,   -73,   153,   -73,   -73,   -73,   -73,   -13,   -73,
  761      -73,   -69,   -73,   -30,   -73,   -73,     4,   -73,   -73,   -73,
  762      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  763      -73,   -73,   -73,   -72,   -73,   -73,   -73,   -73,   -73,   -73,
  764      -73,   -73,   -73,   -73,   -73,     3,   -73,   -73,   -73,   -73,
  765      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  766      -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
  767      -73,   -73,   -73,   -73,   -73,   -73
  768 };
  769 
  770   /* YYDEFGOTO[NTERM-NUM].  */
  771 static const yytype_int16 yydefgoto[] =
  772 {
  773       -1,    46,    47,    48,    49,   187,   206,   207,   208,   209,
  774      210,   222,   223,   224,   225,   226,   227,   228,    51,    52,
  775       53,    54,    55,    56,   211,   261,   212,   213,   214,   215,
  776      216,   239,   267,   268,   217,   218,    57,    58,    59,    60,
  777       61,    62,    63,   125,   194,   195,    64,    65,    66,    67,
  778       68,   188,    69,    70,    71,    72,    73,    74,    75,    76,
  779       77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
  780       87,    88,    89,    90,    91,    92
  781 };
  782 
  783   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
  784      positive, shift that token.  If negative, reduce the rule whose
  785      number is the opposite.  If YYTABLE_NINF, syntax error.  */
  786 static const yytype_uint16 yytable[] =
  787 {
  788      144,   160,   249,    93,    50,   189,   190,   191,   192,   193,
  789      262,   263,   264,   265,   266,   219,   220,    28,     1,     2,
  790        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
  791       13,    14,   221,    15,    16,    17,    18,    19,    20,    21,
  792       94,   138,    22,    23,    24,    95,    96,    97,    25,    26,
  793       27,    50,    98,    99,   100,   101,    28,    29,    30,    31,
  794       32,    33,   102,   140,   145,   161,   250,    34,    35,    36,
  795       37,   103,    38,    39,    40,    41,    42,    43,    44,    45,
  796      196,   104,   197,   105,   106,   107,   108,   109,   110,   111,
  797      112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
  798      198,   122,   123,   124,   126,   127,   128,   129,   130,   131,
  799      199,   200,   201,   202,   203,   204,   132,   133,   134,   135,
  800      136,   137,   141,   205,   142,   146,   143,   147,   148,   174,
  801      230,   149,   150,   151,   152,   153,   163,   154,   155,   156,
  802      157,   158,   159,   162,   164,   165,   166,   167,   168,   169,
  803      171,   170,   172,   173,   175,   176,   231,   177,   178,   179,
  804      180,   232,   233,   181,   182,   183,   234,   184,   185,   186,
  805      235,   236,   237,   238,   247,   242,   240,   243,   244,   248,
  806      251,   245,   252,   253,   257,   254,   255,   256,   271,   258,
  807      259,   260,   269,   246,   241,   270,     0,   229,     0,     0,
  808      139
  809 };
  810 
  811 static const yytype_int16 yycheck[] =
  812 {
  813        6,     6,     6,    69,     0,    51,    52,    53,    54,    55,
  814       51,    52,    53,    54,    55,    43,    44,    45,     7,     8,
  815        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
  816       19,    20,    60,    22,    23,    24,    25,    26,    27,    28,
  817       69,     0,    31,    32,    33,    69,    69,    69,    37,    38,
  818       39,    47,    69,    69,    69,    69,    45,    46,    47,    48,
  819       49,    50,    69,     6,    70,    70,    70,    56,    57,    58,
  820       59,    69,    61,    62,    63,    64,    65,    66,    67,    68,
  821        7,    69,     9,    69,    69,    69,    69,    69,    69,    69,
  822       69,    69,    69,    69,    69,    69,    69,    69,    69,    69,
  823       27,    69,    69,    69,    69,    69,    69,    69,    69,    69,
  824       37,    38,    39,    40,    41,    42,    69,    69,    69,    69,
  825       69,    69,     6,    50,     5,     4,     6,     4,     4,    69,
  826       69,     6,     6,     6,     5,     5,     4,     6,     5,     5,
  827        5,     5,     5,     5,     4,     6,     5,     5,     5,     5,
  828        4,     6,     4,     6,     4,     6,    69,     6,     6,     4,
  829        4,    69,    69,     6,     6,     4,    69,     5,     5,     5,
  830       69,    69,    69,    69,     6,    69,    71,    69,    69,     5,
  831        5,    71,     5,     5,    69,     6,     6,     5,    71,     6,
  832        6,     6,   261,   223,   207,   267,    -1,   194,    -1,    -1,
  833       47
  834 };
  835 
  836   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
  837      symbol of state STATE-NUM.  */
  838 static const yytype_uint8 yystos[] =
  839 {
  840        0,     7,     8,     9,    10,    11,    12,    13,    14,    15,
  841       16,    17,    18,    19,    20,    22,    23,    24,    25,    26,
  842       27,    28,    31,    32,    33,    37,    38,    39,    45,    46,
  843       47,    48,    49,    50,    56,    57,    58,    59,    61,    62,
  844       63,    64,    65,    66,    67,    68,    73,    74,    75,    76,
  845       88,    90,    91,    92,    93,    94,    95,   108,   109,   110,
  846      111,   112,   113,   114,   118,   119,   120,   121,   122,   124,
  847      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
  848      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
  849      145,   146,   147,    69,    69,    69,    69,    69,    69,    69,
  850       69,    69,    69,    69,    69,    69,    69,    69,    69,    69,
  851       69,    69,    69,    69,    69,    69,    69,    69,    69,    69,
  852       69,    69,    69,    69,    69,   115,    69,    69,    69,    69,
  853       69,    69,    69,    69,    69,    69,    69,    69,     0,    75,
  854        6,     6,     5,     6,     6,    70,     4,     4,     4,     6,
  855        6,     6,     5,     5,     6,     5,     5,     5,     5,     5,
  856        6,    70,     5,     4,     4,     6,     5,     5,     5,     5,
  857        6,     4,     4,     6,    69,     4,     6,     6,     6,     4,
  858        4,     6,     6,     4,     5,     5,     5,    77,   123,    51,
  859       52,    53,    54,    55,   116,   117,     7,     9,    27,    37,
  860       38,    39,    40,    41,    42,    50,    78,    79,    80,    81,
  861       82,    96,    98,    99,   100,   101,   102,   106,   107,    43,
  862       44,    60,    83,    84,    85,    86,    87,    88,    89,   117,
  863       69,    69,    69,    69,    69,    69,    69,    69,    69,   103,
  864       71,    80,    69,    69,    69,    71,    85,     6,     5,     6,
  865       70,     5,     5,     5,     6,     6,     5,    69,     6,     6,
  866        6,    97,    51,    52,    53,    54,    55,   104,   105,    83,
  867      105,    71
  868 };
  869 
  870   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
  871 static const yytype_uint8 yyr1[] =
  872 {
  873        0,    72,    73,    74,    74,    75,    75,    75,    75,    75,
  874       75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
  875       75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
  876       75,    75,    75,    75,    75,    75,    75,    75,    75,    75,
  877       75,    75,    75,    75,    75,    75,    75,    75,    75,    76,
  878       77,    76,    78,    79,    79,    80,    80,    80,    80,    80,
  879       80,    80,    80,    80,    80,    81,    82,    83,    84,    84,
  880       85,    85,    85,    85,    86,    87,    88,    89,    90,    91,
  881       92,    93,    94,    95,    96,    97,    96,    98,    99,   100,
  882      101,   103,   102,   104,   104,   105,   105,   105,   105,   105,
  883      106,   107,   108,   109,   110,   111,   112,   113,   115,   114,
  884      116,   116,   117,   117,   117,   117,   117,   118,   119,   120,
  885      121,   122,   123,   122,   124,   125,   126,   127,   128,   129,
  886      130,   131,   132,   133,   134,   134,   135,   136,   137,   138,
  887      139,   140,   141,   142,   143,   144,   145,   146,   147
  888 };
  889 
  890   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
  891 static const yytype_uint8 yyr2[] =
  892 {
  893        0,     2,     1,     1,     2,     1,     1,     1,     1,     1,
  894        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
  895        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
  896        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
  897        1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
  898        0,     6,     1,     1,     2,     1,     1,     1,     1,     1,
  899        1,     1,     1,     1,     1,     3,     3,     1,     1,     2,
  900        1,     1,     1,     1,     3,     3,     3,     3,     3,     3,
  901        3,     3,     3,     3,     3,     0,     6,     3,     3,     3,
  902        3,     0,     4,     1,     2,     1,     1,     1,     1,     1,
  903        3,     3,     3,     3,     3,     3,     3,     3,     0,     4,
  904        1,     2,     1,     1,     1,     1,     1,     3,     3,     3,
  905        3,     3,     0,     6,     3,     3,     3,     3,     3,     3,
  906        3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  907        3,     3,     3,     3,     3,     3,     3,     3,     3
  908 };
  909 
  910 
  911 #define yyerrok         (yyerrstatus = 0)
  912 #define yyclearin       (yychar = YYEMPTY)
  913 #define YYEMPTY         (-2)
  914 #define YYEOF           0
  915 
  916 #define YYACCEPT        goto yyacceptlab
  917 #define YYABORT         goto yyabortlab
  918 #define YYERROR         goto yyerrorlab
  919 
  920 
  921 #define YYRECOVERING()  (!!yyerrstatus)
  922 
  923 #define YYBACKUP(Token, Value)                                    \
  924   do                                                              \
  925     if (yychar == YYEMPTY)                                        \
  926       {                                                           \
  927         yychar = (Token);                                         \
  928         yylval = (Value);                                         \
  929         YYPOPSTACK (yylen);                                       \
  930         yystate = *yyssp;                                         \
  931         goto yybackup;                                            \
  932       }                                                           \
  933     else                                                          \
  934       {                                                           \
  935         yyerror (cfg, YY_("syntax error: cannot back up")); \
  936         YYERROR;                                                  \
  937       }                                                           \
  938   while (0)
  939 
  940 /* Error token number */
  941 #define YYTERROR        1
  942 #define YYERRCODE       256
  943 
  944 
  945 
  946 /* Enable debugging if requested.  */
  947 #if YYDEBUG
  948 
  949 # ifndef YYFPRINTF
  950 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
  951 #  define YYFPRINTF fprintf
  952 # endif
  953 
  954 # define YYDPRINTF(Args)                        \
  955 do {                                            \
  956   if (yydebug)                                  \
  957     YYFPRINTF Args;                             \
  958 } while (0)
  959 
  960 /* This macro is provided for backward compatibility. */
  961 #ifndef YY_LOCATION_PRINT
  962 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
  963 #endif
  964 
  965 
  966 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
  967 do {                                                                      \
  968   if (yydebug)                                                            \
  969     {                                                                     \
  970       YYFPRINTF (stderr, "%s ", Title);                                   \
  971       yy_symbol_print (stderr,                                            \
  972                   Type, Value, cfg); \
  973       YYFPRINTF (stderr, "\n");                                           \
  974     }                                                                     \
  975 } while (0)
  976 
  977 
  978 /*-----------------------------------.
  979 | Print this symbol's value on YYO.  |
  980 `-----------------------------------*/
  981 
  982 static void
  983 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, hitch_config *cfg)
  984 {
  985   FILE *yyoutput = yyo;
  986   YYUSE (yyoutput);
  987   YYUSE (cfg);
  988   if (!yyvaluep)
  989     return;
  990 # ifdef YYPRINT
  991   if (yytype < YYNTOKENS)
  992     YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
  993 # endif
  994   YYUSE (yytype);
  995 }
  996 
  997 
  998 /*---------------------------.
  999 | Print this symbol on YYO.  |
 1000 `---------------------------*/
 1001 
 1002 static void
 1003 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, hitch_config *cfg)
 1004 {
 1005   YYFPRINTF (yyo, "%s %s (",
 1006              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 1007 
 1008   yy_symbol_value_print (yyo, yytype, yyvaluep, cfg);
 1009   YYFPRINTF (yyo, ")");
 1010 }
 1011 
 1012 /*------------------------------------------------------------------.
 1013 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 1014 | TOP (included).                                                   |
 1015 `------------------------------------------------------------------*/
 1016 
 1017 static void
 1018 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
 1019 {
 1020   YYFPRINTF (stderr, "Stack now");
 1021   for (; yybottom <= yytop; yybottom++)
 1022     {
 1023       int yybot = *yybottom;
 1024       YYFPRINTF (stderr, " %d", yybot);
 1025     }
 1026   YYFPRINTF (stderr, "\n");
 1027 }
 1028 
 1029 # define YY_STACK_PRINT(Bottom, Top)                            \
 1030 do {                                                            \
 1031   if (yydebug)                                                  \
 1032     yy_stack_print ((Bottom), (Top));                           \
 1033 } while (0)
 1034 
 1035 
 1036 /*------------------------------------------------.
 1037 | Report that the YYRULE is going to be reduced.  |
 1038 `------------------------------------------------*/
 1039 
 1040 static void
 1041 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, hitch_config *cfg)
 1042 {
 1043   unsigned long yylno = yyrline[yyrule];
 1044   int yynrhs = yyr2[yyrule];
 1045   int yyi;
 1046   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 1047              yyrule - 1, yylno);
 1048   /* The symbols being reduced.  */
 1049   for (yyi = 0; yyi < yynrhs; yyi++)
 1050     {
 1051       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 1052       yy_symbol_print (stderr,
 1053                        yystos[yyssp[yyi + 1 - yynrhs]],
 1054                        &yyvsp[(yyi + 1) - (yynrhs)]
 1055                                               , cfg);
 1056       YYFPRINTF (stderr, "\n");
 1057     }
 1058 }
 1059 
 1060 # define YY_REDUCE_PRINT(Rule)          \
 1061 do {                                    \
 1062   if (yydebug)                          \
 1063     yy_reduce_print (yyssp, yyvsp, Rule, cfg); \
 1064 } while (0)
 1065 
 1066 /* Nonzero means print parse trace.  It is left uninitialized so that
 1067    multiple parsers can coexist.  */
 1068 int yydebug;
 1069 #else /* !YYDEBUG */
 1070 # define YYDPRINTF(Args)
 1071 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 1072 # define YY_STACK_PRINT(Bottom, Top)
 1073 # define YY_REDUCE_PRINT(Rule)
 1074 #endif /* !YYDEBUG */
 1075 
 1076 
 1077 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 1078 #ifndef YYINITDEPTH
 1079 # define YYINITDEPTH 200
 1080 #endif
 1081 
 1082 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 1083    if the built-in stack extension method is used).
 1084 
 1085    Do not make this value too large; the results are undefined if
 1086    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 1087    evaluated with infinite-precision integer arithmetic.  */
 1088 
 1089 #ifndef YYMAXDEPTH
 1090 # define YYMAXDEPTH 10000
 1091 #endif
 1092 
 1093 
 1094 #if YYERROR_VERBOSE
 1095 
 1096 # ifndef yystrlen
 1097 #  if defined __GLIBC__ && defined _STRING_H
 1098 #   define yystrlen strlen
 1099 #  else
 1100 /* Return the length of YYSTR.  */
 1101 static YYSIZE_T
 1102 yystrlen (const char *yystr)
 1103 {
 1104   YYSIZE_T yylen;
 1105   for (yylen = 0; yystr[yylen]; yylen++)
 1106     continue;
 1107   return yylen;
 1108 }
 1109 #  endif
 1110 # endif
 1111 
 1112 # ifndef yystpcpy
 1113 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 1114 #   define yystpcpy stpcpy
 1115 #  else
 1116 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 1117    YYDEST.  */
 1118 static char *
 1119 yystpcpy (char *yydest, const char *yysrc)
 1120 {
 1121   char *yyd = yydest;
 1122   const char *yys = yysrc;
 1123 
 1124   while ((*yyd++ = *yys++) != '\0')
 1125     continue;
 1126 
 1127   return yyd - 1;
 1128 }
 1129 #  endif
 1130 # endif
 1131 
 1132 # ifndef yytnamerr
 1133 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 1134    quotes and backslashes, so that it's suitable for yyerror.  The
 1135    heuristic is that double-quoting is unnecessary unless the string
 1136    contains an apostrophe, a comma, or backslash (other than
 1137    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 1138    null, do not copy; instead, return the length of what the result
 1139    would have been.  */
 1140 static YYSIZE_T
 1141 yytnamerr (char *yyres, const char *yystr)
 1142 {
 1143   if (*yystr == '"')
 1144     {
 1145       YYSIZE_T yyn = 0;
 1146       char const *yyp = yystr;
 1147 
 1148       for (;;)
 1149         switch (*++yyp)
 1150           {
 1151           case '\'':
 1152           case ',':
 1153             goto do_not_strip_quotes;
 1154 
 1155           case '\\':
 1156             if (*++yyp != '\\')
 1157               goto do_not_strip_quotes;
 1158             else
 1159               goto append;
 1160 
 1161           append:
 1162           default:
 1163             if (yyres)
 1164               yyres[yyn] = *yyp;
 1165             yyn++;
 1166             break;
 1167 
 1168           case '"':
 1169             if (yyres)
 1170               yyres[yyn] = '\0';
 1171             return yyn;
 1172           }
 1173     do_not_strip_quotes: ;
 1174     }
 1175 
 1176   if (! yyres)
 1177     return yystrlen (yystr);
 1178 
 1179   return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
 1180 }
 1181 # endif
 1182 
 1183 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
 1184    about the unexpected token YYTOKEN for the state stack whose top is
 1185    YYSSP.
 1186 
 1187    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
 1188    not large enough to hold the message.  In that case, also set
 1189    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
 1190    required number of bytes is too large to store.  */
 1191 static int
 1192 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 1193                 yytype_int16 *yyssp, int yytoken)
 1194 {
 1195   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
 1196   YYSIZE_T yysize = yysize0;
 1197   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 1198   /* Internationalized format string. */
 1199   const char *yyformat = YY_NULLPTR;
 1200   /* Arguments of yyformat. */
 1201   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 1202   /* Number of reported tokens (one for the "unexpected", one per
 1203      "expected"). */
 1204   int yycount = 0;
 1205 
 1206   /* There are many possibilities here to consider:
 1207      - If this state is a consistent state with a default action, then
 1208        the only way this function was invoked is if the default action
 1209        is an error action.  In that case, don't check for expected
 1210        tokens because there are none.
 1211      - The only way there can be no lookahead present (in yychar) is if
 1212        this state is a consistent state with a default action.  Thus,
 1213        detecting the absence of a lookahead is sufficient to determine
 1214        that there is no unexpected or expected token to report.  In that
 1215        case, just report a simple "syntax error".
 1216      - Don't assume there isn't a lookahead just because this state is a
 1217        consistent state with a default action.  There might have been a
 1218        previous inconsistent state, consistent state with a non-default
 1219        action, or user semantic action that manipulated yychar.
 1220      - Of course, the expected token list depends on states to have
 1221        correct lookahead information, and it depends on the parser not
 1222        to perform extra reductions after fetching a lookahead from the
 1223        scanner and before detecting a syntax error.  Thus, state merging
 1224        (from LALR or IELR) and default reductions corrupt the expected
 1225        token list.  However, the list is correct for canonical LR with
 1226        one exception: it will still contain any token that will not be
 1227        accepted due to an error action in a later state.
 1228   */
 1229   if (yytoken != YYEMPTY)
 1230     {
 1231       int yyn = yypact[*yyssp];
 1232       yyarg[yycount++] = yytname[yytoken];
 1233       if (!yypact_value_is_default (yyn))
 1234         {
 1235           /* Start YYX at -YYN if negative to avoid negative indexes in
 1236              YYCHECK.  In other words, skip the first -YYN actions for
 1237              this state because they are default actions.  */
 1238           int yyxbegin = yyn < 0 ? -yyn : 0;
 1239           /* Stay within bounds of both yycheck and yytname.  */
 1240           int yychecklim = YYLAST - yyn + 1;
 1241           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 1242           int yyx;
 1243 
 1244           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 1245             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
 1246                 && !yytable_value_is_error (yytable[yyx + yyn]))
 1247               {
 1248                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 1249                   {
 1250                     yycount = 1;
 1251                     yysize = yysize0;
 1252                     break;
 1253                   }
 1254                 yyarg[yycount++] = yytname[yyx];
 1255                 {
 1256                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
 1257                   if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
 1258                     yysize = yysize1;
 1259                   else
 1260                     return 2;
 1261                 }
 1262               }
 1263         }
 1264     }
 1265 
 1266   switch (yycount)
 1267     {
 1268 # define YYCASE_(N, S)                      \
 1269       case N:                               \
 1270         yyformat = S;                       \
 1271       break
 1272     default: /* Avoid compiler warnings. */
 1273       YYCASE_(0, YY_("syntax error"));
 1274       YYCASE_(1, YY_("syntax error, unexpected %s"));
 1275       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
 1276       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
 1277       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
 1278       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
 1279 # undef YYCASE_
 1280     }
 1281 
 1282   {
 1283     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
 1284     if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
 1285       yysize = yysize1;
 1286     else
 1287       return 2;
 1288   }
 1289 
 1290   if (*yymsg_alloc < yysize)
 1291     {
 1292       *yymsg_alloc = 2 * yysize;
 1293       if (! (yysize <= *yymsg_alloc
 1294              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
 1295         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
 1296       return 1;
 1297     }
 1298 
 1299   /* Avoid sprintf, as that infringes on the user's name space.
 1300      Don't have undefined behavior even if the translation
 1301      produced a string with the wrong number of "%s"s.  */
 1302   {
 1303     char *yyp = *yymsg;
 1304     int yyi = 0;
 1305     while ((*yyp = *yyformat) != '\0')
 1306       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
 1307         {
 1308           yyp += yytnamerr (yyp, yyarg[yyi++]);
 1309           yyformat += 2;
 1310         }
 1311       else
 1312         {
 1313           yyp++;
 1314           yyformat++;
 1315         }
 1316   }
 1317   return 0;
 1318 }
 1319 #endif /* YYERROR_VERBOSE */
 1320 
 1321 /*-----------------------------------------------.
 1322 | Release the memory associated to this symbol.  |
 1323 `-----------------------------------------------*/
 1324 
 1325 static void
 1326 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, hitch_config *cfg)
 1327 {
 1328   YYUSE (yyvaluep);
 1329   YYUSE (cfg);
 1330   if (!yymsg)
 1331     yymsg = "Deleting";
 1332   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 1333 
 1334   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 1335   YYUSE (yytype);
 1336   YY_IGNORE_MAYBE_UNINITIALIZED_END
 1337 }
 1338 
 1339 
 1340 
 1341 
 1342 /* The lookahead symbol.  */
 1343 int yychar;
 1344 
 1345 /* The semantic value of the lookahead symbol.  */
 1346 YYSTYPE yylval;
 1347 /* Number of syntax errors so far.  */
 1348 int yynerrs;
 1349 
 1350 
 1351 /*----------.
 1352 | yyparse.  |
 1353 `----------*/
 1354 
 1355 int
 1356 yyparse (hitch_config *cfg)
 1357 {
 1358     int yystate;
 1359     /* Number of tokens to shift before error messages enabled.  */
 1360     int yyerrstatus;
 1361 
 1362     /* The stacks and their tools:
 1363        'yyss': related to states.
 1364        'yyvs': related to semantic values.
 1365 
 1366        Refer to the stacks through separate pointers, to allow yyoverflow
 1367        to reallocate them elsewhere.  */
 1368 
 1369     /* The state stack.  */
 1370     yytype_int16 yyssa[YYINITDEPTH];
 1371     yytype_int16 *yyss;
 1372     yytype_int16 *yyssp;
 1373 
 1374     /* The semantic value stack.  */
 1375     YYSTYPE yyvsa[YYINITDEPTH];
 1376     YYSTYPE *yyvs;
 1377     YYSTYPE *yyvsp;
 1378 
 1379     YYSIZE_T yystacksize;
 1380 
 1381   int yyn;
 1382   int yyresult;
 1383   /* Lookahead token as an internal (translated) token number.  */
 1384   int yytoken = 0;
 1385   /* The variables used to return semantic value and location from the
 1386      action routines.  */
 1387   YYSTYPE yyval;
 1388 
 1389 #if YYERROR_VERBOSE
 1390   /* Buffer for error messages, and its allocated size.  */
 1391   char yymsgbuf[128];
 1392   char *yymsg = yymsgbuf;
 1393   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 1394 #endif
 1395 
 1396 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 1397 
 1398   /* The number of symbols on the RHS of the reduced rule.
 1399      Keep to zero when no symbol should be popped.  */
 1400   int yylen = 0;
 1401 
 1402   yyssp = yyss = yyssa;
 1403   yyvsp = yyvs = yyvsa;
 1404   yystacksize = YYINITDEPTH;
 1405 
 1406   YYDPRINTF ((stderr, "Starting parse\n"));
 1407 
 1408   yystate = 0;
 1409   yyerrstatus = 0;
 1410   yynerrs = 0;
 1411   yychar = YYEMPTY; /* Cause a token to be read.  */
 1412   goto yysetstate;
 1413 
 1414 
 1415 /*------------------------------------------------------------.
 1416 | yynewstate -- push a new state, which is found in yystate.  |
 1417 `------------------------------------------------------------*/
 1418 yynewstate:
 1419   /* In all cases, when you get here, the value and location stacks
 1420      have just been pushed.  So pushing a state here evens the stacks.  */
 1421   yyssp++;
 1422 
 1423 
 1424 /*--------------------------------------------------------------------.
 1425 | yynewstate -- set current state (the top of the stack) to yystate.  |
 1426 `--------------------------------------------------------------------*/
 1427 yysetstate:
 1428   *yyssp = (yytype_int16) yystate;
 1429 
 1430   if (yyss + yystacksize - 1 <= yyssp)
 1431 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
 1432     goto yyexhaustedlab;
 1433 #else
 1434     {
 1435       /* Get the current used size of the three stacks, in elements.  */
 1436       YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
 1437 
 1438 # if defined yyoverflow
 1439       {
 1440         /* Give user a chance to reallocate the stack.  Use copies of
 1441            these so that the &'s don't force the real ones into
 1442            memory.  */
 1443         YYSTYPE *yyvs1 = yyvs;
 1444         yytype_int16 *yyss1 = yyss;
 1445 
 1446         /* Each stack pointer address is followed by the size of the
 1447            data in use in that stack, in bytes.  This used to be a
 1448            conditional around just the two extra args, but that might
 1449            be undefined if yyoverflow is a macro.  */
 1450         yyoverflow (YY_("memory exhausted"),
 1451                     &yyss1, yysize * sizeof (*yyssp),
 1452                     &yyvs1, yysize * sizeof (*yyvsp),
 1453                     &yystacksize);
 1454         yyss = yyss1;
 1455         yyvs = yyvs1;
 1456       }
 1457 # else /* defined YYSTACK_RELOCATE */
 1458       /* Extend the stack our own way.  */
 1459       if (YYMAXDEPTH <= yystacksize)
 1460         goto yyexhaustedlab;
 1461       yystacksize *= 2;
 1462       if (YYMAXDEPTH < yystacksize)
 1463         yystacksize = YYMAXDEPTH;
 1464 
 1465       {
 1466         yytype_int16 *yyss1 = yyss;
 1467         union yyalloc *yyptr =
 1468           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 1469         if (! yyptr)
 1470           goto yyexhaustedlab;
 1471         YYSTACK_RELOCATE (yyss_alloc, yyss);
 1472         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
 1473 # undef YYSTACK_RELOCATE
 1474         if (yyss1 != yyssa)
 1475           YYSTACK_FREE (yyss1);
 1476       }
 1477 # endif
 1478 
 1479       yyssp = yyss + yysize - 1;
 1480       yyvsp = yyvs + yysize - 1;
 1481 
 1482       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 1483                   (unsigned long) yystacksize));
 1484 
 1485       if (yyss + yystacksize - 1 <= yyssp)
 1486         YYABORT;
 1487     }
 1488 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 1489 
 1490   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 1491 
 1492   if (yystate == YYFINAL)
 1493     YYACCEPT;
 1494 
 1495   goto yybackup;
 1496 
 1497 
 1498 /*-----------.
 1499 | yybackup.  |
 1500 `-----------*/
 1501 yybackup:
 1502   /* Do appropriate processing given the current state.  Read a
 1503      lookahead token if we need one and don't already have one.  */
 1504 
 1505   /* First try to decide what to do without reference to lookahead token.  */
 1506   yyn = yypact[yystate];
 1507   if (yypact_value_is_default (yyn))
 1508     goto yydefault;
 1509 
 1510   /* Not known => get a lookahead token if don't already have one.  */
 1511 
 1512   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
 1513   if (yychar == YYEMPTY)
 1514     {
 1515       YYDPRINTF ((stderr, "Reading a token: "));
 1516       yychar = yylex ();
 1517     }
 1518 
 1519   if (yychar <= YYEOF)
 1520     {
 1521       yychar = yytoken = YYEOF;
 1522       YYDPRINTF ((stderr, "Now at end of input.\n"));
 1523     }
 1524   else
 1525     {
 1526       yytoken = YYTRANSLATE (yychar);
 1527       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 1528     }
 1529 
 1530   /* If the proper action on seeing token YYTOKEN is to reduce or to
 1531      detect an error, take that action.  */
 1532   yyn += yytoken;
 1533   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
 1534     goto yydefault;
 1535   yyn = yytable[yyn];
 1536   if (yyn <= 0)
 1537     {
 1538       if (yytable_value_is_error (yyn))
 1539         goto yyerrlab;
 1540       yyn = -yyn;
 1541       goto yyreduce;
 1542     }
 1543 
 1544   /* Count tokens shifted since error; after three, turn off error
 1545      status.  */
 1546   if (yyerrstatus)
 1547     yyerrstatus--;
 1548 
 1549   /* Shift the lookahead token.  */
 1550   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 1551 
 1552   /* Discard the shifted token.  */
 1553   yychar = YYEMPTY;
 1554 
 1555   yystate = yyn;
 1556   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 1557   *++yyvsp = yylval;
 1558   YY_IGNORE_MAYBE_UNINITIALIZED_END
 1559 
 1560   goto yynewstate;
 1561 
 1562 
 1563 /*-----------------------------------------------------------.
 1564 | yydefault -- do the default action for the current state.  |
 1565 `-----------------------------------------------------------*/
 1566 yydefault:
 1567   yyn = yydefact[yystate];
 1568   if (yyn == 0)
 1569     goto yyerrlab;
 1570   goto yyreduce;
 1571 
 1572 
 1573 /*-----------------------------.
 1574 | yyreduce -- do a reduction.  |
 1575 `-----------------------------*/
 1576 yyreduce:
 1577   /* yyn is the number of a rule to reduce with.  */
 1578   yylen = yyr2[yyn];
 1579 
 1580   /* If YYLEN is nonzero, implement the default value of the action:
 1581      '$$ = $1'.
 1582 
 1583      Otherwise, the following line sets YYVAL to garbage.
 1584      This behavior is undocumented and Bison
 1585      users should not rely upon it.  Assigning to YYVAL
 1586      unconditionally makes the parser a bit smaller, and it avoids a
 1587      GCC warning that YYVAL may be used uninitialized.  */
 1588   yyval = yyvsp[1-yylen];
 1589 
 1590 
 1591   YY_REDUCE_PRINT (yyn);
 1592   switch (yyn)
 1593     {
 1594         case 49:
 1595 #line 123 "cfg_parser.y" /* yacc.c:1652  */
 1596     {
 1597         /* XXX: passing an empty string for file */
 1598         if ((yyvsp[0].s) && config_param_validate("frontend", (yyvsp[0].s), cfg, "",
 1599             yyget_lineno()) != 0)
 1600             YYABORT;
 1601     }
 1602 #line 1603 "cfg_parser.c" /* yacc.c:1652  */
 1603     break;
 1604 
 1605   case 50:
 1606 #line 129 "cfg_parser.y" /* yacc.c:1652  */
 1607     {
 1608         /* NB: Mid-rule action */
 1609         AZ(cur_fa);
 1610         cur_fa = front_arg_new();
 1611     }
 1612 #line 1613 "cfg_parser.c" /* yacc.c:1652  */
 1613     break;
 1614 
 1615   case 51:
 1616 #line 134 "cfg_parser.y" /* yacc.c:1652  */
 1617     {
 1618         if (front_arg_add(cfg, cur_fa) != 1)
 1619             YYABORT;
 1620         cur_fa = NULL;
 1621     }
 1622 #line 1623 "cfg_parser.c" /* yacc.c:1652  */
 1623     break;
 1624 
 1625   case 65:
 1626 #line 159 "cfg_parser.y" /* yacc.c:1652  */
 1627     {
 1628     if ((yyvsp[0].s)) {
 1629         if (strcmp((yyvsp[0].s), "*") == 0)
 1630             cur_fa->ip = NULL;
 1631         else
 1632             cur_fa->ip = strdup((yyvsp[0].s));
 1633     }
 1634 }
 1635 #line 1636 "cfg_parser.c" /* yacc.c:1652  */
 1636     break;
 1637 
 1638   case 66:
 1639 #line 168 "cfg_parser.y" /* yacc.c:1652  */
 1640     { if ((yyvsp[0].s)) cur_fa->port = strdup((yyvsp[0].s)); }
 1641 #line 1642 "cfg_parser.c" /* yacc.c:1652  */
 1642     break;
 1643 
 1644   case 74:
 1645 #line 184 "cfg_parser.y" /* yacc.c:1652  */
 1646     { if ((yyvsp[0].s)) cur_pem->filename = strdup((yyvsp[0].s)); }
 1647 #line 1648 "cfg_parser.c" /* yacc.c:1652  */
 1648     break;
 1649 
 1650   case 75:
 1651 #line 186 "cfg_parser.y" /* yacc.c:1652  */
 1652     {
 1653     if ((yyvsp[0].s))
 1654         cur_pem->ocspfn = strdup((yyvsp[0].s));
 1655 }
 1656 #line 1657 "cfg_parser.c" /* yacc.c:1652  */
 1657     break;
 1658 
 1659   case 76:
 1660 #line 191 "cfg_parser.y" /* yacc.c:1652  */
 1661     {
 1662     if (cur_pem != NULL)
 1663         cur_pem->ocsp_vfy = (yyvsp[0].i);
 1664     else
 1665         cfg->OCSP_VFY = (yyvsp[0].i);
 1666 }
 1667 #line 1668 "cfg_parser.c" /* yacc.c:1652  */
 1668     break;
 1669 
 1670   case 77:
 1671 #line 198 "cfg_parser.y" /* yacc.c:1652  */
 1672     {
 1673     if ((yyvsp[0].s)) cur_pem->priv_key_filename = strdup((yyvsp[0].s));
 1674 }
 1675 #line 1676 "cfg_parser.c" /* yacc.c:1652  */
 1676     break;
 1677 
 1678   case 78:
 1679 #line 202 "cfg_parser.y" /* yacc.c:1652  */
 1680     {
 1681     if ((yyvsp[0].s)) {
 1682         size_t l;
 1683         l = strlen((yyvsp[0].s));
 1684         cfg->PEM_DIR = malloc(l + 2);
 1685         strcpy(cfg->PEM_DIR, (yyvsp[0].s));
 1686         if (cfg->PEM_DIR[l-1] != '/')
 1687             strcat(cfg->PEM_DIR, "/");
 1688     }
 1689     else
 1690         cfg->PEM_DIR = NULL;
 1691 }
 1692 #line 1693 "cfg_parser.c" /* yacc.c:1652  */
 1693     break;
 1694 
 1695   case 79:
 1696 #line 215 "cfg_parser.y" /* yacc.c:1652  */
 1697     {
 1698     if ((yyvsp[0].s))
 1699         cfg->PEM_DIR_GLOB = strdup((yyvsp[0].s));
 1700     else
 1701         cfg->PEM_DIR_GLOB = NULL;
 1702 
 1703 }
 1704 #line 1705 "cfg_parser.c" /* yacc.c:1652  */
 1705     break;
 1706 
 1707   case 80:
 1708 #line 223 "cfg_parser.y" /* yacc.c:1652  */
 1709     {
 1710     if ((yyvsp[0].s))
 1711         cfg->OCSP_DIR = strdup((yyvsp[0].s));
 1712     else
 1713         cfg->OCSP_DIR = NULL;
 1714 }
 1715 #line 1716 "cfg_parser.c" /* yacc.c:1652  */
 1716     break;
 1717 
 1718   case 81:
 1719 #line 230 "cfg_parser.y" /* yacc.c:1652  */
 1720     {
 1721     cfg->OCSP_RESP_TMO = (yyvsp[0].i);
 1722 }
 1723 #line 1724 "cfg_parser.c" /* yacc.c:1652  */
 1724     break;
 1725 
 1726   case 82:
 1727 #line 234 "cfg_parser.y" /* yacc.c:1652  */
 1728     {
 1729     cfg->OCSP_CONN_TMO = (yyvsp[0].i);
 1730 }
 1731 #line 1732 "cfg_parser.c" /* yacc.c:1652  */
 1732     break;
 1733 
 1734   case 83:
 1735 #line 238 "cfg_parser.y" /* yacc.c:1652  */
 1736     {
 1737     cfg->OCSP_REFRESH_INTERVAL = (yyvsp[0].i);
 1738 }
 1739 #line 1740 "cfg_parser.c" /* yacc.c:1652  */
 1740     break;
 1741 
 1742   case 84:
 1743 #line 243 "cfg_parser.y" /* yacc.c:1652  */
 1744     {
 1745         if ((yyvsp[0].s) != NULL) {
 1746             int r;
 1747             struct cfg_cert_file *cert;
 1748             cert = cfg_cert_file_new();
 1749             cert->filename = strdup((yyvsp[0].s));
 1750             r = cfg_cert_vfy(cert);
 1751             if (r == 0) {
 1752                 cfg_cert_file_free(&cert);
 1753                 YYABORT;
 1754             }
 1755             cfg_cert_add(cert, &cur_fa->certs);
 1756         }
 1757     }
 1758 #line 1759 "cfg_parser.c" /* yacc.c:1652  */
 1759     break;
 1760 
 1761   case 85:
 1762 #line 257 "cfg_parser.y" /* yacc.c:1652  */
 1763     {
 1764         /* NB: Mid-rule action */
 1765         AZ(cur_pem);
 1766         cur_pem = cfg_cert_file_new();
 1767     }
 1768 #line 1769 "cfg_parser.c" /* yacc.c:1652  */
 1769     break;
 1770 
 1771   case 86:
 1772 #line 262 "cfg_parser.y" /* yacc.c:1652  */
 1773     {
 1774         if (cfg_cert_vfy(cur_pem) != 0)
 1775             cfg_cert_add(cur_pem, &cur_fa->certs);
 1776         else {
 1777             cfg_cert_file_free(&cur_pem);
 1778             YYABORT;
 1779         }
 1780         cur_pem = NULL;
 1781     }
 1782 #line 1783 "cfg_parser.c" /* yacc.c:1652  */
 1783     break;
 1784 
 1785   case 87:
 1786 #line 272 "cfg_parser.y" /* yacc.c:1652  */
 1787     { cur_fa->match_global_certs = (yyvsp[0].i); }
 1788 #line 1789 "cfg_parser.c" /* yacc.c:1652  */
 1789     break;
 1790 
 1791   case 88:
 1792 #line 274 "cfg_parser.y" /* yacc.c:1652  */
 1793     {
 1794         cur_fa->sni_nomatch_abort = (yyvsp[0].i);
 1795 }
 1796 #line 1797 "cfg_parser.c" /* yacc.c:1652  */
 1797     break;
 1798 
 1799   case 89:
 1800 #line 279 "cfg_parser.y" /* yacc.c:1652  */
 1801     {
 1802     if (cur_fa->selected_protos != 0) {
 1803         fprintf(stderr, "%s (%s, line %d):"
 1804             " It is illegal to specify tls after ssl,"
 1805             " tls or tls-protos.\n",
 1806             __func__, __FILE__, __LINE__);
 1807         front_arg_destroy(cur_fa);
 1808         cur_fa = NULL;
 1809         YYABORT;
 1810     }
 1811     if ((yyvsp[0].i))
 1812         cur_fa->selected_protos = TLS_OPTION_PROTOS;
 1813     else
 1814         fprintf(stderr,
 1815             "Warning: tls = off is deprecated and has no effect.\n");
 1816 }
 1817 #line 1818 "cfg_parser.c" /* yacc.c:1652  */
 1818     break;
 1819 
 1820   case 90:
 1821 #line 296 "cfg_parser.y" /* yacc.c:1652  */
 1822     {
 1823     if (cur_fa->selected_protos != 0) {
 1824         fprintf(stderr, "%s (%s, line %d):"
 1825             " It is illegal to specify ssl after ssl,"
 1826             " tls or tls-protos.\n",
 1827             __func__, __FILE__, __LINE__);
 1828         front_arg_destroy(cur_fa);
 1829         cur_fa = NULL;
 1830         YYABORT;
 1831     }
 1832     if ((yyvsp[0].i))
 1833         cur_fa->selected_protos = SSL_OPTION_PROTOS;
 1834     else
 1835         fprintf(stderr,
 1836             "Warning: ssl = off is deprecated and has no effect.\n");
 1837 }
 1838 #line 1839 "cfg_parser.c" /* yacc.c:1652  */
 1839     break;
 1840 
 1841   case 91:
 1842 #line 313 "cfg_parser.y" /* yacc.c:1652  */
 1843     {
 1844     if (cur_fa->selected_protos != 0) {
 1845         fprintf(stderr, "%s (%s, line %d):"
 1846             " It is illegal to specify tls-protos after"
 1847             " ssl, tls or tls-protos\nSelected before was %d\n",
 1848             __func__, __FILE__, __LINE__, cur_fa->selected_protos);
 1849         front_arg_destroy(cur_fa);
 1850         cur_fa = NULL;
 1851         YYABORT;
 1852     }
 1853 }
 1854 #line 1855 "cfg_parser.c" /* yacc.c:1652  */
 1855     break;
 1856 
 1857   case 95:
 1858 #line 327 "cfg_parser.y" /* yacc.c:1652  */
 1859     { cur_fa->selected_protos |= SSLv3_PROTO; }
 1860 #line 1861 "cfg_parser.c" /* yacc.c:1652  */
 1861     break;
 1862 
 1863   case 96:
 1864 #line 328 "cfg_parser.y" /* yacc.c:1652  */
 1865     { cur_fa->selected_protos |= TLSv1_0_PROTO; }
 1866 #line 1867 "cfg_parser.c" /* yacc.c:1652  */
 1867     break;
 1868 
 1869   case 97:
 1870 #line 329 "cfg_parser.y" /* yacc.c:1652  */
 1871     { cur_fa->selected_protos |= TLSv1_1_PROTO; }
 1872 #line 1873 "cfg_parser.c" /* yacc.c:1652  */
 1873     break;
 1874 
 1875   case 98:
 1876 #line 330 "cfg_parser.y" /* yacc.c:1652  */
 1877     { cur_fa->selected_protos |= TLSv1_2_PROTO; }
 1878 #line 1879 "cfg_parser.c" /* yacc.c:1652  */
 1879     break;
 1880 
 1881   case 99:
 1882 #line 331 "cfg_parser.y" /* yacc.c:1652  */
 1883     { cur_fa->selected_protos |= TLSv1_3_PROTO; }
 1884 #line 1885 "cfg_parser.c" /* yacc.c:1652  */
 1885     break;
 1886 
 1887   case 100:
 1888 #line 333 "cfg_parser.y" /* yacc.c:1652  */
 1889     {
 1890     if ((yyvsp[0].s)) cur_fa->ciphers = strdup((yyvsp[0].s));
 1891 }
 1892 #line 1893 "cfg_parser.c" /* yacc.c:1652  */
 1893     break;
 1894 
 1895   case 101:
 1896 #line 337 "cfg_parser.y" /* yacc.c:1652  */
 1897     {
 1898     cur_fa->prefer_server_ciphers = (yyvsp[0].i);
 1899 }
 1900 #line 1901 "cfg_parser.c" /* yacc.c:1652  */
 1901     break;
 1902 
 1903   case 102:
 1904 #line 341 "cfg_parser.y" /* yacc.c:1652  */
 1905     {
 1906     if ((yyvsp[0].i))
 1907         cfg->LOG_LEVEL = 0;
 1908     else
 1909         cfg->LOG_LEVEL = 1;
 1910 }
 1911 #line 1912 "cfg_parser.c" /* yacc.c:1652  */
 1912     break;
 1913 
 1914   case 103:
 1915 #line 348 "cfg_parser.y" /* yacc.c:1652  */
 1916     { cfg->NCORES = (yyvsp[0].i); }
 1917 #line 1918 "cfg_parser.c" /* yacc.c:1652  */
 1918     break;
 1919 
 1920   case 104:
 1921 #line 350 "cfg_parser.y" /* yacc.c:1652  */
 1922     { cfg->BACKLOG = (yyvsp[0].i); }
 1923 #line 1924 "cfg_parser.c" /* yacc.c:1652  */
 1924     break;
 1925 
 1926   case 105:
 1927 #line 352 "cfg_parser.y" /* yacc.c:1652  */
 1928     { cfg->TCP_KEEPALIVE_TIME = (yyvsp[0].i); }
 1929 #line 1930 "cfg_parser.c" /* yacc.c:1652  */
 1930     break;
 1931 
 1932   case 106:
 1933 #line 354 "cfg_parser.y" /* yacc.c:1652  */
 1934     {
 1935     if (cfg->SELECTED_TLS_PROTOS != 0) {
 1936         fprintf(stderr, "%s (%s, line %d):"
 1937             " It is illegal to specify tls after ssl,"
 1938             " tls or tls-protos\n",
 1939             __func__, __FILE__, __LINE__);
 1940         YYABORT;
 1941     }
 1942     if ((yyvsp[0].i))
 1943         cfg->SELECTED_TLS_PROTOS = TLS_OPTION_PROTOS;
 1944     else
 1945         fprintf(stderr,
 1946             "Warning: tls = off is deprecated and has no effect.\n");
 1947 }
 1948 #line 1949 "cfg_parser.c" /* yacc.c:1652  */
 1949     break;
 1950 
 1951   case 107:
 1952 #line 369 "cfg_parser.y" /* yacc.c:1652  */
 1953     {
 1954     if (cfg->SELECTED_TLS_PROTOS != 0) {
 1955         fprintf(stderr, "%s (%s, line %d):"
 1956             " It is illegal to specify ssl after ssl,"
 1957             " tls or tls-protos.\n",
 1958             __func__, __FILE__, __LINE__);
 1959         YYABORT;
 1960     }
 1961     if ((yyvsp[0].i))
 1962         cfg->SELECTED_TLS_PROTOS = SSL_OPTION_PROTOS;
 1963     else
 1964         fprintf(stderr,
 1965             "Warning: ssl = off is deprecated and has no effect.\n");
 1966 }
 1967 #line 1968 "cfg_parser.c" /* yacc.c:1652  */
 1968     break;
 1969 
 1970   case 108:
 1971 #line 384 "cfg_parser.y" /* yacc.c:1652  */
 1972     {
 1973     if (cfg->SELECTED_TLS_PROTOS != 0) {
 1974         fprintf(stderr, "%s (%s, line %d):"
 1975             " It is illegal to specify tls-protos after"
 1976             " ssl, tls or tls-protos\n",
 1977             __func__, __FILE__, __LINE__);
 1978         YYABORT;
 1979     }
 1980 }
 1981 #line 1982 "cfg_parser.c" /* yacc.c:1652  */
 1982     break;
 1983 
 1984   case 112:
 1985 #line 396 "cfg_parser.y" /* yacc.c:1652  */
 1986     { cfg->SELECTED_TLS_PROTOS |= SSLv3_PROTO; }
 1987 #line 1988 "cfg_parser.c" /* yacc.c:1652  */
 1988     break;
 1989 
 1990   case 113:
 1991 #line 397 "cfg_parser.y" /* yacc.c:1652  */
 1992     { cfg->SELECTED_TLS_PROTOS |= TLSv1_0_PROTO; }
 1993 #line 1994 "cfg_parser.c" /* yacc.c:1652  */
 1994     break;
 1995 
 1996   case 114:
 1997 #line 398 "cfg_parser.y" /* yacc.c:1652  */
 1998     { cfg->SELECTED_TLS_PROTOS |= TLSv1_1_PROTO; }
 1999 #line 2000 "cfg_parser.c" /* yacc.c:1652  */
 2000     break;
 2001 
 2002   case 115:
 2003 #line 399 "cfg_parser.y" /* yacc.c:1652  */
 2004     { cfg->SELECTED_TLS_PROTOS |= TLSv1_2_PROTO; }
 2005 #line 2006 "cfg_parser.c" /* yacc.c:1652  */
 2006     break;
 2007 
 2008   case 116:
 2009 #line 400 "cfg_parser.y" /* yacc.c:1652  */
 2010     { cfg->SELECTED_TLS_PROTOS |= TLSv1_3_PROTO; }
 2011 #line 2012 "cfg_parser.c" /* yacc.c:1652  */
 2012     break;
 2013 
 2014   case 117:
 2015 #line 402 "cfg_parser.y" /* yacc.c:1652  */
 2016     { if ((yyvsp[0].s)) cfg->ENGINE = strdup((yyvsp[0].s)); }
 2017 #line 2018 "cfg_parser.c" /* yacc.c:1652  */
 2018     break;
 2019 
 2020   case 118:
 2021 #line 404 "cfg_parser.y" /* yacc.c:1652  */
 2022     {
 2023     cfg->PREFER_SERVER_CIPHERS = (yyvsp[0].i);
 2024 }
 2025 #line 2026 "cfg_parser.c" /* yacc.c:1652  */
 2026     break;
 2027 
 2028   case 119:
 2029 #line 408 "cfg_parser.y" /* yacc.c:1652  */
 2030     {
 2031     /* XXX: passing an empty string for file */
 2032     if ((yyvsp[0].s) && config_param_validate("chroot", (yyvsp[0].s), cfg, "",
 2033         yyget_lineno()) != 0)
 2034         YYABORT;
 2035 }
 2036 #line 2037 "cfg_parser.c" /* yacc.c:1652  */
 2037     break;
 2038 
 2039   case 120:
 2040 #line 415 "cfg_parser.y" /* yacc.c:1652  */
 2041     {
 2042     /* XXX: passing an empty string for file */
 2043     if ((yyvsp[0].s) && config_param_validate("backend", (yyvsp[0].s), cfg, "",
 2044         yyget_lineno()) != 0)
 2045         YYABORT;
 2046 }
 2047 #line 2048 "cfg_parser.c" /* yacc.c:1652  */
 2048     break;
 2049 
 2050   case 121:
 2051 #line 423 "cfg_parser.y" /* yacc.c:1652  */
 2052     {
 2053         /* XXX: passing an empty string for file */
 2054         if ((yyvsp[0].s) && config_param_validate("pem-file", (yyvsp[0].s), cfg, "",
 2055             yyget_lineno()) != 0)
 2056             YYABORT;
 2057     }
 2058 #line 2059 "cfg_parser.c" /* yacc.c:1652  */
 2059     break;
 2060 
 2061   case 122:
 2062 #line 429 "cfg_parser.y" /* yacc.c:1652  */
 2063     {
 2064         /* NB: Mid-rule action */
 2065         AZ(cur_pem);
 2066         cur_pem = cfg_cert_file_new();
 2067     }
 2068 #line 2069 "cfg_parser.c" /* yacc.c:1652  */
 2069     break;
 2070 
 2071   case 123:
 2072 #line 434 "cfg_parser.y" /* yacc.c:1652  */
 2073     {
 2074         if (cfg_cert_vfy(cur_pem) != 0) {
 2075             if (cfg->CERT_DEFAULT != NULL) {
 2076                 struct cfg_cert_file *tmp = cfg->CERT_DEFAULT;
 2077                 cfg_cert_add(tmp, &cfg->CERT_FILES);
 2078             }
 2079             cfg->CERT_DEFAULT = cur_pem;
 2080         } else {
 2081             cfg_cert_file_free(&cur_pem);
 2082             YYABORT;
 2083         }
 2084         cur_pem = NULL;
 2085     }
 2086 #line 2087 "cfg_parser.c" /* yacc.c:1652  */
 2087     break;
 2088 
 2089   case 124:
 2090 #line 448 "cfg_parser.y" /* yacc.c:1652  */
 2091     { cfg->SYSLOG = (yyvsp[0].i); }
 2092 #line 2093 "cfg_parser.c" /* yacc.c:1652  */
 2093     break;
 2094 
 2095   case 125:
 2096 #line 449 "cfg_parser.y" /* yacc.c:1652  */
 2097     { cfg->DAEMONIZE = (yyvsp[0].i); }
 2098 #line 2099 "cfg_parser.c" /* yacc.c:1652  */
 2099     break;
 2100 
 2101   case 126:
 2102 #line 450 "cfg_parser.y" /* yacc.c:1652  */
 2103     {
 2104     cfg->SNI_NOMATCH_ABORT = (yyvsp[0].i);
 2105 }
 2106 #line 2107 "cfg_parser.c" /* yacc.c:1652  */
 2107     break;
 2108 
 2109   case 127:
 2110 #line 454 "cfg_parser.y" /* yacc.c:1652  */
 2111     { if ((yyvsp[0].s)) cfg->CIPHER_SUITE = strdup((yyvsp[0].s)); }
 2112 #line 2113 "cfg_parser.c" /* yacc.c:1652  */
 2113     break;
 2114 
 2115   case 128:
 2116 #line 456 "cfg_parser.y" /* yacc.c:1652  */
 2117     {
 2118     /* XXX: passing an empty string for file */
 2119     if ((yyvsp[0].s) && config_param_validate("user", (yyvsp[0].s), cfg, "",
 2120         yyget_lineno()) != 0)
 2121         YYABORT;
 2122 }
 2123 #line 2124 "cfg_parser.c" /* yacc.c:1652  */
 2124     break;
 2125 
 2126   case 129:
 2127 #line 463 "cfg_parser.y" /* yacc.c:1652  */
 2128     {
 2129     /* XXX: passing an empty string for file */
 2130     if ((yyvsp[0].s) && config_param_validate("group", (yyvsp[0].s), cfg, "",
 2131         yyget_lineno()) != 0)
 2132         YYABORT;
 2133 }
 2134 #line 2135 "cfg_parser.c" /* yacc.c:1652  */
 2135     break;
 2136 
 2137   case 130:
 2138 #line 470 "cfg_parser.y" /* yacc.c:1652  */
 2139     { cfg->WRITE_IP_OCTET = (yyvsp[0].i); }
 2140 #line 2141 "cfg_parser.c" /* yacc.c:1652  */
 2141     break;
 2142 
 2143   case 131:
 2144 #line 472 "cfg_parser.y" /* yacc.c:1652  */
 2145     { cfg->WRITE_PROXY_LINE_V2 = (yyvsp[0].i); }
 2146 #line 2147 "cfg_parser.c" /* yacc.c:1652  */
 2147     break;
 2148 
 2149   case 132:
 2150 #line 474 "cfg_parser.y" /* yacc.c:1652  */
 2151     {
 2152     cfg->WRITE_PROXY_LINE_V1 = (yyvsp[0].i);
 2153 }
 2154 #line 2155 "cfg_parser.c" /* yacc.c:1652  */
 2155     break;
 2156 
 2157   case 133:
 2158 #line 478 "cfg_parser.y" /* yacc.c:1652  */
 2159     {
 2160     cfg->WRITE_PROXY_LINE_V2 = (yyvsp[0].i);
 2161 }
 2162 #line 2163 "cfg_parser.c" /* yacc.c:1652  */
 2163     break;
 2164 
 2165   case 134:
 2166 #line 482 "cfg_parser.y" /* yacc.c:1652  */
 2167     { cfg->PROXY_TLV = (yyvsp[0].i); }
 2168 #line 2169 "cfg_parser.c" /* yacc.c:1652  */
 2169     break;
 2170 
 2171   case 135:
 2172 #line 484 "cfg_parser.y" /* yacc.c:1652  */
 2173     { cfg->PROXY_AUTHORITY = (yyvsp[0].i); }
 2174 #line 2175 "cfg_parser.c" /* yacc.c:1652  */
 2175     break;
 2176 
 2177   case 136:
 2178 #line 486 "cfg_parser.y" /* yacc.c:1652  */
 2179     { cfg->PROXY_PROXY_LINE = (yyvsp[0].i); }
 2180 #line 2181 "cfg_parser.c" /* yacc.c:1652  */
 2181     break;
 2182 
 2183   case 137:
 2184 #line 488 "cfg_parser.y" /* yacc.c:1652  */
 2185     {
 2186     /* XXX: passing an empty string for file */
 2187     if ((yyvsp[0].s) && config_param_validate("alpn-protos", (yyvsp[0].s), cfg, "",
 2188         yyget_lineno()) != 0)
 2189         YYABORT;
 2190 }
 2191 #line 2192 "cfg_parser.c" /* yacc.c:1652  */
 2192     break;
 2193 
 2194   case 138:
 2195 #line 495 "cfg_parser.y" /* yacc.c:1652  */
 2196     {
 2197     /* XXX: passing an empty string for file */
 2198     if ((yyvsp[0].s) &&
 2199         config_param_validate("syslog-facility", (yyvsp[0].s), cfg, "",
 2200         yyget_lineno()) != 0)
 2201         YYABORT;
 2202 }
 2203 #line 2204 "cfg_parser.c" /* yacc.c:1652  */
 2204     break;
 2205 
 2206   case 139:
 2207 #line 503 "cfg_parser.y" /* yacc.c:1652  */
 2208     { cfg->SEND_BUFSIZE = (yyvsp[0].i); }
 2209 #line 2210 "cfg_parser.c" /* yacc.c:1652  */
 2210     break;
 2211 
 2212   case 140:
 2213 #line 505 "cfg_parser.y" /* yacc.c:1652  */
 2214     { cfg->RECV_BUFSIZE = (yyvsp[0].i); }
 2215 #line 2216 "cfg_parser.c" /* yacc.c:1652  */
 2216     break;
 2217 
 2218   case 141:
 2219 #line 507 "cfg_parser.y" /* yacc.c:1652  */
 2220     {
 2221     /* XXX: passing an empty string for file */
 2222     if ((yyvsp[0].s) &&
 2223         config_param_validate("log-filename", (yyvsp[0].s), cfg, "",
 2224         yyget_lineno()) != 0)
 2225         YYABORT;
 2226 }
 2227 #line 2228 "cfg_parser.c" /* yacc.c:1652  */
 2228     break;
 2229 
 2230   case 142:
 2231 #line 515 "cfg_parser.y" /* yacc.c:1652  */
 2232     { cfg->LOG_LEVEL = (yyvsp[0].i); }
 2233 #line 2234 "cfg_parser.c" /* yacc.c:1652  */
 2234     break;
 2235 
 2236   case 143:
 2237 #line 517 "cfg_parser.y" /* yacc.c:1652  */
 2238     {
 2239 #ifdef USE_SHARED_CACHE
 2240     cfg->SHARED_CACHE = (yyvsp[0].i);
 2241 #else
 2242     fprintf(stderr, "Hitch needs to be compiled with --enable-sessioncache "
 2243             "for '%s'", input_line);
 2244     YYABORT;
 2245 #endif
 2246 }
 2247 #line 2248 "cfg_parser.c" /* yacc.c:1652  */
 2248     break;
 2249 
 2250   case 144:
 2251 #line 527 "cfg_parser.y" /* yacc.c:1652  */
 2252     {
 2253 #ifdef USE_SHARED_CACHE
 2254     /* XXX: passing an empty string for file */
 2255     if ((yyvsp[0].s) && config_param_validate("shared-cache-listen", (yyvsp[0].s), cfg,
 2256         "", yyget_lineno()) != 0)
 2257         YYABORT;
 2258 #else
 2259     fprintf(stderr, "Hitch needs to be compiled with --enable-sessioncache "
 2260             "for '%s'", input_line);
 2261     YYABORT;
 2262 #endif
 2263 }
 2264 #line 2265 "cfg_parser.c" /* yacc.c:1652  */
 2265     break;
 2266 
 2267   case 145:
 2268 #line 540 "cfg_parser.y" /* yacc.c:1652  */
 2269     {
 2270 #ifdef USE_SHARED_CACHE
 2271     /* XXX: passing an empty string for file */
 2272     if ((yyvsp[0].s) && config_param_validate("shared-cache-peer", (yyvsp[0].s), cfg,
 2273         "", yyget_lineno()) != 0)
 2274         YYABORT;
 2275 #else
 2276     fprintf(stderr, "Hitch needs to be compiled with --enable-sessioncache "
 2277             "for '%s'", input_line);
 2278     YYABORT;
 2279 #endif
 2280 }
 2281 #line 2282 "cfg_parser.c" /* yacc.c:1652  */
 2282     break;
 2283 
 2284   case 146:
 2285 #line 553 "cfg_parser.y" /* yacc.c:1652  */
 2286     {
 2287 #ifdef USE_SHARED_CACHE
 2288     /* XXX: passing an empty string for file */
 2289     if ((yyvsp[0].s) && config_param_validate("shared-cache-if", (yyvsp[0].s), cfg,
 2290         "", yyget_lineno()) != 0)
 2291         YYABORT;
 2292 #else
 2293     fprintf(stderr, "Hitch needs to be compiled with --enable-sessioncache "
 2294             "for '%s'", input_line);
 2295     YYABORT;
 2296 #endif
 2297 }
 2298 #line 2299 "cfg_parser.c" /* yacc.c:1652  */
 2299     break;
 2300 
 2301   case 147:
 2302 #line 566 "cfg_parser.y" /* yacc.c:1652  */
 2303     {
 2304 #ifdef TCP_FASTOPEN_WORKS
 2305     { cfg->TFO = (yyvsp[0].i); };
 2306 #else
 2307     fprintf(stderr, "Hitch needs to be compiled with --enable-tfo"
 2308             "for '%s'", input_line);
 2309     YYABORT;
 2310 #endif
 2311 }
 2312 #line 2313 "cfg_parser.c" /* yacc.c:1652  */
 2313     break;
 2314 
 2315   case 148:
 2316 #line 576 "cfg_parser.y" /* yacc.c:1652  */
 2317     {
 2318     cfg->BACKEND_REFRESH_TIME = (yyvsp[0].i);
 2319 }
 2320 #line 2321 "cfg_parser.c" /* yacc.c:1652  */
 2321     break;
 2322 
 2323 
 2324 #line 2325 "cfg_parser.c" /* yacc.c:1652  */
 2325       default: break;
 2326     }
 2327   /* User semantic actions sometimes alter yychar, and that requires
 2328      that yytoken be updated with the new translation.  We take the
 2329      approach of translating immediately before every use of yytoken.
 2330      One alternative is translating here after every semantic action,
 2331      but that translation would be missed if the semantic action invokes
 2332      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
 2333      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
 2334      incorrect destructor might then be invoked immediately.  In the
 2335      case of YYERROR or YYBACKUP, subsequent parser actions might lead
 2336      to an incorrect destructor call or verbose syntax error message
 2337      before the lookahead is translated.  */
 2338   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 2339 
 2340   YYPOPSTACK (yylen);
 2341   yylen = 0;
 2342   YY_STACK_PRINT (yyss, yyssp);
 2343 
 2344   *++yyvsp = yyval;
 2345 
 2346   /* Now 'shift' the result of the reduction.  Determine what state
 2347      that goes to, based on the state we popped back to and the rule
 2348      number reduced by.  */
 2349   {
 2350     const int yylhs = yyr1[yyn] - YYNTOKENS;
 2351     const int yyi = yypgoto[yylhs] + *yyssp;
 2352     yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
 2353                ? yytable[yyi]
 2354                : yydefgoto[yylhs]);
 2355   }
 2356 
 2357   goto yynewstate;
 2358 
 2359 
 2360 /*--------------------------------------.
 2361 | yyerrlab -- here on detecting error.  |
 2362 `--------------------------------------*/
 2363 yyerrlab:
 2364   /* Make sure we have latest lookahead translation.  See comments at
 2365      user semantic actions for why this is necessary.  */
 2366   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
 2367 
 2368   /* If not already recovering from an error, report this error.  */
 2369   if (!yyerrstatus)
 2370     {
 2371       ++yynerrs;
 2372 #if ! YYERROR_VERBOSE
 2373       yyerror (cfg, YY_("syntax error"));
 2374 #else
 2375 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
 2376                                         yyssp, yytoken)
 2377       {
 2378         char const *yymsgp = YY_("syntax error");
 2379         int yysyntax_error_status;
 2380         yysyntax_error_status = YYSYNTAX_ERROR;
 2381         if (yysyntax_error_status == 0)
 2382           yymsgp = yymsg;
 2383         else if (yysyntax_error_status == 1)
 2384           {
 2385             if (yymsg != yymsgbuf)
 2386               YYSTACK_FREE (yymsg);
 2387             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
 2388             if (!yymsg)
 2389               {
 2390                 yymsg = yymsgbuf;
 2391                 yymsg_alloc = sizeof yymsgbuf;
 2392                 yysyntax_error_status = 2;
 2393               }
 2394             else
 2395               {
 2396                 yysyntax_error_status = YYSYNTAX_ERROR;
 2397                 yymsgp = yymsg;
 2398               }
 2399           }
 2400         yyerror (cfg, yymsgp);
 2401         if (yysyntax_error_status == 2)
 2402           goto yyexhaustedlab;
 2403       }
 2404 # undef YYSYNTAX_ERROR
 2405 #endif
 2406     }
 2407 
 2408 
 2409 
 2410   if (yyerrstatus == 3)
 2411     {
 2412       /* If just tried and failed to reuse lookahead token after an
 2413          error, discard it.  */
 2414 
 2415       if (yychar <= YYEOF)
 2416         {
 2417           /* Return failure if at end of input.  */
 2418           if (yychar == YYEOF)
 2419             YYABORT;
 2420         }
 2421       else
 2422         {
 2423           yydestruct ("Error: discarding",
 2424                       yytoken, &yylval, cfg);
 2425           yychar = YYEMPTY;
 2426         }
 2427     }
 2428 
 2429   /* Else will try to reuse lookahead token after shifting the error
 2430      token.  */
 2431   goto yyerrlab1;
 2432 
 2433 
 2434 /*---------------------------------------------------.
 2435 | yyerrorlab -- error raised explicitly by YYERROR.  |
 2436 `---------------------------------------------------*/
 2437 yyerrorlab:
 2438   /* Pacify compilers when the user code never invokes YYERROR and the
 2439      label yyerrorlab therefore never appears in user code.  */
 2440   if (0)
 2441     YYERROR;
 2442 
 2443   /* Do not reclaim the symbols of the rule whose action triggered
 2444      this YYERROR.  */
 2445   YYPOPSTACK (yylen);
 2446   yylen = 0;
 2447   YY_STACK_PRINT (yyss, yyssp);
 2448   yystate = *yyssp;
 2449   goto yyerrlab1;
 2450 
 2451 
 2452 /*-------------------------------------------------------------.
 2453 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 2454 `-------------------------------------------------------------*/
 2455 yyerrlab1:
 2456   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
 2457 
 2458   for (;;)
 2459     {
 2460       yyn = yypact[yystate];
 2461       if (!yypact_value_is_default (yyn))
 2462         {
 2463           yyn += YYTERROR;
 2464           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
 2465             {
 2466               yyn = yytable[yyn];
 2467               if (0 < yyn)
 2468                 break;
 2469             }
 2470         }
 2471 
 2472       /* Pop the current state because it cannot handle the error token.  */
 2473       if (yyssp == yyss)
 2474         YYABORT;
 2475 
 2476 
 2477       yydestruct ("Error: popping",
 2478                   yystos[yystate], yyvsp, cfg);
 2479       YYPOPSTACK (1);
 2480       yystate = *yyssp;
 2481       YY_STACK_PRINT (yyss, yyssp);
 2482     }
 2483 
 2484   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 2485   *++yyvsp = yylval;
 2486   YY_IGNORE_MAYBE_UNINITIALIZED_END
 2487 
 2488 
 2489   /* Shift the error token.  */
 2490   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 2491 
 2492   yystate = yyn;
 2493   goto yynewstate;
 2494 
 2495 
 2496 /*-------------------------------------.
 2497 | yyacceptlab -- YYACCEPT comes here.  |
 2498 `-------------------------------------*/
 2499 yyacceptlab:
 2500   yyresult = 0;
 2501   goto yyreturn;
 2502 
 2503 
 2504 /*-----------------------------------.
 2505 | yyabortlab -- YYABORT comes here.  |
 2506 `-----------------------------------*/
 2507 yyabortlab:
 2508   yyresult = 1;
 2509   goto yyreturn;
 2510 
 2511 
 2512 #if !defined yyoverflow || YYERROR_VERBOSE
 2513 /*-------------------------------------------------.
 2514 | yyexhaustedlab -- memory exhaustion comes here.  |
 2515 `-------------------------------------------------*/
 2516 yyexhaustedlab:
 2517   yyerror (cfg, YY_("memory exhausted"));
 2518   yyresult = 2;
 2519   /* Fall through.  */
 2520 #endif
 2521 
 2522 
 2523 /*-----------------------------------------------------.
 2524 | yyreturn -- parsing is finished, return the result.  |
 2525 `-----------------------------------------------------*/
 2526 yyreturn:
 2527   if (yychar != YYEMPTY)
 2528     {
 2529       /* Make sure we have latest lookahead translation.  See comments at
 2530          user semantic actions for why this is necessary.  */
 2531       yytoken = YYTRANSLATE (yychar);
 2532       yydestruct ("Cleanup: discarding lookahead",
 2533                   yytoken, &yylval, cfg);
 2534     }
 2535   /* Do not reclaim the symbols of the rule whose action triggered
 2536      this YYABORT or YYACCEPT.  */
 2537   YYPOPSTACK (yylen);
 2538   YY_STACK_PRINT (yyss, yyssp);
 2539   while (yyssp != yyss)
 2540     {
 2541       yydestruct ("Cleanup: popping",
 2542                   yystos[*yyssp], yyvsp, cfg);
 2543       YYPOPSTACK (1);
 2544     }
 2545 #ifndef yyoverflow
 2546   if (yyss != yyssa)
 2547     YYSTACK_FREE (yyss);
 2548 #endif
 2549 #if YYERROR_VERBOSE
 2550   if (yymsg != yymsgbuf)
 2551     YYSTACK_FREE (yymsg);
 2552 #endif
 2553   return yyresult;
 2554 }
 2555 #line 580 "cfg_parser.y" /* yacc.c:1918  */
 2556 
 2557 
 2558 void
 2559 yyerror(hitch_config *cfg, const char *s)
 2560 {
 2561     (void) cfg;
 2562 
 2563     /* Clean up if FRONTEND_BLK parsing failed */
 2564     if (cur_fa != NULL)
 2565         FREE_OBJ(cur_fa);
 2566 
 2567     config_error_set("Parsing error in line %d: %s: '%s'",
 2568         yyget_lineno(), s, strlen(input_line) > 0 ? input_line : "");
 2569 }