#define yy_create_buffer ssl_expr_yy_create_buffer

#define yy_delete_buffer ssl_expr_yy_delete_buffer

#define yy_scan_buffer ssl_expr_yy_scan_buffer

#define yy_scan_string ssl_expr_yy_scan_string

#define yy_scan_bytes ssl_expr_yy_scan_bytes

#define yy_flex_debug ssl_expr_yy_flex_debug

#define yy_init_buffer ssl_expr_yy_init_buffer

#define yy_flush_buffer ssl_expr_yy_flush_buffer

#define yy_load_buffer_state ssl_expr_yy_load_buffer_state

#define yy_switch_to_buffer ssl_expr_yy_switch_to_buffer

#define yyin ssl_expr_yyin

#define yyleng ssl_expr_yyleng

#define yylex ssl_expr_yylex

#define yyout ssl_expr_yyout

#define yyrestart ssl_expr_yyrestart

#define yytext ssl_expr_yytext

/* A lexical scanner generated by flex */

/* Scanner skeleton version:

* $Header: /home/striker/cvs2svn/dumps/httpd-2.0/../../httpd-2.0/modules/ssl/ssl_expr_scan.c,v 1.19 2004/02/28 18:06:35 jorton Exp $

*/

#define FLEX_SCANNER

#define YY_FLEX_MAJOR_VERSION 2

#define YY_FLEX_MINOR_VERSION 5

#include <stdio.h>

/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */

#ifdef c_plusplus

#ifndef __cplusplus

#define __cplusplus

#endif

#endif

#ifdef __cplusplus

#include <stdlib.h>

#include <unistd.h>

/* Use prototypes in function declarations. */

#define YY_USE_PROTOS

/* The "const" storage-class-modifier is valid. */

#define YY_USE_CONST

#else /* ! __cplusplus */

#if __STDC__

#define YY_USE_PROTOS

#define YY_USE_CONST

#endif /* __STDC__ */

#endif /* ! __cplusplus */

#ifdef __TURBOC__

#pragma warn -rch

#pragma warn -use

#include <io.h>

#include <stdlib.h>

#define YY_USE_CONST

#define YY_USE_PROTOS

#endif

#ifdef YY_USE_CONST

#define yyconst const

#else

#define yyconst

#endif

#ifdef YY_USE_PROTOS

#define YY_PROTO(proto) proto

#else

#define YY_PROTO(proto) ()

#endif

/* Returned upon end-of-file. */

#define YY_NULL 0

/* Promotes a possibly negative, possibly signed char to an unsigned

* integer for use as an array index. If the signed char is negative,

* we want to instead treat it as an 8-bit unsigned char, hence the

* double cast.

*/

#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)

/* Enter a start condition. This macro really ought to take a parameter,

* but we do it the disgusting crufty way forced on us by the ()-less

* definition of BEGIN.

*/

#define BEGIN yy_start = 1 + 2 *

/* Translate the current start state into a value that can be later handed

* to BEGIN to return to the state. The YYSTATE alias is for lex

* compatibility.

*/

#define YY_START ((yy_start - 1) / 2)

#define YYSTATE YY_START

/* Action number for EOF rule of a given start state. */

#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

/* Special action meaning "start processing a new file". */

#define YY_NEW_FILE yyrestart( yyin )

#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */

#define YY_BUF_SIZE 16384

typedef struct yy_buffer_state *YY_BUFFER_STATE;

extern int yyleng;

extern FILE *yyin, *yyout;

#define EOB_ACT_CONTINUE_SCAN 0

#define EOB_ACT_END_OF_FILE 1

#define EOB_ACT_LAST_MATCH 2

/* The funky do-while in the following #define is used to turn the definition

* int a single C statement (which needs a semi-colon terminator). This

* avoids problems with code like:

*

* if ( condition_holds )

* yyless( 5 );

* else

* do_something_else();

*

* Prior to using the do-while the compiler would get upset at the

* "else" because it interpreted the "if" statement as being all

* done when it reached the ';' after the yyless() call.

*/

/* Return all but the first 'n' matched characters back to the input stream. */

#define yyless(n) \

do \

{ \

/* Undo effects of setting up yytext. */ \

*yy_cp = yy_hold_char; \

YY_RESTORE_YY_MORE_OFFSET \

yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \

YY_DO_BEFORE_ACTION; /* set up yytext again */ \

} \

while ( 0 )

#define unput(c) yyunput( c, yytext_ptr )

/* The following is because we cannot portably get our hands on size_t

* (without autoconf's help, which isn't available because we want

* flex-generated scanners to compile on their own).

*/

typedef unsigned int yy_size_t;

struct yy_buffer_state

{

FILE *yy_input_file;

char *yy_ch_buf; /* input buffer */

char *yy_buf_pos; /* current position in input buffer */

/* Size of input buffer in bytes, not including room for EOB

* characters.

*/

yy_size_t yy_buf_size;

/* Number of characters read into yy_ch_buf, not including EOB

* characters.

*/

int yy_n_chars;

/* Whether we "own" the buffer - i.e., we know we created it,

* and can realloc() it to grow it, and should free() it to

* delete it.

*/

int yy_is_our_buffer;

/* Whether this is an "interactive" input source; if so, and

* if we're using stdio for input, then we want to use getc()

* instead of fread(), to make sure we stop fetching input after

* each newline.

*/

int yy_is_interactive;

/* Whether we're considered to be at the beginning of a line.

* If so, '^' rules will be active on the next match, otherwise

* not.

*/

int yy_at_bol;

/* Whether to try to fill the input buffer when we reach the

* end of it.

*/

int yy_fill_buffer;

int yy_buffer_status;

#define YY_BUFFER_NEW 0

#define YY_BUFFER_NORMAL 1

/* When an EOF's been seen but there's still some text to process

* then we mark the buffer as YY_EOF_PENDING, to indicate that we

* shouldn't try reading from the input source any more. We might

* still have a bunch of tokens to match, though, because of

* possible backing-up.

*

* When we actually see the EOF, we change the status to "new"

* (via yyrestart()), so that the user can continue scanning by

* just pointing yyin at a new input file.

*/

#define YY_BUFFER_EOF_PENDING 2

};

static YY_BUFFER_STATE yy_current_buffer = 0;

/* We provide macros for accessing buffer states in case in the

* future we want to put the buffer states in a more general

* "scanner state".

*/

#define YY_CURRENT_BUFFER yy_current_buffer

/* yy_hold_char holds the character lost when yytext is formed. */

static char yy_hold_char;

static int yy_n_chars; /* number of characters read into yy_ch_buf */

int yyleng;

/* Points to current character in buffer. */

static char *yy_c_buf_p = (char *) 0;

static int yy_init = 1; /* whether we need to initialize */

static int yy_start = 0; /* start state number */

/* Flag which is used to allow yywrap()'s to do buffer switches

* instead of setting up a fresh yyin. A bit of a hack ...

*/

static int yy_did_buffer_switch_on_eof;

void yyrestart YY_PROTO(( FILE *input_file ));

void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));

void yy_load_buffer_state YY_PROTO(( void ));

YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));

void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));

void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));

void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));

#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )

YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));

YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));

YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));

static void *yy_flex_alloc YY_PROTO(( yy_size_t ));

static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));

static void yy_flex_free YY_PROTO(( void * ));

#define yy_new_buffer yy_create_buffer

#define yy_set_interactive(is_interactive) \

{ \

if ( ! yy_current_buffer ) \

yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \

yy_current_buffer->yy_is_interactive = is_interactive; \

}

#define yy_set_bol(at_bol) \

{ \

if ( ! yy_current_buffer ) \

yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \

yy_current_buffer->yy_at_bol = at_bol; \

}

#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)

#define yywrap() 1

#define YY_SKIP_YYWRAP

typedef unsigned char YY_CHAR;

FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;

typedef int yy_state_type;

extern char *yytext;

#define yytext_ptr yytext

static yy_state_type yy_get_previous_state YY_PROTO(( void ));

static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));

static int yy_get_next_buffer YY_PROTO(( void ));

static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));

/* Done after the current pattern has been matched and before the

* corresponding action - sets up yytext.

*/

#define YY_DO_BEFORE_ACTION \

yytext_ptr = yy_bp; \

yyleng = (int) (yy_cp - yy_bp); \

yy_hold_char = *yy_cp; \

*yy_cp = '\0'; \

yy_c_buf_p = yy_cp;

#define YY_NUM_RULES 46

#define YY_END_OF_BUFFER 47

static yyconst short int yy_accept[86] =

{ 0,

0, 0, 0, 0, 0, 0, 0, 0, 47, 45,

1, 38, 2, 45, 43, 24, 45, 28, 44, 44,

44, 44, 44, 44, 44, 44, 44, 44, 44, 45,

13, 4, 3, 14, 16, 18, 17, 1, 22, 32,

34, 43, 26, 20, 31, 30, 44, 44, 19, 44,

44, 29, 27, 39, 25, 23, 15, 15, 21, 44,

35, 44, 36, 13, 12, 5, 6, 10, 11, 7,

8, 9, 33, 44, 44, 37, 44, 5, 6, 44,

40, 41, 5, 42, 0

} ;

static yyconst int yy_ec[256] =

{ 0,

1, 1, 1, 1, 1, 1, 1, 1, 2, 3,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 2, 4, 5, 1, 1, 1, 6, 1, 1,

1, 1, 1, 1, 7, 1, 1, 8, 8, 8,

8, 8, 8, 8, 8, 9, 9, 7, 1, 10,

11, 12, 1, 1, 13, 13, 13, 13, 13, 13,

13, 13, 13, 13, 13, 13, 13, 13, 13, 13,

13, 13, 13, 13, 13, 13, 13, 13, 13, 13,

1, 14, 1, 1, 7, 1, 15, 16, 13, 17,

18, 19, 20, 13, 21, 13, 13, 22, 23, 24,

25, 13, 26, 27, 28, 29, 30, 13, 13, 13,

13, 13, 1, 31, 1, 32, 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, 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

} ;

static yyconst int yy_meta[33] =

{ 0,

1, 1, 2, 1, 3, 1, 4, 4, 4, 1,

1, 1, 4, 3, 4, 4, 4, 4, 4, 4,

4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

1, 1

} ;

static yyconst short int yy_base[93] =

{ 0,

0, 0, 30, 31, 0, 0, 82, 81, 101, 142,

35, 28, 142, 94, 32, 88, 31, 87, 0, 69,

66, 28, 28, 67, 29, 63, 30, 63, 62, 57,

0, 142, 142, 88, 142, 142, 142, 48, 142, 142,

142, 44, 142, 142, 142, 142, 0, 70, 0, 64,

63, 0, 0, 0, 0, 0, 142, 0, 0, 55,

0, 46, 142, 0, 142, 53, 62, 142, 142, 142,

142, 142, 0, 44, 48, 0, 41, 70, 72, 38,

0, 0, 74, 0, 142, 117, 121, 125, 50, 129,

133, 137

} ;

static yyconst short int yy_def[93] =

{ 0,

85, 1, 86, 86, 87, 87, 88, 88, 85, 85,

85, 85, 85, 85, 85, 85, 85, 85, 89, 89,

89, 89, 89, 89, 89, 90, 89, 89, 89, 85,

91, 85, 85, 92, 85, 85, 85, 85, 85, 85,

85, 85, 85, 85, 85, 85, 89, 89, 89, 89,

89, 89, 89, 89, 89, 89, 85, 89, 89, 89,

89, 89, 85, 91, 85, 85, 85, 85, 85, 85,

85, 85, 89, 89, 89, 89, 89, 85, 85, 89,

89, 89, 85, 89, 0, 85, 85, 85, 85, 85,

85, 85

} ;

static yyconst short int yy_nxt[175] =

{ 0,

10, 11, 11, 12, 13, 14, 10, 15, 15, 16,

17, 18, 19, 10, 20, 19, 19, 21, 22, 23,

24, 25, 26, 27, 28, 19, 19, 19, 29, 19,

30, 10, 32, 32, 33, 33, 38, 38, 39, 42,

42, 44, 50, 34, 34, 52, 55, 59, 51, 38,

38, 42, 42, 47, 60, 84, 53, 56, 82, 40,

78, 79, 45, 57, 57, 81, 57, 57, 57, 79,

79, 80, 57, 57, 57, 77, 57, 83, 79, 79,

79, 79, 79, 76, 75, 74, 73, 63, 62, 61,

54, 49, 48, 57, 57, 66, 67, 46, 43, 41,

85, 37, 37, 68, 85, 85, 69, 85, 85, 85,

85, 70, 85, 85, 71, 85, 72, 31, 31, 31,

31, 35, 35, 35, 35, 36, 36, 36, 36, 58,

85, 58, 58, 64, 85, 85, 64, 65, 65, 65,

65, 9, 85, 85, 85, 85, 85, 85, 85, 85,

85, 85, 85, 85, 85, 85, 85, 85, 85, 85,

85, 85, 85, 85, 85, 85, 85, 85, 85, 85,

85, 85, 85, 85

} ;

static yyconst short int yy_chk[175] =

{ 0,

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, 3, 4, 3, 4, 11, 11, 12, 15,

15, 17, 22, 3, 4, 23, 25, 27, 22, 38,

38, 42, 42, 89, 27, 80, 23, 25, 77, 12,

66, 66, 17, 26, 26, 75, 26, 26, 26, 67,

67, 74, 26, 26, 26, 62, 26, 78, 78, 79,

79, 83, 83, 60, 51, 50, 48, 30, 29, 28,

24, 21, 20, 26, 26, 34, 34, 18, 16, 14,

9, 8, 7, 34, 0, 0, 34, 0, 0, 0,

0, 34, 0, 0, 34, 0, 34, 86, 86, 86,

86, 87, 87, 87, 87, 88, 88, 88, 88, 90,

0, 90, 90, 91, 0, 0, 91, 92, 92, 92,

92, 85, 85, 85, 85, 85, 85, 85, 85, 85,

85, 85, 85, 85, 85, 85, 85, 85, 85, 85,

85, 85, 85, 85, 85, 85, 85, 85, 85, 85,

85, 85, 85, 85

} ;

static yy_state_type yy_last_accepting_state;

static char *yy_last_accepting_cpos;

/* The intent behind this definition is that it'll catch

* any uses of REJECT which flex missed.

*/

#define REJECT reject_used_but_not_detected

#define yymore() yymore_used_but_not_detected

#define YY_MORE_ADJ 0

#define YY_RESTORE_YY_MORE_OFFSET

char *yytext;

#line 1 "ssl_expr_scan.l"

#define INITIAL 0

/* Copyright 2001-2005 The Apache Software Foundation or its licensors, as

* applicable.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

/* _ _

* _ __ ___ ___ __| | ___ ___| |

* | '_ ` _ \ / _ \ / _` | / __/ __| |

* | | | | | | (_) | (_| | \__ \__ \ | mod_ssl - Apache Interface to OpenSSL

* |_| |_| |_|\___/ \__,_|___|___/___/_| http://www.modssl.org/

* |_____|

* ssl_expr_scan.l

* Expression Scanner

*/

/* ``Killing for peace is

like fucking for virginity.''

-- Unknown */

/* _________________________________________________________________

**

** Expression Scanner

** _________________________________________________________________

*/

#line 38 "ssl_expr_scan.l"

#include "ssl_private.h"

#include "ssl_expr_parse.h"

#define YY_NO_UNPUT 1

int yyinput(char *buf, int max_size);

#undef YY_INPUT

#define YY_INPUT(buf,result,max_size) \

(result = yyinput(buf, max_size))

#define MAX_STR_LEN 2048

/* %option stack */

#define YY_NEVER_INTERACTIVE 1

#define str 1

#define regex 2

#define regex_flags 3

#line 535 "lex.ssl_expr_yy.c"

/* Macros after this point can all be overridden by user definitions in

* section 1.

*/

#ifndef YY_SKIP_YYWRAP

#ifdef __cplusplus

extern "C" int yywrap YY_PROTO(( void ));

#else

extern int yywrap YY_PROTO(( void ));

#endif

#endif

#ifndef YY_NO_UNPUT

static void yyunput YY_PROTO(( int c, char *buf_ptr ));

#endif

#ifndef yytext_ptr

static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));

#endif

#ifdef YY_NEED_STRLEN

static int yy_flex_strlen YY_PROTO(( yyconst char * ));

#endif

#ifndef YY_NO_INPUT

#ifdef __cplusplus

static int yyinput YY_PROTO(( void ));

#else

static int input YY_PROTO(( void ));

#endif

#endif

#if YY_STACK_USED

static int yy_start_stack_ptr = 0;

static int yy_start_stack_depth = 0;

static int *yy_start_stack = 0;

#ifndef YY_NO_PUSH_STATE

static void yy_push_state YY_PROTO(( int new_state ));

#endif

#ifndef YY_NO_POP_STATE

static void yy_pop_state YY_PROTO(( void ));

#endif

#ifndef YY_NO_TOP_STATE

static int yy_top_state YY_PROTO(( void ));

#endif

#else

#define YY_NO_PUSH_STATE 1

#define YY_NO_POP_STATE 1

#define YY_NO_TOP_STATE 1

#endif

#ifdef YY_MALLOC_DECL

YY_MALLOC_DECL

#else

#if __STDC__

#ifndef __cplusplus

#include <stdlib.h>

#endif

#else

/* Just try to get by without declaring the routines. This will fail

* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)

* or sizeof(void*) != sizeof(int).

*/

#endif

#endif

/* Amount of stuff to slurp up with each read. */

#ifndef YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE 8192

#endif

/* Copy whatever the last rule matched to the standard output. */

#ifndef ECHO

/* This used to be an fputs(), but since the string might contain NUL's,

* we now use fwrite().

*/

#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )

#endif

/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,

* is returned in "result".

*/

#ifndef YY_INPUT

#define YY_INPUT(buf,result,max_size) \

if ( yy_current_buffer->yy_is_interactive ) \

{ \

int c = '*', n; \

for ( n = 0; n < max_size && \

(c = getc( yyin )) != EOF && c != '\n'; ++n ) \

buf[n] = (char) c; \

if ( c == '\n' ) \

buf[n++] = (char) c; \

if ( c == EOF && ferror( yyin ) ) \

YY_FATAL_ERROR( "input in flex scanner failed" ); \

result = n; \

} \

else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \

&& ferror( yyin ) ) \

YY_FATAL_ERROR( "input in flex scanner failed" );

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -

* we don't want an extra ';' after the "return" because that will cause

* some compilers to complain about unreachable statements.

*/

#ifndef yyterminate

#define yyterminate() return YY_NULL

#endif

/* Number of entries by which start-condition stack grows. */

#ifndef YY_START_STACK_INCR

#define YY_START_STACK_INCR 25

#endif

/* Report a fatal error. */

#ifndef YY_FATAL_ERROR

#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )

#endif

/* Default declaration of generated scanner - a define so the user can

* easily add parameters.

*/

#ifndef YY_DECL

#define YY_DECL int yylex YY_PROTO(( void ))

#endif

/* Code executed at the beginning of each rule, after yytext and yyleng

* have been set up.

*/

#ifndef YY_USER_ACTION

#define YY_USER_ACTION

#endif

/* Code executed at the end of each rule. */

#ifndef YY_BREAK

#define YY_BREAK break;

#endif

#define YY_RULE_SETUP \

YY_USER_ACTION

YY_DECL

{

register yy_state_type yy_current_state;

register char *yy_cp, *yy_bp;

register int yy_act;

#line 91 "ssl_expr_scan.l"

char caStr[MAX_STR_LEN];

char *cpStr = NULL;

char caRegex[MAX_STR_LEN];

char *cpRegex = NULL;

char cRegexDel = NUL;

/*

* Whitespaces

*/

#line 698 "lex.ssl_expr_yy.c"

if ( yy_init )

{

yy_init = 0;

#ifdef YY_USER_INIT

YY_USER_INIT;

#endif

if ( ! yy_start )

yy_start = 1; /* first start state */

if ( ! yyin )

yyin = stdin;

if ( ! yyout )

yyout = stdout;

if ( ! yy_current_buffer )

yy_current_buffer =

yy_create_buffer( yyin, YY_BUF_SIZE );

yy_load_buffer_state();

}

while ( 1 ) /* loops until end-of-file is reached */

{

yy_cp = yy_c_buf_p;

/* Support of yytext. */

*yy_cp = yy_hold_char;

/* yy_bp points to the position in yy_ch_buf of the start of

* the current run.

*/

yy_bp = yy_cp;

yy_current_state = yy_start;

yy_match:

do

{

register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];

if ( yy_accept[yy_current_state] )

{

yy_last_accepting_state = yy_current_state;

yy_last_accepting_cpos = yy_cp;

}

while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )

{

yy_current_state = (int) yy_def[yy_current_state];

if ( yy_current_state >= 86 )

yy_c = yy_meta[(unsigned int) yy_c];

}

yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];

++yy_cp;

}

while ( yy_current_state != 85 );

yy_cp = yy_last_accepting_cpos;

yy_current_state = yy_last_accepting_state;

yy_find_action:

yy_act = yy_accept[yy_current_state];

YY_DO_BEFORE_ACTION;

do_action: /* This label is used only to access EOF actions. */

switch ( yy_act )

{ /* beginning of action switch */

case 0: /* must back up */

/* undo the effects of YY_DO_BEFORE_ACTION */

*yy_cp = yy_hold_char;

yy_cp = yy_last_accepting_cpos;

yy_current_state = yy_last_accepting_state;

goto yy_find_action;

case 1:

YY_RULE_SETUP

#line 102 "ssl_expr_scan.l"

{

/* NOP */

}

YY_BREAK

/*

* C-style strings ("...")

*/

case 2:

YY_RULE_SETUP

#line 109 "ssl_expr_scan.l"

{

cpStr = caStr;

BEGIN(str);

}

YY_BREAK

case 3:

YY_RULE_SETUP

#line 113 "ssl_expr_scan.l"

{

BEGIN(INITIAL);

*cpStr = NUL;

yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caStr);

return T_STRING;

}

YY_BREAK

case 4:

YY_RULE_SETUP

#line 119 "ssl_expr_scan.l"

{

yyerror("Unterminated string");

}

YY_BREAK

case 5:

YY_RULE_SETUP

#line 122 "ssl_expr_scan.l"

{

int result;

(void)sscanf(yytext+1, "%o", &result);

if (result > 0xff)

yyerror("Escape sequence out of bound");

else

*cpStr++ = result;

}

YY_BREAK

case 6:

YY_RULE_SETUP

#line 131 "ssl_expr_scan.l"

{

yyerror("Bad escape sequence");

}

YY_BREAK

case 7:

YY_RULE_SETUP

#line 134 "ssl_expr_scan.l"

{ *cpStr++ = '\n'; }

YY_BREAK

case 8:

YY_RULE_SETUP

#line 135 "ssl_expr_scan.l"

{ *cpStr++ = '\r'; }

YY_BREAK

case 9:

YY_RULE_SETUP

#line 136 "ssl_expr_scan.l"

{ *cpStr++ = '\t'; }

YY_BREAK

case 10:

YY_RULE_SETUP

#line 137 "ssl_expr_scan.l"

{ *cpStr++ = '\b'; }

YY_BREAK

case 11:

YY_RULE_SETUP

#line 138 "ssl_expr_scan.l"

{ *cpStr++ = '\f'; }

YY_BREAK

case 12:

YY_RULE_SETUP

#line 139 "ssl_expr_scan.l"

{

*cpStr++ = yytext[1];

}

YY_BREAK

case 13:

YY_RULE_SETUP

#line 142 "ssl_expr_scan.l"

{

char *cp = yytext;

while (*cp != NUL)

*cpStr++ = *cp++;

}

YY_BREAK

case 14:

YY_RULE_SETUP

#line 147 "ssl_expr_scan.l"

{

*cpStr++ = yytext[1];

}

YY_BREAK

/*

* Regular Expression

*/

case 15:

YY_RULE_SETUP

#line 154 "ssl_expr_scan.l"

{

cRegexDel = yytext[1];

cpRegex = caRegex;

BEGIN(regex);

}

YY_BREAK

case 16:

YY_RULE_SETUP

#line 159 "ssl_expr_scan.l"

{

if (yytext[0] == cRegexDel) {

*cpRegex = NUL;

BEGIN(regex_flags);

}

else {

*cpRegex++ = yytext[0];

}

}

YY_BREAK

case 17:

YY_RULE_SETUP

#line 168 "ssl_expr_scan.l"

{

yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caRegex);

BEGIN(INITIAL);

return T_REGEX_I;

}

YY_BREAK

case 18:

YY_RULE_SETUP

#line 173 "ssl_expr_scan.l"

{

yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caRegex);

yyless(0);

BEGIN(INITIAL);

return T_REGEX;

}

YY_BREAK

case YY_STATE_EOF(regex_flags):

#line 179 "ssl_expr_scan.l"

{

yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caRegex);

BEGIN(INITIAL);

return T_REGEX;

}

YY_BREAK

/*

* Operators

*/

case 19:

YY_RULE_SETUP

#line 188 "ssl_expr_scan.l"

{ return T_OP_EQ; }

YY_BREAK

case 20:

YY_RULE_SETUP

#line 189 "ssl_expr_scan.l"

{ return T_OP_EQ; }

YY_BREAK

case 21:

YY_RULE_SETUP

#line 190 "ssl_expr_scan.l"

{ return T_OP_NE; }

YY_BREAK

case 22:

YY_RULE_SETUP

#line 191 "ssl_expr_scan.l"

{ return T_OP_NE; }

YY_BREAK

case 23:

YY_RULE_SETUP

#line 192 "ssl_expr_scan.l"

{ return T_OP_LT; }

YY_BREAK

case 24:

YY_RULE_SETUP

#line 193 "ssl_expr_scan.l"

{ return T_OP_LT; }

YY_BREAK

case 25:

YY_RULE_SETUP

#line 194 "ssl_expr_scan.l"

{ return T_OP_LE; }

YY_BREAK

case 26:

YY_RULE_SETUP

#line 195 "ssl_expr_scan.l"

{ return T_OP_LE; }

YY_BREAK

case 27:

YY_RULE_SETUP

#line 196 "ssl_expr_scan.l"

{ return T_OP_GT; }

YY_BREAK

case 28:

YY_RULE_SETUP

#line 197 "ssl_expr_scan.l"

{ return T_OP_GT; }

YY_BREAK

case 29:

YY_RULE_SETUP

#line 198 "ssl_expr_scan.l"

{ return T_OP_GE; }

YY_BREAK

case 30:

YY_RULE_SETUP

#line 199 "ssl_expr_scan.l"

{ return T_OP_GE; }

YY_BREAK

case 31:

YY_RULE_SETUP

#line 200 "ssl_expr_scan.l"

{ return T_OP_REG; }

YY_BREAK

case 32:

YY_RULE_SETUP

#line 201 "ssl_expr_scan.l"

{ return T_OP_NRE; }

YY_BREAK

case 33:

YY_RULE_SETUP

#line 202 "ssl_expr_scan.l"

{ return T_OP_AND; }

YY_BREAK

case 34:

YY_RULE_SETUP

#line 203 "ssl_expr_scan.l"

{ return T_OP_AND; }

YY_BREAK

case 35:

YY_RULE_SETUP

#line 204 "ssl_expr_scan.l"

{ return T_OP_OR; }

YY_BREAK

case 36:

YY_RULE_SETUP

#line 205 "ssl_expr_scan.l"

{ return T_OP_OR; }

YY_BREAK

case 37:

YY_RULE_SETUP

#line 206 "ssl_expr_scan.l"

{ return T_OP_NOT; }

YY_BREAK

case 38:

YY_RULE_SETUP

#line 207 "ssl_expr_scan.l"