← Back to branch summary

~ubuntu-branches/ubuntu/feisty/apache2/feisty

« back to all changes in this revision

Viewing changes to modules/ssl/ssl_expr_parse.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Barth
  • Date: 2006-12-09 21:05:45 UTC
  • mfrom: (0.6.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061209210545-h70s0xaqc2v8vqr2
Tags: 2.2.3-3.2
http://bugs.debian.org/396265
* Non-maintainer upload.
* 043_ajp_connection_reuse: Patch from upstream Bugzilla, fixing a critical
  issue with regard to connection reuse in mod_proxy_ajp.
  Closes: #396265

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/ssl/ssl_expr_parse.c
 
1
#ifndef lint
 
2
static char const
 
3
ssl_expr_yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28.2.1 2001/07/19 05:46:39 peter Exp $";
 
4
#endif
 
5
#include <stdlib.h>
 
6
#define YYBYACC 1
 
7
#define YYMAJOR 1
 
8
#define YYMINOR 9
 
9
#define YYLEX ssl_expr_yylex()
 
10
#define YYEMPTY -1
 
11
#define ssl_expr_yyclearin (ssl_expr_yychar=(YYEMPTY))
 
12
#define ssl_expr_yyerrok (ssl_expr_yyerrflag=0)
 
13
#define YYRECOVERING() (ssl_expr_yyerrflag!=0)
 
14
#if defined(__cplusplus) || __STDC__
 
15
static int ssl_expr_yygrowstack(void);
 
16
#else
 
17
static int ssl_expr_yygrowstack();
 
18
#endif
 
19
#define YYPREFIX "ssl_expr_yy"
 
20
#line 36 "ssl_expr_parse.y"
 
21
#include "ssl_private.h"
 
22
#line 39 "ssl_expr_parse.y"
 
23
typedef union {
 
24
    char     *cpVal;
 
25
    ssl_expr *exVal;
 
26
} YYSTYPE;
 
27
#line 28 "y.tab.c"
 
28
#define YYERRCODE 256
 
29
#define T_TRUE 257
 
30
#define T_FALSE 258
 
31
#define T_DIGIT 259
 
32
#define T_ID 260
 
33
#define T_STRING 261
 
34
#define T_REGEX 262
 
35
#define T_REGEX_I 263
 
36
#define T_FUNC_FILE 264
 
37
#define T_OP_EQ 265
 
38
#define T_OP_NE 266
 
39
#define T_OP_LT 267
 
40
#define T_OP_LE 268
 
41
#define T_OP_GT 269
 
42
#define T_OP_GE 270
 
43
#define T_OP_REG 271
 
44
#define T_OP_NRE 272
 
45
#define T_OP_IN 273
 
46
#define T_OP_OID 274
 
47
#define T_OP_OR 275
 
48
#define T_OP_AND 276
 
49
#define T_OP_NOT 277
 
50
const short ssl_expr_yylhs[] = {                                        -1,
 
51
    0,    1,    1,    1,    1,    1,    1,    1,    2,    2,
 
52
    2,    2,    2,    2,    2,    2,    2,    6,    6,    5,
 
53
    5,    7,    7,    7,    7,    4,    4,    3,
 
54
};
 
55
const short ssl_expr_yylen[] = {                                         2,
 
56
    1,    1,    1,    2,    3,    3,    1,    3,    3,    3,
 
57
    3,    3,    3,    3,    3,    3,    3,    4,    3,    1,
 
58
    3,    1,    1,    4,    1,    1,    1,    4,
 
59
};
 
60
const short ssl_expr_yydefred[] = {                                      0,
 
61
    2,    3,   22,   23,    0,    0,    0,    0,    0,    0,
 
62
    7,   25,    0,    0,    4,    0,    0,    0,    0,    0,
 
63
    0,    0,    0,    0,    0,    0,    0,    0,    0,    8,
 
64
    0,    0,    6,    9,   10,   11,   12,   13,   14,   26,
 
65
   27,   16,   17,    0,    0,   15,   28,   24,    0,    0,
 
66
   20,    0,   19,    0,   18,   21,
 
67
};
 
68
const short ssl_expr_yydgoto[] = {                                       9,
 
69
   10,   11,   12,   42,   50,   46,   13,
 
70
};
 
71
const short ssl_expr_yysindex[] = {                                    -37,
 
72
    0,    0,    0,    0,  -16,  -37,  -37,  -92,    0, -248,
 
73
    0,    0, -250, -228,    0,  -39, -226,  -37,  -37,  -33,
 
74
  -33,  -33,  -33,  -33,  -33, -233, -233, -118,   -6,    0,
 
75
  -88, -238,    0,    0,    0,    0,    0,    0,    0,    0,
 
76
    0,    0,    0,   -1,  -33,    0,    0,    0,  -33,  -38,
 
77
    0,    2,    0,  -33,    0,    0,
 
78
};
 
79
const short ssl_expr_yyrindex[] = {                                      0,
 
80
    0,    0,    0,    0,    0,    0,    0,    0,    0,   40,
 
81
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
82
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
83
    0,    1,    0,    0,    0,    0,    0,    0,    0,    0,
 
84
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
85
    0,    0,    0,    0,    0,    0,
 
86
};
 
87
const short ssl_expr_yygindex[] = {                                      0,
 
88
    7,    0,    0,   17,    0,    0,  -13,
 
89
};
 
90
#define YYTABLESIZE 276
 
91
const short ssl_expr_yytable[] = {                                       8,
 
92
    5,   30,    7,    8,   45,   54,   34,   35,   36,   37,
 
93
   38,   39,   15,   16,   20,   21,   22,   23,   24,   25,
 
94
   26,   27,   28,   14,   32,   33,   18,   19,   40,   41,
 
95
   17,   51,   29,   31,   47,   52,   48,   19,   49,    1,
 
96
   56,    5,   55,   43,    0,    0,    0,    0,    0,    0,
 
97
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
98
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
99
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
100
    0,    0,    0,    0,    0,    0,   53,    0,    0,    0,
 
101
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
102
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
103
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
104
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
105
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
106
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
107
    0,    0,    0,    0,    0,   44,    0,    0,    0,    0,
 
108
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
109
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
110
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
111
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
112
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
113
    0,    0,    0,    0,    0,    0,    0,    0,    0,    1,
 
114
    2,    3,    0,    4,    0,    3,    5,    4,    0,    0,
 
115
    5,    0,    0,    0,    0,   18,   19,    0,    0,    6,
 
116
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
117
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
118
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
119
    0,    0,    0,    0,    0,    5,
 
120
};
 
121
const short ssl_expr_yycheck[] = {                                      37,
 
122
    0,   41,   40,   37,  123,   44,   20,   21,   22,   23,
 
123
   24,   25,    6,    7,  265,  266,  267,  268,  269,  270,
 
124
  271,  272,  273,   40,   18,   19,  275,  276,  262,  263,
 
125
  123,   45,  261,  260,   41,   49,  125,  276,   40,    0,
 
126
   54,   41,   41,   27,   -1,   -1,   -1,   -1,   -1,   -1,
 
127
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
128
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
129
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
130
   -1,   -1,   -1,   -1,   -1,   -1,  125,   -1,   -1,   -1,
 
131
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
132
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
133
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
134
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
135
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
136
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
137
   -1,   -1,   -1,   -1,   -1,  274,   -1,   -1,   -1,   -1,
 
138
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
139
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
140
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
141
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
142
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
143
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,
 
144
  258,  259,   -1,  261,   -1,  259,  264,  261,   -1,   -1,
 
145
  264,   -1,   -1,   -1,   -1,  275,  276,   -1,   -1,  277,
 
146
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
147
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
148
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 
149
   -1,   -1,   -1,   -1,   -1,  275,
 
150
};
 
151
#define YYFINAL 9
 
152
#ifndef YYDEBUG
 
153
#define YYDEBUG 0
 
154
#endif
 
155
#define YYMAXTOKEN 277
 
156
#if YYDEBUG
 
157
const char * const ssl_expr_yyname[] = {
 
158
"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,
 
159
0,0,0,"'%'",0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
160
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
161
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
162
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
163
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
164
0,0,0,0,0,0,0,0,0,0,0,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",
 
165
"T_FALSE","T_DIGIT","T_ID","T_STRING","T_REGEX","T_REGEX_I","T_FUNC_FILE",
 
166
"T_OP_EQ","T_OP_NE","T_OP_LT","T_OP_LE","T_OP_GT","T_OP_GE","T_OP_REG",
 
167
"T_OP_NRE","T_OP_IN","T_OP_OID","T_OP_OR","T_OP_AND","T_OP_NOT",
 
168
};
 
169
const char * const ssl_expr_yyrule[] = {
 
170
"$accept : root",
 
171
"root : expr",
 
172
"expr : T_TRUE",
 
173
"expr : T_FALSE",
 
174
"expr : T_OP_NOT expr",
 
175
"expr : expr T_OP_OR expr",
 
176
"expr : expr T_OP_AND expr",
 
177
"expr : comparison",
 
178
"expr : '(' expr ')'",
 
179
"comparison : word T_OP_EQ word",
 
180
"comparison : word T_OP_NE word",
 
181
"comparison : word T_OP_LT word",
 
182
"comparison : word T_OP_LE word",
 
183
"comparison : word T_OP_GT word",
 
184
"comparison : word T_OP_GE word",
 
185
"comparison : word T_OP_IN wordlist",
 
186
"comparison : word T_OP_REG regex",
 
187
"comparison : word T_OP_NRE regex",
 
188
"wordlist : T_OP_OID '(' word ')'",
 
189
"wordlist : '{' words '}'",
 
190
"words : word",
 
191
"words : words ',' word",
 
192
"word : T_DIGIT",
 
193
"word : T_STRING",
 
194
"word : '%' '{' T_ID '}'",
 
195
"word : funccall",
 
196
"regex : T_REGEX",
 
197
"regex : T_REGEX_I",
 
198
"funccall : T_FUNC_FILE '(' T_STRING ')'",
 
199
};
 
200
#endif
 
201
#if YYDEBUG
 
202
#include <stdio.h>
 
203
#endif
 
204
#ifdef YYSTACKSIZE
 
205
#undef YYMAXDEPTH
 
206
#define YYMAXDEPTH YYSTACKSIZE
 
207
#else
 
208
#ifdef YYMAXDEPTH
 
209
#define YYSTACKSIZE YYMAXDEPTH
 
210
#else
 
211
#define YYSTACKSIZE 10000
 
212
#define YYMAXDEPTH 10000
 
213
#endif
 
214
#endif
 
215
#define YYINITSTACKSIZE 200
 
216
int ssl_expr_yydebug;
 
217
int ssl_expr_yynerrs;
 
218
int ssl_expr_yyerrflag;
 
219
int ssl_expr_yychar;
 
220
short *ssl_expr_yyssp;
 
221
YYSTYPE *ssl_expr_yyvsp;
 
222
YYSTYPE ssl_expr_yyval;
 
223
YYSTYPE ssl_expr_yylval;
 
224
short *ssl_expr_yyss;
 
225
short *ssl_expr_yysslim;
 
226
YYSTYPE *ssl_expr_yyvs;
 
227
int ssl_expr_yystacksize;
 
228
#line 148 "ssl_expr_parse.y"
 
229
 
 
230
int ssl_expr_yyerror(char *s)
 
231
{
 
232
    ssl_expr_error = s;
 
233
    return 2;
 
234
}
 
235
 
 
236
#line 237 "y.tab.c"
 
237
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
 
238
static int ssl_expr_yygrowstack()
 
239
{
 
240
    int newsize, i;
 
241
    short *newss;
 
242
    YYSTYPE *newvs;
 
243
 
 
244
    if ((newsize = ssl_expr_yystacksize) == 0)
 
245
        newsize = YYINITSTACKSIZE;
 
246
    else if (newsize >= YYMAXDEPTH)
 
247
        return -1;
 
248
    else if ((newsize *= 2) > YYMAXDEPTH)
 
249
        newsize = YYMAXDEPTH;
 
250
    i = ssl_expr_yyssp - ssl_expr_yyss;
 
251
    newss = ssl_expr_yyss ? (short *)realloc(ssl_expr_yyss, newsize * sizeof *newss) :
 
252
      (short *)malloc(newsize * sizeof *newss);
 
253
    if (newss == NULL)
 
254
        return -1;
 
255
    ssl_expr_yyss = newss;
 
256
    ssl_expr_yyssp = newss + i;
 
257
    newvs = ssl_expr_yyvs ? (YYSTYPE *)realloc(ssl_expr_yyvs, newsize * sizeof *newvs) :
 
258
      (YYSTYPE *)malloc(newsize * sizeof *newvs);
 
259
    if (newvs == NULL)
 
260
        return -1;
 
261
    ssl_expr_yyvs = newvs;
 
262
    ssl_expr_yyvsp = newvs + i;
 
263
    ssl_expr_yystacksize = newsize;
 
264
    ssl_expr_yysslim = ssl_expr_yyss + newsize - 1;
 
265
    return 0;
 
266
}
 
267
 
 
268
#define YYABORT goto ssl_expr_yyabort
 
269
#define YYREJECT goto ssl_expr_yyabort
 
270
#define YYACCEPT goto ssl_expr_yyaccept
 
271
#define YYERROR goto ssl_expr_yyerrlab
 
272
 
 
273
#ifndef YYPARSE_PARAM
 
274
#if defined(__cplusplus) || __STDC__
 
275
#define YYPARSE_PARAM_ARG void
 
276
#define YYPARSE_PARAM_DECL
 
277
#else  /* ! ANSI-C/C++ */
 
278
#define YYPARSE_PARAM_ARG
 
279
#define YYPARSE_PARAM_DECL
 
280
#endif  /* ANSI-C/C++ */
 
281
#else   /* YYPARSE_PARAM */
 
282
#ifndef YYPARSE_PARAM_TYPE
 
283
#define YYPARSE_PARAM_TYPE void *
 
284
#endif
 
285
#if defined(__cplusplus) || __STDC__
 
286
#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
 
287
#define YYPARSE_PARAM_DECL
 
288
#else  /* ! ANSI-C/C++ */
 
289
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
 
290
#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
 
291
#endif  /* ANSI-C/C++ */
 
292
#endif  /* ! YYPARSE_PARAM */
 
293
 
 
294
int
 
295
ssl_expr_yyparse (YYPARSE_PARAM_ARG)
 
296
    YYPARSE_PARAM_DECL
 
297
{
 
298
    register int ssl_expr_yym, ssl_expr_yyn, ssl_expr_yystate;
 
299
#if YYDEBUG
 
300
    register const char *ssl_expr_yys;
 
301
 
 
302
    if ((ssl_expr_yys = getenv("YYDEBUG")))
 
303
    {
 
304
        ssl_expr_yyn = *ssl_expr_yys;
 
305
        if (ssl_expr_yyn >= '0' && ssl_expr_yyn <= '9')
 
306
            ssl_expr_yydebug = ssl_expr_yyn - '0';
 
307
    }
 
308
#endif
 
309
 
 
310
    ssl_expr_yynerrs = 0;
 
311
    ssl_expr_yyerrflag = 0;
 
312
    ssl_expr_yychar = (-1);
 
313
 
 
314
    if (ssl_expr_yyss == NULL && ssl_expr_yygrowstack()) goto ssl_expr_yyoverflow;
 
315
    ssl_expr_yyssp = ssl_expr_yyss;
 
316
    ssl_expr_yyvsp = ssl_expr_yyvs;
 
317
    *ssl_expr_yyssp = ssl_expr_yystate = 0;
 
318
 
 
319
ssl_expr_yyloop:
 
320
    if ((ssl_expr_yyn = ssl_expr_yydefred[ssl_expr_yystate])) goto ssl_expr_yyreduce;
 
321
    if (ssl_expr_yychar < 0)
 
322
    {
 
323
        if ((ssl_expr_yychar = ssl_expr_yylex()) < 0) ssl_expr_yychar = 0;
 
324
#if YYDEBUG
 
325
        if (ssl_expr_yydebug)
 
326
        {
 
327
            ssl_expr_yys = 0;
 
328
            if (ssl_expr_yychar <= YYMAXTOKEN) ssl_expr_yys = ssl_expr_yyname[ssl_expr_yychar];
 
329
            if (!ssl_expr_yys) ssl_expr_yys = "illegal-symbol";
 
330
            printf("%sdebug: state %d, reading %d (%s)\n",
 
331
                    YYPREFIX, ssl_expr_yystate, ssl_expr_yychar, ssl_expr_yys);
 
332
        }
 
333
#endif
 
334
    }
 
335
    if ((ssl_expr_yyn = ssl_expr_yysindex[ssl_expr_yystate]) && (ssl_expr_yyn += ssl_expr_yychar) >= 0 &&
 
336
            ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == ssl_expr_yychar)
 
337
    {
 
338
#if YYDEBUG
 
339
        if (ssl_expr_yydebug)
 
340
            printf("%sdebug: state %d, shifting to state %d\n",
 
341
                    YYPREFIX, ssl_expr_yystate, ssl_expr_yytable[ssl_expr_yyn]);
 
342
#endif
 
343
        if (ssl_expr_yyssp >= ssl_expr_yysslim && ssl_expr_yygrowstack())
 
344
        {
 
345
            goto ssl_expr_yyoverflow;
 
346
        }
 
347
        *++ssl_expr_yyssp = ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yyn];
 
348
        *++ssl_expr_yyvsp = ssl_expr_yylval;
 
349
        ssl_expr_yychar = (-1);
 
350
        if (ssl_expr_yyerrflag > 0)  --ssl_expr_yyerrflag;
 
351
        goto ssl_expr_yyloop;
 
352
    }
 
353
    if ((ssl_expr_yyn = ssl_expr_yyrindex[ssl_expr_yystate]) && (ssl_expr_yyn += ssl_expr_yychar) >= 0 &&
 
354
            ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == ssl_expr_yychar)
 
355
    {
 
356
        ssl_expr_yyn = ssl_expr_yytable[ssl_expr_yyn];
 
357
        goto ssl_expr_yyreduce;
 
358
    }
 
359
    if (ssl_expr_yyerrflag) goto ssl_expr_yyinrecovery;
 
360
#if defined(lint) || defined(__GNUC__)
 
361
    goto ssl_expr_yynewerror;
 
362
#endif
 
363
ssl_expr_yynewerror:
 
364
    ssl_expr_yyerror("syntax error");
 
365
#if defined(lint) || defined(__GNUC__)
 
366
    goto ssl_expr_yyerrlab;
 
367
#endif
 
368
ssl_expr_yyerrlab:
 
369
    ++ssl_expr_yynerrs;
 
370
ssl_expr_yyinrecovery:
 
371
    if (ssl_expr_yyerrflag < 3)
 
372
    {
 
373
        ssl_expr_yyerrflag = 3;
 
374
        for (;;)
 
375
        {
 
376
            if ((ssl_expr_yyn = ssl_expr_yysindex[*ssl_expr_yyssp]) && (ssl_expr_yyn += YYERRCODE) >= 0 &&
 
377
                    ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == YYERRCODE)
 
378
            {
 
379
#if YYDEBUG
 
380
                if (ssl_expr_yydebug)
 
381
                    printf("%sdebug: state %d, error recovery shifting\
 
382
 to state %d\n", YYPREFIX, *ssl_expr_yyssp, ssl_expr_yytable[ssl_expr_yyn]);
 
383
#endif
 
384
                if (ssl_expr_yyssp >= ssl_expr_yysslim && ssl_expr_yygrowstack())
 
385
                {
 
386
                    goto ssl_expr_yyoverflow;
 
387
                }
 
388
                *++ssl_expr_yyssp = ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yyn];
 
389
                *++ssl_expr_yyvsp = ssl_expr_yylval;
 
390
                goto ssl_expr_yyloop;
 
391
            }
 
392
            else
 
393
            {
 
394
#if YYDEBUG
 
395
                if (ssl_expr_yydebug)
 
396
                    printf("%sdebug: error recovery discarding state %d\n",
 
397
                            YYPREFIX, *ssl_expr_yyssp);
 
398
#endif
 
399
                if (ssl_expr_yyssp <= ssl_expr_yyss) goto ssl_expr_yyabort;
 
400
                --ssl_expr_yyssp;
 
401
                --ssl_expr_yyvsp;
 
402
            }
 
403
        }
 
404
    }
 
405
    else
 
406
    {
 
407
        if (ssl_expr_yychar == 0) goto ssl_expr_yyabort;
 
408
#if YYDEBUG
 
409
        if (ssl_expr_yydebug)
 
410
        {
 
411
            ssl_expr_yys = 0;
 
412
            if (ssl_expr_yychar <= YYMAXTOKEN) ssl_expr_yys = ssl_expr_yyname[ssl_expr_yychar];
 
413
            if (!ssl_expr_yys) ssl_expr_yys = "illegal-symbol";
 
414
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 
415
                    YYPREFIX, ssl_expr_yystate, ssl_expr_yychar, ssl_expr_yys);
 
416
        }
 
417
#endif
 
418
        ssl_expr_yychar = (-1);
 
419
        goto ssl_expr_yyloop;
 
420
    }
 
421
ssl_expr_yyreduce:
 
422
#if YYDEBUG
 
423
    if (ssl_expr_yydebug)
 
424
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 
425
                YYPREFIX, ssl_expr_yystate, ssl_expr_yyn, ssl_expr_yyrule[ssl_expr_yyn]);
 
426
#endif
 
427
    ssl_expr_yym = ssl_expr_yylen[ssl_expr_yyn];
 
428
    ssl_expr_yyval = ssl_expr_yyvsp[1-ssl_expr_yym];
 
429
    switch (ssl_expr_yyn)
 
430
    {
 
431
case 1:
 
432
#line 84 "ssl_expr_parse.y"
 
433
{ ssl_expr_info.expr = ssl_expr_yyvsp[0].exVal; }
 
434
break;
 
435
case 2:
 
436
#line 87 "ssl_expr_parse.y"
 
437
{ ssl_expr_yyval.exVal = ssl_expr_make(op_True,  NULL, NULL); }
 
438
break;
 
439
case 3:
 
440
#line 88 "ssl_expr_parse.y"
 
441
{ ssl_expr_yyval.exVal = ssl_expr_make(op_False, NULL, NULL); }
 
442
break;
 
443
case 4:
 
444
#line 89 "ssl_expr_parse.y"
 
445
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Not,   ssl_expr_yyvsp[0].exVal,   NULL); }
 
446
break;
 
447
case 5:
 
448
#line 90 "ssl_expr_parse.y"
 
449
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Or,    ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   }
 
450
break;
 
451
case 6:
 
452
#line 91 "ssl_expr_parse.y"
 
453
{ ssl_expr_yyval.exVal = ssl_expr_make(op_And,   ssl_expr_yyvsp[-2].exVal,   ssl_expr_yyvsp[0].exVal);   }
 
454
break;
 
455
case 7:
 
456
#line 92 "ssl_expr_parse.y"
 
457
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Comp,  ssl_expr_yyvsp[0].exVal,   NULL); }
 
458
break;
 
459
case 8:
 
460
#line 93 "ssl_expr_parse.y"
 
461
{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[-1].exVal; }
 
462
break;
 
463
case 9:
 
464
#line 96 "ssl_expr_parse.y"
 
465
{ ssl_expr_yyval.exVal = ssl_expr_make(op_EQ,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
466
break;
 
467
case 10:
 
468
#line 97 "ssl_expr_parse.y"
 
469
{ ssl_expr_yyval.exVal = ssl_expr_make(op_NE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
470
break;
 
471
case 11:
 
472
#line 98 "ssl_expr_parse.y"
 
473
{ ssl_expr_yyval.exVal = ssl_expr_make(op_LT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
474
break;
 
475
case 12:
 
476
#line 99 "ssl_expr_parse.y"
 
477
{ ssl_expr_yyval.exVal = ssl_expr_make(op_LE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
478
break;
 
479
case 13:
 
480
#line 100 "ssl_expr_parse.y"
 
481
{ ssl_expr_yyval.exVal = ssl_expr_make(op_GT,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
482
break;
 
483
case 14:
 
484
#line 101 "ssl_expr_parse.y"
 
485
{ ssl_expr_yyval.exVal = ssl_expr_make(op_GE,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
486
break;
 
487
case 15:
 
488
#line 102 "ssl_expr_parse.y"
 
489
{ ssl_expr_yyval.exVal = ssl_expr_make(op_IN,  ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
490
break;
 
491
case 16:
 
492
#line 103 "ssl_expr_parse.y"
 
493
{ ssl_expr_yyval.exVal = ssl_expr_make(op_REG, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
494
break;
 
495
case 17:
 
496
#line 104 "ssl_expr_parse.y"
 
497
{ ssl_expr_yyval.exVal = ssl_expr_make(op_NRE, ssl_expr_yyvsp[-2].exVal, ssl_expr_yyvsp[0].exVal); }
 
498
break;
 
499
case 18:
 
500
#line 107 "ssl_expr_parse.y"
 
501
{ ssl_expr_yyval.exVal = ssl_expr_make(op_OidListElement, ssl_expr_yyvsp[-1].exVal, NULL); }
 
502
break;
 
503
case 19:
 
504
#line 108 "ssl_expr_parse.y"
 
505
{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[-1].exVal ; }
 
506
break;
 
507
case 20:
 
508
#line 111 "ssl_expr_parse.y"
 
509
{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, NULL); }
 
510
break;
 
511
case 21:
 
512
#line 112 "ssl_expr_parse.y"
 
513
{ ssl_expr_yyval.exVal = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[0].exVal, ssl_expr_yyvsp[-2].exVal);   }
 
514
break;
 
515
case 22:
 
516
#line 115 "ssl_expr_parse.y"
 
517
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Digit,  ssl_expr_yyvsp[0].cpVal, NULL); }
 
518
break;
 
519
case 23:
 
520
#line 116 "ssl_expr_parse.y"
 
521
{ ssl_expr_yyval.exVal = ssl_expr_make(op_String, ssl_expr_yyvsp[0].cpVal, NULL); }
 
522
break;
 
523
case 24:
 
524
#line 117 "ssl_expr_parse.y"
 
525
{ ssl_expr_yyval.exVal = ssl_expr_make(op_Var,    ssl_expr_yyvsp[-1].cpVal, NULL); }
 
526
break;
 
527
case 25:
 
528
#line 118 "ssl_expr_parse.y"
 
529
{ ssl_expr_yyval.exVal = ssl_expr_yyvsp[0].exVal; }
 
530
break;
 
531
case 26:
 
532
#line 121 "ssl_expr_parse.y"
 
533
{
 
534
                ap_regex_t *regex;
 
535
                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal,
 
536
                                         AP_REG_EXTENDED|AP_REG_NOSUB)) == NULL) {
 
537
                    ssl_expr_error = "Failed to compile regular expression";
 
538
                    YYERROR;
 
539
                }
 
540
                ssl_expr_yyval.exVal = ssl_expr_make(op_Regex, regex, NULL);
 
541
            }
 
542
break;
 
543
case 27:
 
544
#line 130 "ssl_expr_parse.y"
 
545
{
 
546
                ap_regex_t *regex;
 
547
                if ((regex = ap_pregcomp(ssl_expr_info.pool, ssl_expr_yyvsp[0].cpVal,
 
548
                                         AP_REG_EXTENDED|AP_REG_NOSUB|AP_REG_ICASE)) == NULL) {
 
549
                    ssl_expr_error = "Failed to compile regular expression";
 
550
                    YYERROR;
 
551
                }
 
552
                ssl_expr_yyval.exVal = ssl_expr_make(op_Regex, regex, NULL);
 
553
            }
 
554
break;
 
555
case 28:
 
556
#line 141 "ssl_expr_parse.y"
 
557
{
 
558
               ssl_expr *args = ssl_expr_make(op_ListElement, ssl_expr_yyvsp[-1].cpVal, NULL);
 
559
               ssl_expr_yyval.exVal = ssl_expr_make(op_Func, "file", args);
 
560
            }
 
561
break;
 
562
#line 563 "y.tab.c"
 
563
    }
 
564
    ssl_expr_yyssp -= ssl_expr_yym;
 
565
    ssl_expr_yystate = *ssl_expr_yyssp;
 
566
    ssl_expr_yyvsp -= ssl_expr_yym;
 
567
    ssl_expr_yym = ssl_expr_yylhs[ssl_expr_yyn];
 
568
    if (ssl_expr_yystate == 0 && ssl_expr_yym == 0)
 
569
    {
 
570
#if YYDEBUG
 
571
        if (ssl_expr_yydebug)
 
572
            printf("%sdebug: after reduction, shifting from state 0 to\
 
573
 state %d\n", YYPREFIX, YYFINAL);
 
574
#endif
 
575
        ssl_expr_yystate = YYFINAL;
 
576
        *++ssl_expr_yyssp = YYFINAL;
 
577
        *++ssl_expr_yyvsp = ssl_expr_yyval;
 
578
        if (ssl_expr_yychar < 0)
 
579
        {
 
580
            if ((ssl_expr_yychar = ssl_expr_yylex()) < 0) ssl_expr_yychar = 0;
 
581
#if YYDEBUG
 
582
            if (ssl_expr_yydebug)
 
583
            {
 
584
                ssl_expr_yys = 0;
 
585
                if (ssl_expr_yychar <= YYMAXTOKEN) ssl_expr_yys = ssl_expr_yyname[ssl_expr_yychar];
 
586
                if (!ssl_expr_yys) ssl_expr_yys = "illegal-symbol";
 
587
                printf("%sdebug: state %d, reading %d (%s)\n",
 
588
                        YYPREFIX, YYFINAL, ssl_expr_yychar, ssl_expr_yys);
 
589
            }
 
590
#endif
 
591
        }
 
592
        if (ssl_expr_yychar == 0) goto ssl_expr_yyaccept;
 
593
        goto ssl_expr_yyloop;
 
594
    }
 
595
    if ((ssl_expr_yyn = ssl_expr_yygindex[ssl_expr_yym]) && (ssl_expr_yyn += ssl_expr_yystate) >= 0 &&
 
596
            ssl_expr_yyn <= YYTABLESIZE && ssl_expr_yycheck[ssl_expr_yyn] == ssl_expr_yystate)
 
597
        ssl_expr_yystate = ssl_expr_yytable[ssl_expr_yyn];
 
598
    else
 
599
        ssl_expr_yystate = ssl_expr_yydgoto[ssl_expr_yym];
 
600
#if YYDEBUG
 
601
    if (ssl_expr_yydebug)
 
602
        printf("%sdebug: after reduction, shifting from state %d \
 
603
to state %d\n", YYPREFIX, *ssl_expr_yyssp, ssl_expr_yystate);
 
604
#endif
 
605
    if (ssl_expr_yyssp >= ssl_expr_yysslim && ssl_expr_yygrowstack())
 
606
    {
 
607
        goto ssl_expr_yyoverflow;
 
608
    }
 
609
    *++ssl_expr_yyssp = ssl_expr_yystate;
 
610
    *++ssl_expr_yyvsp = ssl_expr_yyval;
 
611
    goto ssl_expr_yyloop;
 
612
ssl_expr_yyoverflow:
 
613
    ssl_expr_yyerror("yacc stack overflow");
 
614
ssl_expr_yyabort:
 
615
    return (1);
 
616
ssl_expr_yyaccept:
 
617
    return (0);
 
618
}