httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From wr...@apache.org
Subject svn commit: r396974 [3/5] - in /httpd/httpd/branches/2.2.x: ./ modules/aaa/ modules/arch/win32/ modules/cache/ modules/database/ modules/dav/fs/ modules/dav/main/ modules/debug/ modules/echo/ modules/filters/ modules/generators/ modules/http/ modules/l...
Date Tue, 25 Apr 2006 20:25:34 GMT
Modified: httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.c
URL: http://svn.apache.org/viewcvs/httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.c?rev=396974&r1=396973&r2=396974&view=diff
==============================================================================
--- httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.c (original)
+++ httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.c Tue Apr 25 13:24:55 2006
@@ -1,618 +1,1089 @@
-#ifndef lint
-static char const
-ssl_expr_yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28.2.1 2001/07/19 05:46:39 peter Exp $";
-#endif
-#include <stdlib.h>
-#define YYBYACC 1
-#define YYMAJOR 1
-#define YYMINOR 9
-#define YYLEX ssl_expr_yylex()
-#define YYEMPTY -1
-#define ssl_expr_yyclearin (ssl_expr_yychar=(YYEMPTY))
-#define ssl_expr_yyerrok (ssl_expr_yyerrflag=0)
-#define YYRECOVERING() (ssl_expr_yyerrflag!=0)
-#if defined(__cplusplus) || __STDC__
-static int ssl_expr_yygrowstack(void);
-#else
-static int ssl_expr_yygrowstack();
-#endif
-#define YYPREFIX "ssl_expr_yy"
-#line 36 "ssl_expr_parse.y"
+
+/*  A Bison parser, made from ssl_expr_parse.y
+    by GNU Bison version 1.28  */
+
+#define YYBISON 1  /* Identify Bison output.  */
+
+#define	T_TRUE	257
+#define	T_FALSE	258
+#define	T_DIGIT	259
+#define	T_ID	260
+#define	T_STRING	261
+#define	T_REGEX	262
+#define	T_REGEX_I	263
+#define	T_FUNC_FILE	264
+#define	T_OP_EQ	265
+#define	T_OP_NE	266
+#define	T_OP_LT	267
+#define	T_OP_LE	268
+#define	T_OP_GT	269
+#define	T_OP_GE	270
+#define	T_OP_REG	271
+#define	T_OP_NRE	272
+#define	T_OP_IN	273
+#define	T_OP_OID	274
+#define	T_OP_OR	275
+#define	T_OP_AND	276
+#define	T_OP_NOT	277
+
+#line 35 "ssl_expr_parse.y"
+
 #include "ssl_private.h"
+
 #line 39 "ssl_expr_parse.y"
 typedef union {
     char     *cpVal;
     ssl_expr *exVal;
 } YYSTYPE;
-#line 28 "y.tab.c"
-#define YYERRCODE 256
-#define T_TRUE 257
-#define T_FALSE 258
-#define T_DIGIT 259
-#define T_ID 260
-#define T_STRING 261
-#define T_REGEX 262
-#define T_REGEX_I 263
-#define T_FUNC_FILE 264
-#define T_OP_EQ 265
-#define T_OP_NE 266
-#define T_OP_LT 267
-#define T_OP_LE 268
-#define T_OP_GT 269
-#define T_OP_GE 270
-#define T_OP_REG 271
-#define T_OP_NRE 272
-#define T_OP_IN 273
-#define T_OP_OID 274
-#define T_OP_OR 275
-#define T_OP_AND 276
-#define T_OP_NOT 277
-const short ssl_expr_yylhs[] = {                                        -1,
-    0,    1,    1,    1,    1,    1,    1,    1,    2,    2,
-    2,    2,    2,    2,    2,    2,    2,    6,    6,    5,
-    5,    7,    7,    7,    7,    4,    4,    3,
-};
-const short ssl_expr_yylen[] = {                                         2,
-    1,    1,    1,    2,    3,    3,    1,    3,    3,    3,
-    3,    3,    3,    3,    3,    3,    3,    4,    3,    1,
-    3,    1,    1,    4,    1,    1,    1,    4,
-};
-const short ssl_expr_yydefred[] = {                                      0,
-    2,    3,   22,   23,    0,    0,    0,    0,    0,    0,
-    7,   25,    0,    0,    4,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    8,
-    0,    0,    6,    9,   10,   11,   12,   13,   14,   26,
-   27,   16,   17,    0,    0,   15,   28,   24,    0,    0,
-   20,    0,   19,    0,   18,   21,
-};
-const short ssl_expr_yydgoto[] = {                                       9,
-   10,   11,   12,   42,   50,   46,   13,
-};
-const short ssl_expr_yysindex[] = {                                    -37,
-    0,    0,    0,    0,  -16,  -37,  -37,  -92,    0, -248,
-    0,    0, -250, -228,    0,  -39, -226,  -37,  -37,  -33,
-  -33,  -33,  -33,  -33,  -33, -233, -233, -118,   -6,    0,
-  -88, -238,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,   -1,  -33,    0,    0,    0,  -33,  -38,
-    0,    2,    0,  -33,    0,    0,
-};
-const short ssl_expr_yyrindex[] = {                                      0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,   40,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    1,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,
-};
-const short ssl_expr_yygindex[] = {                                      0,
-    7,    0,    0,   17,    0,    0,  -13,
-};
-#define YYTABLESIZE 276
-const short ssl_expr_yytable[] = {                                       8,
-    5,   30,    7,    8,   45,   54,   34,   35,   36,   37,
-   38,   39,   15,   16,   20,   21,   22,   23,   24,   25,
-   26,   27,   28,   14,   32,   33,   18,   19,   40,   41,
-   17,   51,   29,   31,   47,   52,   48,   19,   49,    1,
-   56,    5,   55,   43,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,   53,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,   44,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    1,
-    2,    3,    0,    4,    0,    3,    5,    4,    0,    0,
-    5,    0,    0,    0,    0,   18,   19,    0,    0,    6,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    5,
-};
-const short ssl_expr_yycheck[] = {                                      37,
-    0,   41,   40,   37,  123,   44,   20,   21,   22,   23,
-   24,   25,    6,    7,  265,  266,  267,  268,  269,  270,
-  271,  272,  273,   40,   18,   19,  275,  276,  262,  263,
-  123,   45,  261,  260,   41,   49,  125,  276,   40,    0,
-   54,   41,   41,   27,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  125,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  274,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,
-  258,  259,   -1,  261,   -1,  259,  264,  261,   -1,   -1,
-  264,   -1,   -1,   -1,   -1,  275,  276,   -1,   -1,  277,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  275,
-};
-#define YYFINAL 9
-#ifndef YYDEBUG
-#define YYDEBUG 0
-#endif
-#define YYMAXTOKEN 277
-#if YYDEBUG
-const char * const ssl_expr_yyname[] = {
-"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,"'%'",0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"T_TRUE",
-"T_FALSE","T_DIGIT","T_ID","T_STRING","T_REGEX","T_REGEX_I","T_FUNC_FILE",
-"T_OP_EQ","T_OP_NE","T_OP_LT","T_OP_LE","T_OP_GT","T_OP_GE","T_OP_REG",
-"T_OP_NRE","T_OP_IN","T_OP_OID","T_OP_OR","T_OP_AND","T_OP_NOT",
-};
-const char * const ssl_expr_yyrule[] = {
-"$accept : root",
-"root : expr",
-"expr : T_TRUE",
-"expr : T_FALSE",
-"expr : T_OP_NOT expr",
-"expr : expr T_OP_OR expr",
-"expr : expr T_OP_AND expr",
-"expr : comparison",
-"expr : '(' expr ')'",
-"comparison : word T_OP_EQ word",
-"comparison : word T_OP_NE word",
-"comparison : word T_OP_LT word",
-"comparison : word T_OP_LE word",
-"comparison : word T_OP_GT word",
-"comparison : word T_OP_GE word",
-"comparison : word T_OP_IN wordlist",
-"comparison : word T_OP_REG regex",
-"comparison : word T_OP_NRE regex",
-"wordlist : T_OP_OID '(' word ')'",
-"wordlist : '{' words '}'",
-"words : word",
-"words : words ',' word",
-"word : T_DIGIT",
-"word : T_STRING",
-"word : '%' '{' T_ID '}'",
-"word : funccall",
-"regex : T_REGEX",
-"regex : T_REGEX_I",
-"funccall : T_FUNC_FILE '(' T_STRING ')'",
+#include <stdio.h>
+
+#ifndef __cplusplus
+#ifndef __STDC__
+#define const
+#endif
+#endif
+
+
+
+#define	YYFINAL		58
+#define	YYFLAG		-32768
+#define	YYNTBASE	30
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 277 ? ssl_expr_yytranslate[x] : 38)
+
+static const char ssl_expr_yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,    29,     2,     2,    24,
+    25,     2,     2,    28,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,    26,     2,    27,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
+     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+    17,    18,    19,    20,    21,    22,    23
 };
+
+#if YYDEBUG != 0
+static const short ssl_expr_yyprhs[] = {     0,
+     0,     2,     4,     6,     9,    13,    17,    19,    23,    27,
+    31,    35,    39,    43,    47,    51,    55,    59,    64,    68,
+    70,    74,    76,    78,    83,    85,    87,    89
+};
+
+static const short ssl_expr_yyrhs[] = {    31,
+     0,     3,     0,     4,     0,    23,    31,     0,    31,    21,
+    31,     0,    31,    22,    31,     0,    32,     0,    24,    31,
+    25,     0,    35,    11,    35,     0,    35,    12,    35,     0,
+    35,    13,    35,     0,    35,    14,    35,     0,    35,    15,
+    35,     0,    35,    16,    35,     0,    35,    19,    33,     0,
+    35,    17,    36,     0,    35,    18,    36,     0,    20,    24,
+    35,    25,     0,    26,    34,    27,     0,    35,     0,    34,
+    28,    35,     0,     5,     0,     7,     0,    29,    26,     6,
+    27,     0,    37,     0,     8,     0,     9,     0,    10,    24,
+     7,    25,     0
+};
+
 #endif
-#if YYDEBUG
-#include <stdio.h>
+
+#if YYDEBUG != 0
+static const short ssl_expr_yyrline[] = { 0,
+    84,    87,    88,    89,    90,    91,    92,    93,    96,    97,
+    98,    99,   100,   101,   102,   103,   104,   107,   108,   111,
+   112,   115,   116,   117,   118,   121,   130,   141
+};
 #endif
-#ifdef YYSTACKSIZE
-#undef YYMAXDEPTH
-#define YYMAXDEPTH YYSTACKSIZE
+
+
+#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+
+static const char * const ssl_expr_yytname[] = {   "$","error","$undefined.","T_TRUE",
+"T_FALSE","T_DIGIT","T_ID","T_STRING","T_REGEX","T_REGEX_I","T_FUNC_FILE","T_OP_EQ",
+"T_OP_NE","T_OP_LT","T_OP_LE","T_OP_GT","T_OP_GE","T_OP_REG","T_OP_NRE","T_OP_IN",
+"T_OP_OID","T_OP_OR","T_OP_AND","T_OP_NOT","'('","')'","'{'","'}'","','","'%'",
+"root","expr","comparison","wordlist","words","word","regex","funccall", NULL
+};
+#endif
+
+static const short ssl_expr_yyr1[] = {     0,
+    30,    31,    31,    31,    31,    31,    31,    31,    32,    32,
+    32,    32,    32,    32,    32,    32,    32,    33,    33,    34,
+    34,    35,    35,    35,    35,    36,    36,    37
+};
+
+static const short ssl_expr_yyr2[] = {     0,
+     1,     1,     1,     2,     3,     3,     1,     3,     3,     3,
+     3,     3,     3,     3,     3,     3,     3,     4,     3,     1,
+     3,     1,     1,     4,     1,     1,     1,     4
+};
+
+static const short ssl_expr_yydefact[] = {     0,
+     2,     3,    22,    23,     0,     0,     0,     0,     1,     7,
+     0,    25,     0,     4,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     8,     0,
+     5,     6,     9,    10,    11,    12,    13,    14,    26,    27,
+    16,    17,     0,     0,    15,    28,    24,     0,     0,    20,
+     0,    19,     0,    18,    21,     0,     0,     0
+};
+
+static const short ssl_expr_yydefgoto[] = {    56,
+     9,    10,    45,    49,    11,    41,    12
+};
+
+static const short ssl_expr_yypact[] = {     3,
+-32768,-32768,-32768,-32768,    -7,     3,     3,    -5,    -6,-32768,
+    24,-32768,    17,-32768,    23,    22,     3,     3,     4,     4,
+     4,     4,     4,     4,    14,    14,    -8,    25,-32768,    26,
+    27,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,    28,     4,-32768,-32768,-32768,     4,    19,-32768,
+    29,-32768,     4,-32768,-32768,    51,    55,-32768
+};
+
+static const short ssl_expr_yypgoto[] = {-32768,
+    13,-32768,-32768,-32768,   -19,    30,-32768
+};
+
+
+#define	YYLAST		56
+
+
+static const short ssl_expr_yytable[] = {    33,
+    34,    35,    36,    37,    38,     1,     2,     3,     3,     4,
+     4,    43,     5,     5,    17,    18,    13,    44,    14,    15,
+    16,    39,    40,    28,    50,     6,     7,    30,    51,    31,
+    32,     8,     8,    55,    19,    20,    21,    22,    23,    24,
+    25,    26,    27,    17,    18,    52,    53,    29,    18,    46,
+    57,    48,    47,    54,    58,    42
+};
+
+static const short ssl_expr_yycheck[] = {    19,
+    20,    21,    22,    23,    24,     3,     4,     5,     5,     7,
+     7,    20,    10,    10,    21,    22,    24,    26,     6,     7,
+    26,     8,     9,     7,    44,    23,    24,     6,    48,    17,
+    18,    29,    29,    53,    11,    12,    13,    14,    15,    16,
+    17,    18,    19,    21,    22,    27,    28,    25,    22,    25,
+     0,    24,    27,    25,     0,    26
+};
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "/usr/local/share/bison.simple"
+/* This file comes from bison-1.28.  */
+
+/* Skeleton output parser for bison,
+   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* This is the parser code that is written into each bison parser
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
+
+#ifndef YYSTACK_USE_ALLOCA
+#ifdef alloca
+#define YYSTACK_USE_ALLOCA
+#else /* alloca not defined */
+#ifdef __GNUC__
+#define YYSTACK_USE_ALLOCA
+#define alloca __builtin_alloca
+#else /* not GNU C.  */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+#define YYSTACK_USE_ALLOCA
+#include <alloca.h>
+#else /* not sparc */
+/* We think this test detects Watcom and Microsoft C.  */
+/* This used to test MSDOS, but that is a bad idea
+   since that symbol is in the user namespace.  */
+#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+#if 0 /* No need for malloc.h, which pollutes the namespace;
+	 instead, just don't use alloca.  */
+#include <malloc.h>
+#endif
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+/* I don't know what this was needed for, but it pollutes the namespace.
+   So I turned it off.   rms, 2 May 1997.  */
+/* #include <malloc.h>  */
+ #pragma alloca
+#define YYSTACK_USE_ALLOCA
+#else /* not MSDOS, or __TURBOC__, or _AIX */
+#if 0
+#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
+		 and on HPUX 10.  Eventually we can turn this on.  */
+#define YYSTACK_USE_ALLOCA
+#define alloca __builtin_alloca
+#endif /* __hpux */
+#endif
+#endif /* not _AIX */
+#endif /* not MSDOS, or __TURBOC__ */
+#endif /* not sparc */
+#endif /* not GNU C */
+#endif /* alloca not defined */
+#endif /* YYSTACK_USE_ALLOCA not defined */
+
+#ifdef YYSTACK_USE_ALLOCA
+#define YYSTACK_ALLOC alloca
 #else
-#ifdef YYMAXDEPTH
-#define YYSTACKSIZE YYMAXDEPTH
+#define YYSTACK_ALLOC malloc
+#endif
+
+/* Note: there must be only one dollar sign in this file.
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
+
+#define ssl_expr_yyerrok		(ssl_expr_yyerrstatus = 0)
+#define ssl_expr_yyclearin	(ssl_expr_yychar = YYEMPTY)
+#define YYEMPTY		-2
+#define YYEOF		0
+#define YYACCEPT	goto ssl_expr_yyacceptlab
+#define YYABORT 	goto ssl_expr_yyabortlab
+#define YYERROR		goto ssl_expr_yyerrlab1
+/* Like YYERROR except do call ssl_expr_yyerror.
+   This remains here temporarily to ease the
+   transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+#define YYFAIL		goto ssl_expr_yyerrlab
+#define YYRECOVERING()  (!!ssl_expr_yyerrstatus)
+#define YYBACKUP(token, value) \
+do								\
+  if (ssl_expr_yychar == YYEMPTY && ssl_expr_yylen == 1)				\
+    { ssl_expr_yychar = (token), ssl_expr_yylval = (value);			\
+      ssl_expr_yychar1 = YYTRANSLATE (ssl_expr_yychar);				\
+      YYPOPSTACK;						\
+      goto ssl_expr_yybackup;						\
+    }								\
+  else								\
+    { ssl_expr_yyerror ("syntax error: cannot back up"); YYERROR; }	\
+while (0)
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+#ifndef YYPURE
+#define YYLEX		ssl_expr_yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#ifdef YYLEX_PARAM
+#define YYLEX		ssl_expr_yylex(&ssl_expr_yylval, &ssl_expr_yylloc, YYLEX_PARAM)
 #else
-#define YYSTACKSIZE 10000
-#define YYMAXDEPTH 10000
+#define YYLEX		ssl_expr_yylex(&ssl_expr_yylval, &ssl_expr_yylloc)
 #endif
+#else /* not YYLSP_NEEDED */
+#ifdef YYLEX_PARAM
+#define YYLEX		ssl_expr_yylex(&ssl_expr_yylval, YYLEX_PARAM)
+#else
+#define YYLEX		ssl_expr_yylex(&ssl_expr_yylval)
+#endif
+#endif /* not YYLSP_NEEDED */
 #endif
-#define YYINITSTACKSIZE 200
-int ssl_expr_yydebug;
-int ssl_expr_yynerrs;
-int ssl_expr_yyerrflag;
-int ssl_expr_yychar;
-short *ssl_expr_yyssp;
-YYSTYPE *ssl_expr_yyvsp;
-YYSTYPE ssl_expr_yyval;
-YYSTYPE ssl_expr_yylval;
-short *ssl_expr_yyss;
-short *ssl_expr_yysslim;
-YYSTYPE *ssl_expr_yyvs;
-int ssl_expr_yystacksize;
-#line 148 "ssl_expr_parse.y"
 
-int ssl_expr_yyerror(char *s)
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+int	ssl_expr_yychar;			/*  the lookahead symbol		*/
+YYSTYPE	ssl_expr_yylval;			/*  the semantic value of the		*/
+				/*  lookahead symbol			*/
+
+#ifdef YYLSP_NEEDED
+YYLTYPE ssl_expr_yylloc;			/*  location data for the lookahead	*/
+				/*  symbol				*/
+#endif
+
+int ssl_expr_yynerrs;			/*  number of parse errors so far       */
+#endif  /* not YYPURE */
+
+#if YYDEBUG != 0
+int ssl_expr_yydebug;			/*  nonzero means print parse trace	*/
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
+#endif
+
+/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+
+#ifndef	YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/*  YYMAXDEPTH is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+/* Define __ssl_expr_yy_memcpy.  Note that the size argument
+   should be passed with type unsigned int, because that is what the non-GCC
+   definitions require.  With GCC, __builtin_memcpy takes an arg
+   of type size_t, but it can handle unsigned int.  */
+
+#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
+#define __ssl_expr_yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
+#else				/* not GNU C or C++ */
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__ssl_expr_yy_memcpy (to, from, count)
+     char *to;
+     char *from;
+     unsigned int count;
 {
-    ssl_expr_error = s;
-    return 2;
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
 }
 
-#line 237 "y.tab.c"
-/* allocate initial stack or double stack size, up to YYMAXDEPTH */
-static int ssl_expr_yygrowstack()
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__ssl_expr_yy_memcpy (char *to, char *from, unsigned int count)
 {
-    int newsize, i;
-    short *newss;
-    YYSTYPE *newvs;
-
-    if ((newsize = ssl_expr_yystacksize) == 0)
-        newsize = YYINITSTACKSIZE;
-    else if (newsize >= YYMAXDEPTH)
-        return -1;
-    else if ((newsize *= 2) > YYMAXDEPTH)
-        newsize = YYMAXDEPTH;
-    i = ssl_expr_yyssp - ssl_expr_yyss;
-    newss = ssl_expr_yyss ? (short *)realloc(ssl_expr_yyss, newsize * sizeof *newss) :
-      (short *)malloc(newsize * sizeof *newss);
-    if (newss == NULL)
-        return -1;
-    ssl_expr_yyss = newss;
-    ssl_expr_yyssp = newss + i;
-    newvs = ssl_expr_yyvs ? (YYSTYPE *)realloc(ssl_expr_yyvs, newsize * sizeof *newvs) :
-      (YYSTYPE *)malloc(newsize * sizeof *newvs);
-    if (newvs == NULL)
-        return -1;
-    ssl_expr_yyvs = newvs;
-    ssl_expr_yyvsp = newvs + i;
-    ssl_expr_yystacksize = newsize;
-    ssl_expr_yysslim = ssl_expr_yyss + newsize - 1;
-    return 0;
+  register char *t = to;
+  register char *f = from;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
 }
 
-#define YYABORT goto ssl_expr_yyabort
-#define YYREJECT goto ssl_expr_yyabort
-#define YYACCEPT goto ssl_expr_yyaccept
-#define YYERROR goto ssl_expr_yyerrlab
-
-#ifndef YYPARSE_PARAM
-#if defined(__cplusplus) || __STDC__
-#define YYPARSE_PARAM_ARG void
+#endif
+#endif
+
+#line 217 "/usr/local/share/bison.simple"
+
+/* The user can define YYPARSE_PARAM as the name of an argument to be passed
+   into ssl_expr_yyparse.  The argument should have type void *.
+   It should actually point to an object.
+   Grammar actions can access the variable by casting it
+   to the proper pointer type.  */
+
+#ifdef YYPARSE_PARAM
+#ifdef __cplusplus
+#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 #define YYPARSE_PARAM_DECL
-#else  /* ! ANSI-C/C++ */
+#else /* not __cplusplus */
+#define YYPARSE_PARAM_ARG YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+#endif /* not __cplusplus */
+#else /* not YYPARSE_PARAM */
 #define YYPARSE_PARAM_ARG
 #define YYPARSE_PARAM_DECL
-#endif  /* ANSI-C/C++ */
-#else   /* YYPARSE_PARAM */
-#ifndef YYPARSE_PARAM_TYPE
-#define YYPARSE_PARAM_TYPE void *
+#endif /* not YYPARSE_PARAM */
+
+/* Prevent warning if -Wstrict-prototypes.  */
+#ifdef __GNUC__
+#ifdef YYPARSE_PARAM
+int ssl_expr_yyparse (void *);
+#else
+int ssl_expr_yyparse (void);
+#endif
 #endif
-#if defined(__cplusplus) || __STDC__
-#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL
-#else  /* ! ANSI-C/C++ */
-#define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
-#endif  /* ANSI-C/C++ */
-#endif  /* ! YYPARSE_PARAM */
 
 int
-ssl_expr_yyparse (YYPARSE_PARAM_ARG)
-    YYPARSE_PARAM_DECL
+ssl_expr_yyparse(YYPARSE_PARAM_ARG)
+     YYPARSE_PARAM_DECL
 {
-    register int ssl_expr_yym, ssl_expr_yyn, ssl_expr_yystate;
-#if YYDEBUG
-    register const char *ssl_expr_yys;
-
-    if ((ssl_expr_yys = getenv("YYDEBUG")))
-    {
-        ssl_expr_yyn = *ssl_expr_yys;
-        if (ssl_expr_yyn >= '0' && ssl_expr_yyn <= '9')
-            ssl_expr_yydebug = ssl_expr_yyn - '0';
-    }
-#endif
-
-    ssl_expr_yynerrs = 0;
-    ssl_expr_yyerrflag = 0;
-    ssl_expr_yychar = (-1);
-
-    if (ssl_expr_yyss == NULL && ssl_expr_yygrowstack()) goto ssl_expr_yyoverflow;
-    ssl_expr_yyssp = ssl_expr_yyss;
-    ssl_expr_yyvsp = ssl_expr_yyvs;
-    *ssl_expr_yyssp = ssl_expr_yystate = 0;
-
-ssl_expr_yyloop:
-    if ((ssl_expr_yyn = ssl_expr_yydefred[ssl_expr_yystate])) goto ssl_expr_yyreduce;
-    if (ssl_expr_yychar < 0)
-    {
-        if ((ssl_expr_yychar = ssl_expr_yylex()) < 0) ssl_expr_yychar = 0;
-#if YYDEBUG
-        if (ssl_expr_yydebug)
-        {
-            ssl_expr_yys = 0;
-            if (ssl_expr_yychar <= YYMAXTOKEN) ssl_expr_yys = ssl_expr_yyname[ssl_expr_yychar];
-            if (!ssl_expr_yys) ssl_expr_yys = "illegal-symbol";
-            printf("%sdebug: state %d, reading %d (%s)\n",
-                    YYPREFIX, ssl_expr_yystate, ssl_expr_yychar, ssl_expr_yys);
-        }
-#endif
-    }
-    if ((ssl_expr_yyn = ssl_expr_yysindex[ssl_expr_yystate]) && (ssl_expr_yyn += ssl_expr_yychar) >= 0 &&
-            ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == ssl_expr_yychar)
-    {
-#if YYDEBUG
-        if (ssl_expr_yydebug)
-            printf("%sdebug: state %d, shifting to state %d\n",
-                    YYPREFIX, ssl_expr_yystate, ssl_expr_yytable[ssl_expr_yyn]);
-#endif
-        if (ssl_expr_yyssp >= ssl_expr_yysslim && ssl_expr_yygrowstack())
-        {
-            goto ssl_expr_yyoverflow;
-        }
-        *++ssl_expr_yyssp = ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yyn];
-        *++ssl_expr_yyvsp = ssl_expr_yylval;
-        ssl_expr_yychar = (-1);
-        if (ssl_expr_yyerrflag > 0)  --ssl_expr_yyerrflag;
-        goto ssl_expr_yyloop;
-    }
-    if ((ssl_expr_yyn = ssl_expr_yyrindex[ssl_expr_yystate]) && (ssl_expr_yyn += ssl_expr_yychar) >= 0 &&
-            ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == ssl_expr_yychar)
-    {
-        ssl_expr_yyn = ssl_expr_yytable[ssl_expr_yyn];
-        goto ssl_expr_yyreduce;
-    }
-    if (ssl_expr_yyerrflag) goto ssl_expr_yyinrecovery;
-#if defined(lint) || defined(__GNUC__)
-    goto ssl_expr_yynewerror;
-#endif
-ssl_expr_yynewerror:
-    ssl_expr_yyerror("syntax error");
-#if defined(lint) || defined(__GNUC__)
-    goto ssl_expr_yyerrlab;
+  register int ssl_expr_yystate;
+  register int ssl_expr_yyn;
+  register short *ssl_expr_yyssp;
+  register YYSTYPE *ssl_expr_yyvsp;
+  int ssl_expr_yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int ssl_expr_yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
+
+  short	ssl_expr_yyssa[YYINITDEPTH];	/*  the state stack			*/
+  YYSTYPE ssl_expr_yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
+
+  short *ssl_expr_yyss = ssl_expr_yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *ssl_expr_yyvs = ssl_expr_yyvsa;	/*  to allow ssl_expr_yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+  YYLTYPE ssl_expr_yylsa[YYINITDEPTH];	/*  the location stack			*/
+  YYLTYPE *ssl_expr_yyls = ssl_expr_yylsa;
+  YYLTYPE *ssl_expr_yylsp;
+
+#define YYPOPSTACK   (ssl_expr_yyvsp--, ssl_expr_yyssp--, ssl_expr_yylsp--)
+#else
+#define YYPOPSTACK   (ssl_expr_yyvsp--, ssl_expr_yyssp--)
 #endif
-ssl_expr_yyerrlab:
-    ++ssl_expr_yynerrs;
-ssl_expr_yyinrecovery:
-    if (ssl_expr_yyerrflag < 3)
-    {
-        ssl_expr_yyerrflag = 3;
-        for (;;)
-        {
-            if ((ssl_expr_yyn = ssl_expr_yysindex[*ssl_expr_yyssp]) && (ssl_expr_yyn += YYERRCODE) >= 0 &&
-                    ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == YYERRCODE)
-            {
-#if YYDEBUG
-                if (ssl_expr_yydebug)
-                    printf("%sdebug: state %d, error recovery shifting\
- to state %d\n", YYPREFIX, *ssl_expr_yyssp, ssl_expr_yytable[ssl_expr_yyn]);
-#endif
-                if (ssl_expr_yyssp >= ssl_expr_yysslim && ssl_expr_yygrowstack())
-                {
-                    goto ssl_expr_yyoverflow;
-                }
-                *++ssl_expr_yyssp = ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yyn];
-                *++ssl_expr_yyvsp = ssl_expr_yylval;
-                goto ssl_expr_yyloop;
-            }
-            else
-            {
-#if YYDEBUG
-                if (ssl_expr_yydebug)
-                    printf("%sdebug: error recovery discarding state %d\n",
-                            YYPREFIX, *ssl_expr_yyssp);
-#endif
-                if (ssl_expr_yyssp <= ssl_expr_yyss) goto ssl_expr_yyabort;
-                --ssl_expr_yyssp;
-                --ssl_expr_yyvsp;
-            }
-        }
-    }
-    else
-    {
-        if (ssl_expr_yychar == 0) goto ssl_expr_yyabort;
-#if YYDEBUG
-        if (ssl_expr_yydebug)
-        {
-            ssl_expr_yys = 0;
-            if (ssl_expr_yychar <= YYMAXTOKEN) ssl_expr_yys = ssl_expr_yyname[ssl_expr_yychar];
-            if (!ssl_expr_yys) ssl_expr_yys = "illegal-symbol";
-            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
-                    YYPREFIX, ssl_expr_yystate, ssl_expr_yychar, ssl_expr_yys);
-        }
+
+  int ssl_expr_yystacksize = YYINITDEPTH;
+  int ssl_expr_yyfree_stacks = 0;
+
+#ifdef YYPURE
+  int ssl_expr_yychar;
+  YYSTYPE ssl_expr_yylval;
+  int ssl_expr_yynerrs;
+#ifdef YYLSP_NEEDED
+  YYLTYPE ssl_expr_yylloc;
+#endif
+#endif
+
+  YYSTYPE ssl_expr_yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
+
+  int ssl_expr_yylen;
+
+#if YYDEBUG != 0
+  if (ssl_expr_yydebug)
+    fprintf(stderr, "Starting parse\n");
+#endif
+
+  ssl_expr_yystate = 0;
+  ssl_expr_yyerrstatus = 0;
+  ssl_expr_yynerrs = 0;
+  ssl_expr_yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  ssl_expr_yyssp = ssl_expr_yyss - 1;
+  ssl_expr_yyvsp = ssl_expr_yyvs;
+#ifdef YYLSP_NEEDED
+  ssl_expr_yylsp = ssl_expr_yyls;
+#endif
+
+/* Push a new state, which is found in  ssl_expr_yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+ssl_expr_yynewstate:
+
+  *++ssl_expr_yyssp = ssl_expr_yystate;
+
+  if (ssl_expr_yyssp >= ssl_expr_yyss + ssl_expr_yystacksize - 1)
+    {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+      YYSTYPE *ssl_expr_yyvs1 = ssl_expr_yyvs;
+      short *ssl_expr_yyss1 = ssl_expr_yyss;
+#ifdef YYLSP_NEEDED
+      YYLTYPE *ssl_expr_yyls1 = ssl_expr_yyls;
+#endif
+
+      /* Get the current used size of the three stacks, in elements.  */
+      int size = ssl_expr_yyssp - ssl_expr_yyss + 1;
+
+#ifdef ssl_expr_yyoverflow
+      /* Each stack pointer address is followed by the size of
+	 the data in use in that stack, in bytes.  */
+#ifdef YYLSP_NEEDED
+      /* This used to be a conditional around just the two extra args,
+	 but that might be undefined if ssl_expr_yyoverflow is a macro.  */
+      ssl_expr_yyoverflow("parser stack overflow",
+		 &ssl_expr_yyss1, size * sizeof (*ssl_expr_yyssp),
+		 &ssl_expr_yyvs1, size * sizeof (*ssl_expr_yyvsp),
+		 &ssl_expr_yyls1, size * sizeof (*ssl_expr_yylsp),
+		 &ssl_expr_yystacksize);
+#else
+      ssl_expr_yyoverflow("parser stack overflow",
+		 &ssl_expr_yyss1, size * sizeof (*ssl_expr_yyssp),
+		 &ssl_expr_yyvs1, size * sizeof (*ssl_expr_yyvsp),
+		 &ssl_expr_yystacksize);
+#endif
+
+      ssl_expr_yyss = ssl_expr_yyss1; ssl_expr_yyvs = ssl_expr_yyvs1;
+#ifdef YYLSP_NEEDED
+      ssl_expr_yyls = ssl_expr_yyls1;
+#endif
+#else /* no ssl_expr_yyoverflow */
+      /* Extend the stack our own way.  */
+      if (ssl_expr_yystacksize >= YYMAXDEPTH)
+	{
+	  ssl_expr_yyerror("parser stack overflow");
+	  if (ssl_expr_yyfree_stacks)
+	    {
+	      free (ssl_expr_yyss);
+	      free (ssl_expr_yyvs);
+#ifdef YYLSP_NEEDED
+	      free (ssl_expr_yyls);
 #endif
-        ssl_expr_yychar = (-1);
-        goto ssl_expr_yyloop;
+	    }
+	  return 2;
+	}
+      ssl_expr_yystacksize *= 2;
+      if (ssl_expr_yystacksize > YYMAXDEPTH)
+	ssl_expr_yystacksize = YYMAXDEPTH;
+#ifndef YYSTACK_USE_ALLOCA
+      ssl_expr_yyfree_stacks = 1;
+#endif
+      ssl_expr_yyss = (short *) YYSTACK_ALLOC (ssl_expr_yystacksize * sizeof (*ssl_expr_yyssp));
+      __ssl_expr_yy_memcpy ((char *)ssl_expr_yyss, (char *)ssl_expr_yyss1,
+		   size * (unsigned int) sizeof (*ssl_expr_yyssp));
+      ssl_expr_yyvs = (YYSTYPE *) YYSTACK_ALLOC (ssl_expr_yystacksize * sizeof (*ssl_expr_yyvsp));
+      __ssl_expr_yy_memcpy ((char *)ssl_expr_yyvs, (char *)ssl_expr_yyvs1,
+		   size * (unsigned int) sizeof (*ssl_expr_yyvsp));
+#ifdef YYLSP_NEEDED
+      ssl_expr_yyls = (YYLTYPE *) YYSTACK_ALLOC (ssl_expr_yystacksize * sizeof (*ssl_expr_yylsp));
+      __ssl_expr_yy_memcpy ((char *)ssl_expr_yyls, (char *)ssl_expr_yyls1,
+		   size * (unsigned int) sizeof (*ssl_expr_yylsp));
+#endif
+#endif /* no ssl_expr_yyoverflow */
+
+      ssl_expr_yyssp = ssl_expr_yyss + size - 1;
+      ssl_expr_yyvsp = ssl_expr_yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+      ssl_expr_yylsp = ssl_expr_yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+      if (ssl_expr_yydebug)
+	fprintf(stderr, "Stack size increased to %d\n", ssl_expr_yystacksize);
+#endif
+
+      if (ssl_expr_yyssp >= ssl_expr_yyss + ssl_expr_yystacksize - 1)
+	YYABORT;
+    }
+
+#if YYDEBUG != 0
+  if (ssl_expr_yydebug)
+    fprintf(stderr, "Entering state %d\n", ssl_expr_yystate);
+#endif
+
+  goto ssl_expr_yybackup;
+ ssl_expr_yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* ssl_expr_yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  ssl_expr_yyn = ssl_expr_yypact[ssl_expr_yystate];
+  if (ssl_expr_yyn == YYFLAG)
+    goto ssl_expr_yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* ssl_expr_yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (ssl_expr_yychar == YYEMPTY)
+    {
+#if YYDEBUG != 0
+      if (ssl_expr_yydebug)
+	fprintf(stderr, "Reading a token: ");
+#endif
+      ssl_expr_yychar = YYLEX;
     }
+
+  /* Convert token to internal form (in ssl_expr_yychar1) for indexing tables with */
+
+  if (ssl_expr_yychar <= 0)		/* This means end of input. */
+    {
+      ssl_expr_yychar1 = 0;
+      ssl_expr_yychar = YYEOF;		/* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+      if (ssl_expr_yydebug)
+	fprintf(stderr, "Now at end of input.\n");
+#endif
+    }
+  else
+    {
+      ssl_expr_yychar1 = YYTRANSLATE(ssl_expr_yychar);
+
+#if YYDEBUG != 0
+      if (ssl_expr_yydebug)
+	{
+	  fprintf (stderr, "Next token is %d (%s", ssl_expr_yychar, ssl_expr_yytname[ssl_expr_yychar1]);
+	  /* Give the individual parser a way to print the precise meaning
+	     of a token, for further debugging info.  */
+#ifdef YYPRINT
+	  YYPRINT (stderr, ssl_expr_yychar, ssl_expr_yylval);
+#endif
+	  fprintf (stderr, ")\n");
+	}
+#endif
+    }
+
+  ssl_expr_yyn += ssl_expr_yychar1;
+  if (ssl_expr_yyn < 0 || ssl_expr_yyn > YYLAST || ssl_expr_yycheck[ssl_expr_yyn] != ssl_expr_yychar1)
+    goto ssl_expr_yydefault;
+
+  ssl_expr_yyn = ssl_expr_yytable[ssl_expr_yyn];
+
+  /* ssl_expr_yyn is what to do for this token type in this state.
+     Negative => reduce, -ssl_expr_yyn is rule number.
+     Positive => shift, ssl_expr_yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (ssl_expr_yyn < 0)
+    {
+      if (ssl_expr_yyn == YYFLAG)
+	goto ssl_expr_yyerrlab;
+      ssl_expr_yyn = -ssl_expr_yyn;
+      goto ssl_expr_yyreduce;
+    }
+  else if (ssl_expr_yyn == 0)
+    goto ssl_expr_yyerrlab;
+
+  if (ssl_expr_yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+
+#if YYDEBUG != 0
+  if (ssl_expr_yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", ssl_expr_yychar, ssl_expr_yytname[ssl_expr_yychar1]);
+#endif
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (ssl_expr_yychar != YYEOF)
+    ssl_expr_yychar = YYEMPTY;
+
+  *++ssl_expr_yyvsp = ssl_expr_yylval;
+#ifdef YYLSP_NEEDED
+  *++ssl_expr_yylsp = ssl_expr_yylloc;
+#endif
+
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (ssl_expr_yyerrstatus) ssl_expr_yyerrstatus--;
+
+  ssl_expr_yystate = ssl_expr_yyn;
+  goto ssl_expr_yynewstate;
+
+/* Do the default action for the current state.  */
+ssl_expr_yydefault:
+
+  ssl_expr_yyn = ssl_expr_yydefact[ssl_expr_yystate];
+  if (ssl_expr_yyn == 0)
+    goto ssl_expr_yyerrlab;
+
+/* Do a reduction.  ssl_expr_yyn is the number of a rule to reduce with.  */
 ssl_expr_yyreduce:
-#if YYDEBUG
-    if (ssl_expr_yydebug)
-        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
-                YYPREFIX, ssl_expr_yystate, ssl_expr_yyn, ssl_expr_yyrule[ssl_expr_yyn]);
-#endif
-    ssl_expr_yym = ssl_expr_yylen[ssl_expr_yyn];
-    ssl_expr_yyval = ssl_expr_yyvsp[1-ssl_expr_yym];
-    switch (ssl_expr_yyn)
+  ssl_expr_yylen = ssl_expr_yyr2[ssl_expr_yyn];
+  if (ssl_expr_yylen > 0)
+    ssl_expr_yyval = ssl_expr_yyvsp[1-ssl_expr_yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+  if (ssl_expr_yydebug)
     {
+      int i;
+
+      fprintf (stderr, "Reducing via rule %d (line %d), ",
+	       ssl_expr_yyn, ssl_expr_yyrline[ssl_expr_yyn]);
+
+      /* Print the symbols being reduced, and their result.  */
+      for (i = ssl_expr_yyprhs[ssl_expr_yyn]; ssl_expr_yyrhs[i] > 0; i++)
+	fprintf (stderr, "%s ", ssl_expr_yytname[ssl_expr_yyrhs[i]]);
+      fprintf (stderr, " -> %s\n", ssl_expr_yytname[ssl_expr_yyr1[ssl_expr_yyn]]);
+    }
+#endif
+
+
+  switch (ssl_expr_yyn) {
+
 case 1:
 #line 84 "ssl_expr_parse.y"
-{ ssl_expr_info.expr = ssl_expr_yyvsp[0].exVal; }
-break;
+{ ssl_expr_info.expr = ssl_expr_yyvsp[0].exVal; ;
+    break;}
 case 2:
 #line 87 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_True,  NULL, NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_True,  NULL, NULL); ;
+    break;}
 case 3:
 #line 88 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_False, NULL, NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_False, NULL, NULL); ;
+    break;}
 case 4:
 #line 89 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_Not,   ssl_expr_yyvsp[0].exVal,   NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_Not,   ssl_expr_yyvsp[0].exVal,   NULL); ;
+    break;}
 case 5:
 #line 90 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_Or,    ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_Or,    ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   ;
+    break;}
 case 6:
 #line 91 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_And,   ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_And,   ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   ;
+    break;}
 case 7:
 #line 92 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_Comp,  ssl_expr_yyvsp[0].exVal,   NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_Comp,  ssl_expr_yyvsp[0].exVal,   NULL); ;
+    break;}
 case 8:
 #line 93 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[-1].exVal; }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[-1].exVal; ;
+    break;}
 case 9:
 #line 96 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_EQ,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_EQ,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 10:
 #line 97 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_NE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_NE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 11:
 #line 98 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_LT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_LT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 12:
 #line 99 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_LE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_LE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 13:
 #line 100 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_GT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_GT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 14:
 #line 101 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_GE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_GE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 15:
 #line 102 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_IN,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_IN,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 16:
 #line 103 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_REG, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_REG, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 17:
 #line 104 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_NRE, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_NRE, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); ;
+    break;}
 case 18:
 #line 107 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_OidListElement, ssl_expr_yyvsp[-1].exVal, NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_OidListElement, ssl_expr_yyvsp[-1].exVal, NULL); ;
+    break;}
 case 19:
 #line 108 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[-1].exVal ; }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[-1].exVal ; ;
+    break;}
 case 20:
 #line 111 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, NULL); ;
+    break;}
 case 21:
 #line 112 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, ssl_expr_yyvsp[-2].exVal);   }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, ssl_expr_yyvsp[-2].exVal);   ;
+    break;}
 case 22:
 #line 115 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_Digit,  ssl_expr_yyvsp[0].cpVal, NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_Digit,  ssl_expr_yyvsp[0].cpVal, NULL); ;
+    break;}
 case 23:
 #line 116 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_String, ssl_expr_yyvsp[0].cpVal, NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_String, ssl_expr_yyvsp[0].cpVal, NULL); ;
+    break;}
 case 24:
 #line 117 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_make(op_Var,    ssl_expr_yyvsp[-1].cpVal, NULL); }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_make(op_Var,    ssl_expr_yyvsp[-1].cpVal, NULL); ;
+    break;}
 case 25:
 #line 118 "ssl_expr_parse.y"
-{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[0].exVal; }
-break;
+{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[0].exVal; ;
+    break;}
 case 26:
 #line 121 "ssl_expr_parse.y"
-{
+{ 
                 ap_regex_t *regex;
-                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal,
+                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal, 
                                          AP_REG_EXTENDED|AP_REG_NOSUB)) == NULL) {
                     ssl_expr_error = "Failed to compile regular expression";
                     YYERROR;
                 }
                 ssl_expr_yyval.exVal = ssl_expr_make(op_Regex, regex, NULL);
-            }
-break;
+            ;
+    break;}
 case 27:
 #line 130 "ssl_expr_parse.y"
 {
                 ap_regex_t *regex;
-                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal,
+                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal, 
                                          AP_REG_EXTENDED|AP_REG_NOSUB|AP_REG_ICASE)) == NULL) {
                     ssl_expr_error = "Failed to compile regular expression";
                     YYERROR;
                 }
                 ssl_expr_yyval.exVal = ssl_expr_make(op_Regex, regex, NULL);
-            }
-break;
+            ;
+    break;}
 case 28:
 #line 141 "ssl_expr_parse.y"
-{
+{ 
                ssl_expr *args = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[-1].cpVal, NULL);
                ssl_expr_yyval.exVal = ssl_expr_make(op_Func, "file", args);
-            }
-break;
-#line 563 "y.tab.c"
-    }
-    ssl_expr_yyssp -= ssl_expr_yym;
-    ssl_expr_yystate = *ssl_expr_yyssp;
-    ssl_expr_yyvsp -= ssl_expr_yym;
-    ssl_expr_yym = ssl_expr_yylhs[ssl_expr_yyn];
-    if (ssl_expr_yystate == 0 && ssl_expr_yym == 0)
-    {
-#if YYDEBUG
-        if (ssl_expr_yydebug)
-            printf("%sdebug: after reduction, shifting from state 0 to\
- state %d\n", YYPREFIX, YYFINAL);
-#endif
-        ssl_expr_yystate = YYFINAL;
-        *++ssl_expr_yyssp = YYFINAL;
-        *++ssl_expr_yyvsp = ssl_expr_yyval;
-        if (ssl_expr_yychar < 0)
-        {
-            if ((ssl_expr_yychar = ssl_expr_yylex()) < 0) ssl_expr_yychar = 0;
-#if YYDEBUG
-            if (ssl_expr_yydebug)
-            {
-                ssl_expr_yys = 0;
-                if (ssl_expr_yychar <= YYMAXTOKEN) ssl_expr_yys = ssl_expr_yyname[ssl_expr_yychar];
-                if (!ssl_expr_yys) ssl_expr_yys = "illegal-symbol";
-                printf("%sdebug: state %d, reading %d (%s)\n",
-                        YYPREFIX, YYFINAL, ssl_expr_yychar, ssl_expr_yys);
-            }
-#endif
-        }
-        if (ssl_expr_yychar == 0) goto ssl_expr_yyaccept;
-        goto ssl_expr_yyloop;
-    }
-    if ((ssl_expr_yyn = ssl_expr_yygindex[ssl_expr_yym]) && (ssl_expr_yyn += ssl_expr_yystate) >= 0 &&
-            ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == ssl_expr_yystate)
-        ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yyn];
-    else
-        ssl_expr_yystate = ssl_expr_yydgoto[ssl_expr_yym];
-#if YYDEBUG
-    if (ssl_expr_yydebug)
-        printf("%sdebug: after reduction, shifting from state %d \
-to state %d\n", YYPREFIX, *ssl_expr_yyssp, ssl_expr_yystate);
-#endif
-    if (ssl_expr_yyssp >= ssl_expr_yysslim && ssl_expr_yygrowstack())
-    {
-        goto ssl_expr_yyoverflow;
-    }
-    *++ssl_expr_yyssp = ssl_expr_yystate;
-    *++ssl_expr_yyvsp = ssl_expr_yyval;
-    goto ssl_expr_yyloop;
-ssl_expr_yyoverflow:
-    ssl_expr_yyerror("yacc stack overflow");
-ssl_expr_yyabort:
-    return (1);
-ssl_expr_yyaccept:
-    return (0);
+            ;
+    break;}
+}
+   /* the action file gets copied in in place of this dollarsign */
+#line 543 "/usr/local/share/bison.simple"
+
+  ssl_expr_yyvsp -= ssl_expr_yylen;
+  ssl_expr_yyssp -= ssl_expr_yylen;
+#ifdef YYLSP_NEEDED
+  ssl_expr_yylsp -= ssl_expr_yylen;
+#endif
+
+#if YYDEBUG != 0
+  if (ssl_expr_yydebug)
+    {
+      short *ssp1 = ssl_expr_yyss - 1;
+      fprintf (stderr, "state stack now");
+      while (ssp1 != ssl_expr_yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+  *++ssl_expr_yyvsp = ssl_expr_yyval;
+
+#ifdef YYLSP_NEEDED
+  ssl_expr_yylsp++;
+  if (ssl_expr_yylen == 0)
+    {
+      ssl_expr_yylsp->first_line = ssl_expr_yylloc.first_line;
+      ssl_expr_yylsp->first_column = ssl_expr_yylloc.first_column;
+      ssl_expr_yylsp->last_line = (ssl_expr_yylsp-1)->last_line;
+      ssl_expr_yylsp->last_column = (ssl_expr_yylsp-1)->last_column;
+      ssl_expr_yylsp->text = 0;
+    }
+  else
+    {
+      ssl_expr_yylsp->last_line = (ssl_expr_yylsp+ssl_expr_yylen-1)->last_line;
+      ssl_expr_yylsp->last_column = (ssl_expr_yylsp+ssl_expr_yylen-1)->last_column;
+    }
+#endif
+
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
+
+  ssl_expr_yyn = ssl_expr_yyr1[ssl_expr_yyn];
+
+  ssl_expr_yystate = ssl_expr_yypgoto[ssl_expr_yyn - YYNTBASE] + *ssl_expr_yyssp;
+  if (ssl_expr_yystate >= 0 && ssl_expr_yystate <= YYLAST && ssl_expr_yycheck[ssl_expr_yystate] == *ssl_expr_yyssp)
+    ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yystate];
+  else
+    ssl_expr_yystate = ssl_expr_yydefgoto[ssl_expr_yyn - YYNTBASE];
+
+  goto ssl_expr_yynewstate;
+
+ssl_expr_yyerrlab:   /* here on detecting error */
+
+  if (! ssl_expr_yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
+      ++ssl_expr_yynerrs;
+
+#ifdef YYERROR_VERBOSE
+      ssl_expr_yyn = ssl_expr_yypact[ssl_expr_yystate];
+
+      if (ssl_expr_yyn > YYFLAG && ssl_expr_yyn < YYLAST)
+	{
+	  int size = 0;
+	  char *msg;
+	  int x, count;
+
+	  count = 0;
+	  /* Start X at -ssl_expr_yyn if nec to avoid negative indexes in ssl_expr_yycheck.  */
+	  for (x = (ssl_expr_yyn < 0 ? -ssl_expr_yyn : 0);
+	       x < (sizeof(ssl_expr_yytname) / sizeof(char *)); x++)
+	    if (ssl_expr_yycheck[x + ssl_expr_yyn] == x)
+	      size += strlen(ssl_expr_yytname[x]) + 15, count++;
+	  msg = (char *) malloc(size + 15);
+	  if (msg != 0)
+	    {
+	      strcpy(msg, "parse error");
+
+	      if (count < 5)
+		{
+		  count = 0;
+		  for (x = (ssl_expr_yyn < 0 ? -ssl_expr_yyn : 0);
+		       x < (sizeof(ssl_expr_yytname) / sizeof(char *)); x++)
+		    if (ssl_expr_yycheck[x + ssl_expr_yyn] == x)
+		      {
+			strcat(msg, count == 0 ? ", expecting `" : " or `");
+			strcat(msg, ssl_expr_yytname[x]);
+			strcat(msg, "'");
+			count++;
+		      }
+		}
+	      ssl_expr_yyerror(msg);
+	      free(msg);
+	    }
+	  else
+	    ssl_expr_yyerror ("parse error; also virtual memory exceeded");
+	}
+      else
+#endif /* YYERROR_VERBOSE */
+	ssl_expr_yyerror("parse error");
+    }
+
+  goto ssl_expr_yyerrlab1;
+ssl_expr_yyerrlab1:   /* here on error raised explicitly by an action */
+
+  if (ssl_expr_yyerrstatus == 3)
+    {
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+
+      /* return failure if at end of input */
+      if (ssl_expr_yychar == YYEOF)
+	YYABORT;
+
+#if YYDEBUG != 0
+      if (ssl_expr_yydebug)
+	fprintf(stderr, "Discarding token %d (%s).\n", ssl_expr_yychar, ssl_expr_yytname[ssl_expr_yychar1]);
+#endif
+
+      ssl_expr_yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
+
+  ssl_expr_yyerrstatus = 3;		/* Each real token shifted decrements this */
+
+  goto ssl_expr_yyerrhandle;
+
+ssl_expr_yyerrdefault:  /* current state does not do anything special for the error token. */
+
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  ssl_expr_yyn = ssl_expr_yydefact[ssl_expr_yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (ssl_expr_yyn) goto ssl_expr_yydefault;
+#endif
+
+ssl_expr_yyerrpop:   /* pop the current state because it cannot handle the error token */
+
+  if (ssl_expr_yyssp == ssl_expr_yyss) YYABORT;
+  ssl_expr_yyvsp--;
+  ssl_expr_yystate = *--ssl_expr_yyssp;
+#ifdef YYLSP_NEEDED
+  ssl_expr_yylsp--;
+#endif
+
+#if YYDEBUG != 0
+  if (ssl_expr_yydebug)
+    {
+      short *ssp1 = ssl_expr_yyss - 1;
+      fprintf (stderr, "Error: state stack now");
+      while (ssp1 != ssl_expr_yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+ssl_expr_yyerrhandle:
+
+  ssl_expr_yyn = ssl_expr_yypact[ssl_expr_yystate];
+  if (ssl_expr_yyn == YYFLAG)
+    goto ssl_expr_yyerrdefault;
+
+  ssl_expr_yyn += YYTERROR;
+  if (ssl_expr_yyn < 0 || ssl_expr_yyn > YYLAST || ssl_expr_yycheck[ssl_expr_yyn] != YYTERROR)
+    goto ssl_expr_yyerrdefault;
+
+  ssl_expr_yyn = ssl_expr_yytable[ssl_expr_yyn];
+  if (ssl_expr_yyn < 0)
+    {
+      if (ssl_expr_yyn == YYFLAG)
+	goto ssl_expr_yyerrpop;
+      ssl_expr_yyn = -ssl_expr_yyn;
+      goto ssl_expr_yyreduce;
+    }
+  else if (ssl_expr_yyn == 0)
+    goto ssl_expr_yyerrpop;
+
+  if (ssl_expr_yyn == YYFINAL)
+    YYACCEPT;
+
+#if YYDEBUG != 0
+  if (ssl_expr_yydebug)
+    fprintf(stderr, "Shifting error token, ");
+#endif
+
+  *++ssl_expr_yyvsp = ssl_expr_yylval;
+#ifdef YYLSP_NEEDED
+  *++ssl_expr_yylsp = ssl_expr_yylloc;
+#endif
+
+  ssl_expr_yystate = ssl_expr_yyn;
+  goto ssl_expr_yynewstate;
+
+ ssl_expr_yyacceptlab:
+  /* YYACCEPT comes here.  */
+  if (ssl_expr_yyfree_stacks)
+    {
+      free (ssl_expr_yyss);
+      free (ssl_expr_yyvs);
+#ifdef YYLSP_NEEDED
+      free (ssl_expr_yyls);
+#endif
+    }
+  return 0;
+
+ ssl_expr_yyabortlab:
+  /* YYABORT comes here.  */
+  if (ssl_expr_yyfree_stacks)
+    {
+      free (ssl_expr_yyss);
+      free (ssl_expr_yyvs);
+#ifdef YYLSP_NEEDED
+      free (ssl_expr_yyls);
+#endif
+    }
+  return 1;
 }
+#line 147 "ssl_expr_parse.y"
+
+
+int ssl_expr_yyerror(char *s)
+{
+    ssl_expr_error = s;
+    return 2;
+}
+

Modified: httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.h
URL: http://svn.apache.org/viewcvs/httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.h?rev=396974&r1=396973&r2=396974&view=diff
==============================================================================
--- httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.h (original)
+++ httpd/httpd/branches/2.2.x/modules/ssl/ssl_expr_parse.h Tue Apr 25 13:24:55 2006
@@ -1,30 +1,28 @@
-#ifndef YYERRCODE
-#define YYERRCODE 256
-#endif
-
-#define T_TRUE 257
-#define T_FALSE 258
-#define T_DIGIT 259
-#define T_ID 260
-#define T_STRING 261
-#define T_REGEX 262
-#define T_REGEX_I 263
-#define T_FUNC_FILE 264
-#define T_OP_EQ 265
-#define T_OP_NE 266
-#define T_OP_LT 267
-#define T_OP_LE 268
-#define T_OP_GT 269
-#define T_OP_GE 270
-#define T_OP_REG 271
-#define T_OP_NRE 272
-#define T_OP_IN 273
-#define T_OP_OID 274
-#define T_OP_OR 275
-#define T_OP_AND 276
-#define T_OP_NOT 277
 typedef union {
     char     *cpVal;
     ssl_expr *exVal;
 } YYSTYPE;
+#define	T_TRUE	257
+#define	T_FALSE	258
+#define	T_DIGIT	259
+#define	T_ID	260
+#define	T_STRING	261
+#define	T_REGEX	262
+#define	T_REGEX_I	263
+#define	T_FUNC_FILE	264
+#define	T_OP_EQ	265
+#define	T_OP_NE	266
+#define	T_OP_LT	267
+#define	T_OP_LE	268
+#define	T_OP_GT	269
+#define	T_OP_GE	270
+#define	T_OP_REG	271
+#define	T_OP_NRE	272
+#define	T_OP_IN	273
+#define	T_OP_OID	274
+#define	T_OP_OR	275
+#define	T_OP_AND	276
+#define	T_OP_NOT	277
+
+
 extern YYSTYPE ssl_expr_yylval;



Mime
View raw message