rubbos/app/httpd-2.0.64/modules/ssl/ssl_expr_scan.c

   1 #define yy_create_buffer ssl_expr_yy_create_buffer
   2 #define yy_delete_buffer ssl_expr_yy_delete_buffer
   3 #define yy_scan_buffer ssl_expr_yy_scan_buffer
   4 #define yy_scan_string ssl_expr_yy_scan_string
   5 #define yy_scan_bytes ssl_expr_yy_scan_bytes
   6 #define yy_flex_debug ssl_expr_yy_flex_debug
   7 #define yy_init_buffer ssl_expr_yy_init_buffer
   8 #define yy_flush_buffer ssl_expr_yy_flush_buffer
   9 #define yy_load_buffer_state ssl_expr_yy_load_buffer_state
  10 #define yy_switch_to_buffer ssl_expr_yy_switch_to_buffer
  11 #define yyin ssl_expr_yyin
  12 #define yyleng ssl_expr_yyleng
  13 #define yylex ssl_expr_yylex
  14 #define yyout ssl_expr_yyout
  15 #define yyrestart ssl_expr_yyrestart
  16 #define yytext ssl_expr_yytext
  17
  18 /* A lexical scanner generated by flex */
  19
  20 /* Scanner skeleton version:
  21  * $Header: /home/striker/cvs2svn/dumps/httpd-2.0/../../httpd-2.0/modules/ssl/ssl_expr_scan.c,v 1.12.2.4 2004/02/09 20:53:20 nd Exp $
  22  */
  23
  24 #define FLEX_SCANNER
  25 #define YY_FLEX_MAJOR_VERSION 2
  26 #define YY_FLEX_MINOR_VERSION 5
  27
  28 #include <stdio.h>
  29
  30
  31 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  32 #ifdef c_plusplus
  33 #ifndef __cplusplus
  34 #define __cplusplus
  35 #endif
  36 #endif
  37
  38
  39 #ifdef __cplusplus
  40
  41 #include <stdlib.h>
  42 #include <unistd.h>
  43
  44 /* Use prototypes in function declarations. */
  45 #define YY_USE_PROTOS
  46
  47 /* The "const" storage-class-modifier is valid. */
  48 #define YY_USE_CONST
  49
  50 #else   /* ! __cplusplus */
  51
  52 #if __STDC__
  53
  54 #define YY_USE_PROTOS
  55 #define YY_USE_CONST
  56
  57 #endif  /* __STDC__ */
  58 #endif  /* ! __cplusplus */
  59
  60 #ifdef __TURBOC__
  61 #pragma warn -rch
  62 #pragma warn -use
  63 #include <io.h>
  64 #include <stdlib.h>
  65 #define YY_USE_CONST
  66 #define YY_USE_PROTOS
  67 #endif
  68
  69 #ifdef YY_USE_CONST
  70 #define yyconst const
  71 #else
  72 #define yyconst
  73 #endif
  74
  75
  76 #ifdef YY_USE_PROTOS
  77 #define YY_PROTO(proto) proto
  78 #else
  79 #define YY_PROTO(proto) ()
  80 #endif
  81
  82 /* Returned upon end-of-file. */
  83 #define YY_NULL 0
  84
  85 /* Promotes a possibly negative, possibly signed char to an unsigned
  86  * integer for use as an array index.  If the signed char is negative,
  87  * we want to instead treat it as an 8-bit unsigned char, hence the
  88  * double cast.
  89  */
  90 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  91
  92 /* Enter a start condition.  This macro really ought to take a parameter,
  93  * but we do it the disgusting crufty way forced on us by the ()-less
  94  * definition of BEGIN.
  95  */
  96 #define BEGIN yy_start = 1 + 2 *
  97
  98 /* Translate the current start state into a value that can be later handed
  99  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 100  * compatibility.
 101  */
 102 #define YY_START ((yy_start - 1) / 2)
 103 #define YYSTATE YY_START
 104
 105 /* Action number for EOF rule of a given start state. */
 106 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 107
 108 /* Special action meaning "start processing a new file". */
 109 #define YY_NEW_FILE yyrestart( yyin )
 110
 111 #define YY_END_OF_BUFFER_CHAR 0
 112
 113 /* Size of default input buffer. */
 114 #define YY_BUF_SIZE 16384
 115
 116 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 117
 118 extern int yyleng;
 119 extern FILE *yyin, *yyout;
 120
 121 #define EOB_ACT_CONTINUE_SCAN 0
 122 #define EOB_ACT_END_OF_FILE 1
 123 #define EOB_ACT_LAST_MATCH 2
 124
 125 /* The funky do-while in the following #define is used to turn the definition
 126  * int a single C statement (which needs a semi-colon terminator).  This
 127  * avoids problems with code like:
 128  *
 129  *      if ( condition_holds )
 130  *              yyless( 5 );
 131  *      else
 132  *              do_something_else();
 133  *
 134  * Prior to using the do-while the compiler would get upset at the
 135  * "else" because it interpreted the "if" statement as being all
 136  * done when it reached the ';' after the yyless() call.
 137  */
 138
 139 /* Return all but the first 'n' matched characters back to the input stream. */
 140
 141 #define yyless(n) \
 142         do \
 143                 { \
 144                 /* Undo effects of setting up yytext. */ \
 145                 *yy_cp = yy_hold_char; \
 146                 YY_RESTORE_YY_MORE_OFFSET \
 147                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 148                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 149                 } \
 150         while ( 0 )
 151
 152 #define unput(c) yyunput( c, yytext_ptr )
 153
 154 /* The following is because we cannot portably get our hands on size_t
 155  * (without autoconf's help, which isn't available because we want
 156  * flex-generated scanners to compile on their own).
 157  */
 158 typedef unsigned int yy_size_t;
 159
 160
 161 struct yy_buffer_state
 162         {
 163         FILE *yy_input_file;
 164
 165         char *yy_ch_buf;                /* input buffer */
 166         char *yy_buf_pos;               /* current position in input buffer */
 167
 168         /* Size of input buffer in bytes, not including room for EOB
 169          * characters.
 170          */
 171         yy_size_t yy_buf_size;
 172
 173         /* Number of characters read into yy_ch_buf, not including EOB
 174          * characters.
 175          */
 176         int yy_n_chars;
 177
 178         /* Whether we "own" the buffer - i.e., we know we created it,
 179          * and can realloc() it to grow it, and should free() it to
 180          * delete it.
 181          */
 182         int yy_is_our_buffer;
 183
 184         /* Whether this is an "interactive" input source; if so, and
 185          * if we're using stdio for input, then we want to use getc()
 186          * instead of fread(), to make sure we stop fetching input after
 187          * each newline.
 188          */
 189         int yy_is_interactive;
 190
 191         /* Whether we're considered to be at the beginning of a line.
 192          * If so, '^' rules will be active on the next match, otherwise
 193          * not.
 194          */
 195         int yy_at_bol;
 196
 197         /* Whether to try to fill the input buffer when we reach the
 198          * end of it.
 199          */
 200         int yy_fill_buffer;
 201
 202         int yy_buffer_status;
 203 #define YY_BUFFER_NEW 0
 204 #define YY_BUFFER_NORMAL 1
 205         /* When an EOF's been seen but there's still some text to process
 206          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 207          * shouldn't try reading from the input source any more.  We might
 208          * still have a bunch of tokens to match, though, because of
 209          * possible backing-up.
 210          *
 211          * When we actually see the EOF, we change the status to "new"
 212          * (via yyrestart()), so that the user can continue scanning by
 213          * just pointing yyin at a new input file.
 214          */
 215 #define YY_BUFFER_EOF_PENDING 2
 216         };
 217
 218 static YY_BUFFER_STATE yy_current_buffer = 0;
 219
 220 /* We provide macros for accessing buffer states in case in the
 221  * future we want to put the buffer states in a more general
 222  * "scanner state".
 223  */
 224 #define YY_CURRENT_BUFFER yy_current_buffer
 225
 226
 227 /* yy_hold_char holds the character lost when yytext is formed. */
 228 static char yy_hold_char;
 229
 230 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 231
 232
 233 int yyleng;
 234
 235 /* Points to current character in buffer. */
 236 static char *yy_c_buf_p = (char *) 0;
 237 static int yy_init = 1;         /* whether we need to initialize */
 238 static int yy_start = 0;        /* start state number */
 239
 240 /* Flag which is used to allow yywrap()'s to do buffer switches
 241  * instead of setting up a fresh yyin.  A bit of a hack ...
 242  */
 243 static int yy_did_buffer_switch_on_eof;
 244
 245 void yyrestart YY_PROTO(( FILE *input_file ));
 246
 247 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 248 void yy_load_buffer_state YY_PROTO(( void ));
 249 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 250 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 251 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 252 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 253 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 254
 255 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 256 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 257 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 258
 259 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 260 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 261 static void yy_flex_free YY_PROTO(( void * ));
 262
 263 #define yy_new_buffer yy_create_buffer
 264
 265 #define yy_set_interactive(is_interactive) \
 266         { \
 267         if ( ! yy_current_buffer ) \
 268                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 269         yy_current_buffer->yy_is_interactive = is_interactive; \
 270         }
 271
 272 #define yy_set_bol(at_bol) \
 273         { \
 274         if ( ! yy_current_buffer ) \
 275                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 276         yy_current_buffer->yy_at_bol = at_bol; \
 277         }
 278
 279 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 280
 281
 282 #define yywrap() 1
 283 #define YY_SKIP_YYWRAP
 284 typedef unsigned char YY_CHAR;
 285 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 286 typedef int yy_state_type;
 287 extern char *yytext;
 288 #define yytext_ptr yytext
 289
 290 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 291 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 292 static int yy_get_next_buffer YY_PROTO(( void ));
 293 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 294
 295 /* Done after the current pattern has been matched and before the
 296  * corresponding action - sets up yytext.
 297  */
 298 #define YY_DO_BEFORE_ACTION \
 299         yytext_ptr = yy_bp; \
 300         yyleng = (int) (yy_cp - yy_bp); \
 301         yy_hold_char = *yy_cp; \
 302         *yy_cp = '\0'; \
 303         yy_c_buf_p = yy_cp;
 304
 305 #define YY_NUM_RULES 46
 306 #define YY_END_OF_BUFFER 47
 307 static yyconst short int yy_accept[86] =
 308     {   0,
 309         0,    0,    0,    0,    0,    0,    0,    0,   47,   45,
 310         1,   38,    2,   45,   43,   24,   45,   28,   44,   44,
 311        44,   44,   44,   44,   44,   44,   44,   44,   44,   45,
 312        13,    4,    3,   14,   16,   18,   17,    1,   22,   32,
 313        34,   43,   26,   20,   31,   30,   44,   44,   19,   44,
 314        44,   29,   27,   39,   25,   23,   15,   15,   21,   44,
 315        35,   44,   36,   13,   12,    5,    6,   10,   11,    7,
 316         8,    9,   33,   44,   44,   37,   44,    5,    6,   44,
 317        40,   41,    5,   42,    0
 318     } ;
 319
 320 static yyconst int yy_ec[256] =
 321     {   0,
 322         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 323         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 325         1,    2,    4,    5,    1,    1,    1,    6,    1,    1,
 326         1,    1,    1,    1,    7,    1,    1,    8,    8,    8,
 327         8,    8,    8,    8,    8,    9,    9,    7,    1,   10,
 328        11,   12,    1,    1,   13,   13,   13,   13,   13,   13,
 329        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
 330        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
 331         1,   14,    1,    1,    7,    1,   15,   16,   13,   17,
 332
 333        18,   19,   20,   13,   21,   13,   13,   22,   23,   24,
 334        25,   13,   26,   27,   28,   29,   30,   13,   13,   13,
 335        13,   13,    1,   31,    1,   32,    1,    1,    1,    1,
 336         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 337         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 338         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 340         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 341         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 342         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 343
 344         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 345         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 346         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 347         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 348         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 349         1,    1,    1,    1,    1
 350     } ;
 351
 352 static yyconst int yy_meta[33] =
 353     {   0,
 354         1,    1,    2,    1,    3,    1,    4,    4,    4,    1,
 355         1,    1,    4,    3,    4,    4,    4,    4,    4,    4,
 356         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 357         1,    1
 358     } ;
 359
 360 static yyconst short int yy_base[93] =
 361     {   0,
 362         0,    0,   30,   31,    0,    0,   82,   81,  101,  142,
 363        35,   28,  142,   94,   32,   88,   31,   87,    0,   69,
 364        66,   28,   28,   67,   29,   63,   30,   63,   62,   57,
 365         0,  142,  142,   88,  142,  142,  142,   48,  142,  142,
 366       142,   44,  142,  142,  142,  142,    0,   70,    0,   64,
 367        63,    0,    0,    0,    0,    0,  142,    0,    0,   55,
 368         0,   46,  142,    0,  142,   53,   62,  142,  142,  142,
 369       142,  142,    0,   44,   48,    0,   41,   70,   72,   38,
 370         0,    0,   74,    0,  142,  117,  121,  125,   50,  129,
 371       133,  137
 372
 373     } ;
 374
 375 static yyconst short int yy_def[93] =
 376     {   0,
 377        85,    1,   86,   86,   87,   87,   88,   88,   85,   85,
 378        85,   85,   85,   85,   85,   85,   85,   85,   89,   89,
 379        89,   89,   89,   89,   89,   90,   89,   89,   89,   85,
 380        91,   85,   85,   92,   85,   85,   85,   85,   85,   85,
 381        85,   85,   85,   85,   85,   85,   89,   89,   89,   89,
 382        89,   89,   89,   89,   89,   89,   85,   89,   89,   89,
 383        89,   89,   85,   91,   85,   85,   85,   85,   85,   85,
 384        85,   85,   89,   89,   89,   89,   89,   85,   85,   89,
 385        89,   89,   85,   89,    0,   85,   85,   85,   85,   85,
 386        85,   85
 387
 388     } ;
 389
 390 static yyconst short int yy_nxt[175] =
 391     {   0,
 392        10,   11,   11,   12,   13,   14,   10,   15,   15,   16,
 393        17,   18,   19,   10,   20,   19,   19,   21,   22,   23,
 394        24,   25,   26,   27,   28,   19,   19,   19,   29,   19,
 395        30,   10,   32,   32,   33,   33,   38,   38,   39,   42,
 396        42,   44,   50,   34,   34,   52,   55,   59,   51,   38,
 397        38,   42,   42,   47,   60,   84,   53,   56,   82,   40,
 398        78,   79,   45,   57,   57,   81,   57,   57,   57,   79,
 399        79,   80,   57,   57,   57,   77,   57,   83,   79,   79,
 400        79,   79,   79,   76,   75,   74,   73,   63,   62,   61,
 401        54,   49,   48,   57,   57,   66,   67,   46,   43,   41,
 402
 403        85,   37,   37,   68,   85,   85,   69,   85,   85,   85,
 404        85,   70,   85,   85,   71,   85,   72,   31,   31,   31,
 405        31,   35,   35,   35,   35,   36,   36,   36,   36,   58,
 406        85,   58,   58,   64,   85,   85,   64,   65,   65,   65,
 407        65,    9,   85,   85,   85,   85,   85,   85,   85,   85,
 408        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 409        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 410        85,   85,   85,   85
 411     } ;
 412
 413 static yyconst short int yy_chk[175] =
 414     {   0,
 415         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 416         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 417         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 418         1,    1,    3,    4,    3,    4,   11,   11,   12,   15,
 419        15,   17,   22,    3,    4,   23,   25,   27,   22,   38,
 420        38,   42,   42,   89,   27,   80,   23,   25,   77,   12,
 421        66,   66,   17,   26,   26,   75,   26,   26,   26,   67,
 422        67,   74,   26,   26,   26,   62,   26,   78,   78,   79,
 423        79,   83,   83,   60,   51,   50,   48,   30,   29,   28,
 424        24,   21,   20,   26,   26,   34,   34,   18,   16,   14,
 425
 426         9,    8,    7,   34,    0,    0,   34,    0,    0,    0,
 427         0,   34,    0,    0,   34,    0,   34,   86,   86,   86,
 428        86,   87,   87,   87,   87,   88,   88,   88,   88,   90,
 429         0,   90,   90,   91,    0,    0,   91,   92,   92,   92,
 430        92,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 431        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 432        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 433        85,   85,   85,   85
 434     } ;
 435
 436 static yy_state_type yy_last_accepting_state;
 437 static char *yy_last_accepting_cpos;
 438
 439 /* The intent behind this definition is that it'll catch
 440  * any uses of REJECT which flex missed.
 441  */
 442 #define REJECT reject_used_but_not_detected
 443 #define yymore() yymore_used_but_not_detected
 444 #define YY_MORE_ADJ 0
 445 #define YY_RESTORE_YY_MORE_OFFSET
 446 char *yytext;
 447 #line 1 "ssl_expr_scan.l"
 448 #define INITIAL 0
 449 /* Licensed to the Apache Software Foundation (ASF) under one or more
 450  * contributor license agreements.  See the NOTICE file distributed with
 451  * this work for additional information regarding copyright ownership.
 452  * The ASF licenses this file to You under the Apache License, Version 2.0
 453  * (the "License"); you may not use this file except in compliance with
 454  * the License.  You may obtain a copy of the License at
 455  *
 456  *     http://www.apache.org/licenses/LICENSE-2.0
 457  *
 458  * Unless required by applicable law or agreed to in writing, software
 459  * distributed under the License is distributed on an "AS IS" BASIS,
 460  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 461  * See the License for the specific language governing permissions and
 462  * limitations under the License.
 463  */
 464
 465 /*                      _             _
 466  *  _ __ ___   ___   __| |    ___ ___| |
 467  * | '_ ` _ \ / _ \ / _` |   / __/ __| |
 468  * | | | | | | (_) | (_| |   \__ \__ \ | mod_ssl - Apache Interface to OpenSSL
 469  * |_| |_| |_|\___/ \__,_|___|___/___/_| http://www.modssl.org/
 470  *                      |_____|
 471  *  ssl_expr_scan.l
 472  *  Expression Scanner
 473  */
 474 /* ``Killing for peace is
 475 like fucking for virginity.''
 476 -- Unknown  */
 477 /*  _________________________________________________________________
 478 **
 479 **  Expression Scanner
 480 **  _________________________________________________________________
 481 */
 482 #line 38 "ssl_expr_scan.l"
 483 #include "mod_ssl.h"
 484
 485 #include "ssl_expr_parse.h"
 486
 487 #define YY_NO_UNPUT 1
 488 int yyinput(char *buf, int max_size);
 489
 490 #undef  YY_INPUT
 491 #define YY_INPUT(buf,result,max_size) \
 492     (result = yyinput(buf, max_size))
 493
 494 #define MAX_STR_LEN 2048
 495 /* %option stack */
 496 #define YY_NEVER_INTERACTIVE 1
 497 #define str 1
 498
 499 #define regex 2
 500 #define regex_flags 3
 501
 502 #line 535 "lex.ssl_expr_yy.c"
 503
 504 /* Macros after this point can all be overridden by user definitions in
 505  * section 1.
 506  */
 507
 508 #ifndef YY_SKIP_YYWRAP
 509 #ifdef __cplusplus
 510 extern "C" int yywrap YY_PROTO(( void ));
 511 #else
 512 extern int yywrap YY_PROTO(( void ));
 513 #endif
 514 #endif
 515
 516 #ifndef YY_NO_UNPUT
 517 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 518 #endif
 519
 520 #ifndef yytext_ptr
 521 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 522 #endif
 523
 524 #ifdef YY_NEED_STRLEN
 525 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 526 #endif
 527
 528 #ifndef YY_NO_INPUT
 529 #ifdef __cplusplus
 530 static int yyinput YY_PROTO(( void ));
 531 #else
 532 static int input YY_PROTO(( void ));
 533 #endif
 534 #endif
 535
 536 #if YY_STACK_USED
 537 static int yy_start_stack_ptr = 0;
 538 static int yy_start_stack_depth = 0;
 539 static int *yy_start_stack = 0;
 540 #ifndef YY_NO_PUSH_STATE
 541 static void yy_push_state YY_PROTO(( int new_state ));
 542 #endif
 543 #ifndef YY_NO_POP_STATE
 544 static void yy_pop_state YY_PROTO(( void ));
 545 #endif
 546 #ifndef YY_NO_TOP_STATE
 547 static int yy_top_state YY_PROTO(( void ));
 548 #endif
 549
 550 #else
 551 #define YY_NO_PUSH_STATE 1
 552 #define YY_NO_POP_STATE 1
 553 #define YY_NO_TOP_STATE 1
 554 #endif
 555
 556 #ifdef YY_MALLOC_DECL
 557 YY_MALLOC_DECL
 558 #else
 559 #if __STDC__
 560 #ifndef __cplusplus
 561 #include <stdlib.h>
 562 #endif
 563 #else
 564 /* Just try to get by without declaring the routines.  This will fail
 565  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 566  * or sizeof(void*) != sizeof(int).
 567  */
 568 #endif
 569 #endif
 570
 571 /* Amount of stuff to slurp up with each read. */
 572 #ifndef YY_READ_BUF_SIZE
 573 #define YY_READ_BUF_SIZE 8192
 574 #endif
 575
 576 /* Copy whatever the last rule matched to the standard output. */
 577
 578 #ifndef ECHO
 579 /* This used to be an fputs(), but since the string might contain NUL's,
 580  * we now use fwrite().
 581  */
 582 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 583 #endif
 584
 585 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 586  * is returned in "result".
 587  */
 588 #ifndef YY_INPUT
 589 #define YY_INPUT(buf,result,max_size) \
 590         if ( yy_current_buffer->yy_is_interactive ) \
 591                 { \
 592                 int c = '*', n; \
 593                 for ( n = 0; n < max_size && \
 594                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 595                         buf[n] = (char) c; \
 596                 if ( c == '\n' ) \
 597                         buf[n++] = (char) c; \
 598                 if ( c == EOF && ferror( yyin ) ) \
 599                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 600                 result = n; \
 601                 } \
 602         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 603                   && ferror( yyin ) ) \
 604                 YY_FATAL_ERROR( "input in flex scanner failed" );
 605 #endif
 606
 607 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 608  * we don't want an extra ';' after the "return" because that will cause
 609  * some compilers to complain about unreachable statements.
 610  */
 611 #ifndef yyterminate
 612 #define yyterminate() return YY_NULL
 613 #endif
 614
 615 /* Number of entries by which start-condition stack grows. */
 616 #ifndef YY_START_STACK_INCR
 617 #define YY_START_STACK_INCR 25
 618 #endif
 619
 620 /* Report a fatal error. */
 621 #ifndef YY_FATAL_ERROR
 622 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 623 #endif
 624
 625 /* Default declaration of generated scanner - a define so the user can
 626  * easily add parameters.
 627  */
 628 #ifndef YY_DECL
 629 #define YY_DECL int yylex YY_PROTO(( void ))
 630 #endif
 631
 632 /* Code executed at the beginning of each rule, after yytext and yyleng
 633  * have been set up.
 634  */
 635 #ifndef YY_USER_ACTION
 636 #define YY_USER_ACTION
 637 #endif
 638
 639 /* Code executed at the end of each rule. */
 640 #ifndef YY_BREAK
 641 #define YY_BREAK break;
 642 #endif
 643
 644 #define YY_RULE_SETUP \
 645         YY_USER_ACTION
 646
 647 YY_DECL
 648         {
 649         register yy_state_type yy_current_state;
 650         register char *yy_cp, *yy_bp;
 651         register int yy_act;
 652
 653 #line 91 "ssl_expr_scan.l"
 654
 655
 656   char  caStr[MAX_STR_LEN];
 657   char *cpStr = NULL;
 658   char  caRegex[MAX_STR_LEN];
 659   char *cpRegex = NULL;
 660   char  cRegexDel = NUL;
 661
 662  /*
 663   * Whitespaces
 664   */
 665 #line 698 "lex.ssl_expr_yy.c"
 666
 667         if ( yy_init )
 668                 {
 669                 yy_init = 0;
 670
 671 #ifdef YY_USER_INIT
 672                 YY_USER_INIT;
 673 #endif
 674
 675                 if ( ! yy_start )
 676                         yy_start = 1;   /* first start state */
 677
 678                 if ( ! yyin )
 679                         yyin = stdin;
 680
 681                 if ( ! yyout )
 682                         yyout = stdout;
 683
 684                 if ( ! yy_current_buffer )
 685                         yy_current_buffer =
 686                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 687
 688                 yy_load_buffer_state();
 689                 }
 690
 691         while ( 1 )             /* loops until end-of-file is reached */
 692                 {
 693                 yy_cp = yy_c_buf_p;
 694
 695                 /* Support of yytext. */
 696                 *yy_cp = yy_hold_char;
 697
 698                 /* yy_bp points to the position in yy_ch_buf of the start of
 699                  * the current run.
 700                  */
 701                 yy_bp = yy_cp;
 702
 703                 yy_current_state = yy_start;
 704 yy_match:
 705                 do
 706                         {
 707                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 708                         if ( yy_accept[yy_current_state] )
 709                                 {
 710                                 yy_last_accepting_state = yy_current_state;
 711                                 yy_last_accepting_cpos = yy_cp;
 712                                 }
 713                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 714                                 {
 715                                 yy_current_state = (int) yy_def[yy_current_state];
 716                                 if ( yy_current_state >= 86 )
 717                                         yy_c = yy_meta[(unsigned int) yy_c];
 718                                 }
 719                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 720                         ++yy_cp;
 721                         }
 722                 while ( yy_current_state != 85 );
 723                 yy_cp = yy_last_accepting_cpos;
 724                 yy_current_state = yy_last_accepting_state;
 725
 726 yy_find_action:
 727                 yy_act = yy_accept[yy_current_state];
 728
 729                 YY_DO_BEFORE_ACTION;
 730
 731
 732 do_action:      /* This label is used only to access EOF actions. */
 733
 734
 735                 switch ( yy_act )
 736         { /* beginning of action switch */
 737                         case 0: /* must back up */
 738                         /* undo the effects of YY_DO_BEFORE_ACTION */
 739                         *yy_cp = yy_hold_char;
 740                         yy_cp = yy_last_accepting_cpos;
 741                         yy_current_state = yy_last_accepting_state;
 742                         goto yy_find_action;
 743
 744 case 1:
 745 YY_RULE_SETUP
 746 #line 102 "ssl_expr_scan.l"
 747 {
 748     /* NOP */
 749 }
 750         YY_BREAK
 751 /*
 752   * C-style strings ("...")
 753   */
 754 case 2:
 755 YY_RULE_SETUP
 756 #line 109 "ssl_expr_scan.l"
 757 {
 758     cpStr = caStr;
 759     BEGIN(str);
 760 }
 761         YY_BREAK
 762 case 3:
 763 YY_RULE_SETUP
 764 #line 113 "ssl_expr_scan.l"
 765 {
 766     BEGIN(INITIAL);
 767     *cpStr = NUL;
 768     yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caStr);
 769     return T_STRING;
 770 }
 771         YY_BREAK
 772 case 4:
 773 YY_RULE_SETUP
 774 #line 119 "ssl_expr_scan.l"
 775 {
 776     yyerror("Unterminated string");
 777 }
 778         YY_BREAK
 779 case 5:
 780 YY_RULE_SETUP
 781 #line 122 "ssl_expr_scan.l"
 782 {
 783     int result;
 784
 785     (void)sscanf(yytext+1, "%o", &result);
 786     if (result > 0xff)
 787         yyerror("Escape sequence out of bound");
 788     else
 789         *cpStr++ = result;
 790 }
 791         YY_BREAK
 792 case 6:
 793 YY_RULE_SETUP
 794 #line 131 "ssl_expr_scan.l"
 795 {
 796     yyerror("Bad escape sequence");
 797 }
 798         YY_BREAK
 799 case 7:
 800 YY_RULE_SETUP
 801 #line 134 "ssl_expr_scan.l"
 802 { *cpStr++ = '\n'; }
 803         YY_BREAK
 804 case 8:
 805 YY_RULE_SETUP
 806 #line 135 "ssl_expr_scan.l"
 807 { *cpStr++ = '\r'; }
 808         YY_BREAK
 809 case 9:
 810 YY_RULE_SETUP
 811 #line 136 "ssl_expr_scan.l"
 812 { *cpStr++ = '\t'; }
 813         YY_BREAK
 814 case 10:
 815 YY_RULE_SETUP
 816 #line 137 "ssl_expr_scan.l"
 817 { *cpStr++ = '\b'; }
 818         YY_BREAK
 819 case 11:
 820 YY_RULE_SETUP
 821 #line 138 "ssl_expr_scan.l"
 822 { *cpStr++ = '\f'; }
 823         YY_BREAK
 824 case 12:
 825 YY_RULE_SETUP
 826 #line 139 "ssl_expr_scan.l"
 827 {
 828     *cpStr++ = yytext[1];
 829 }
 830         YY_BREAK
 831 case 13:
 832 YY_RULE_SETUP
 833 #line 142 "ssl_expr_scan.l"
 834 {
 835     char *cp = yytext;
 836     while (*cp != NUL)
 837         *cpStr++ = *cp++;
 838 }
 839         YY_BREAK
 840 case 14:
 841 YY_RULE_SETUP
 842 #line 147 "ssl_expr_scan.l"
 843 {
 844     *cpStr++ = yytext[1];
 845 }
 846         YY_BREAK
 847 /*
 848   * Regular Expression
 849   */
 850 case 15:
 851 YY_RULE_SETUP
 852 #line 154 "ssl_expr_scan.l"
 853 {
 854     cRegexDel = yytext[1];
 855     cpRegex = caRegex;
 856     BEGIN(regex);
 857 }
 858         YY_BREAK
 859 case 16:
 860 YY_RULE_SETUP
 861 #line 159 "ssl_expr_scan.l"
 862 {
 863     if (yytext[0] == cRegexDel) {
 864         *cpRegex = NUL;
 865         BEGIN(regex_flags);
 866     }
 867     else {
 868         *cpRegex++ = yytext[0];
 869     }
 870 }
 871         YY_BREAK
 872 case 17:
 873 YY_RULE_SETUP
 874 #line 168 "ssl_expr_scan.l"
 875 {
 876     yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caRegex);
 877     BEGIN(INITIAL);
 878     return T_REGEX_I;
 879 }
 880         YY_BREAK
 881 case 18:
 882 YY_RULE_SETUP
 883 #line 173 "ssl_expr_scan.l"
 884 {
 885     yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caRegex);
 886     yyless(0);
 887     BEGIN(INITIAL);
 888     return T_REGEX;
 889 }
 890         YY_BREAK
 891 case YY_STATE_EOF(regex_flags):
 892 #line 179 "ssl_expr_scan.l"
 893 {
 894     yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, caRegex);
 895     BEGIN(INITIAL);
 896     return T_REGEX;
 897 }
 898         YY_BREAK
 899 /*
 900   * Operators
 901   */
 902 case 19:
 903 YY_RULE_SETUP
 904 #line 188 "ssl_expr_scan.l"
 905 { return T_OP_EQ; }
 906         YY_BREAK
 907 case 20:
 908 YY_RULE_SETUP
 909 #line 189 "ssl_expr_scan.l"
 910 { return T_OP_EQ; }
 911         YY_BREAK
 912 case 21:
 913 YY_RULE_SETUP
 914 #line 190 "ssl_expr_scan.l"
 915 { return T_OP_NE; }
 916         YY_BREAK
 917 case 22:
 918 YY_RULE_SETUP
 919 #line 191 "ssl_expr_scan.l"
 920 { return T_OP_NE; }
 921         YY_BREAK
 922 case 23:
 923 YY_RULE_SETUP
 924 #line 192 "ssl_expr_scan.l"
 925 { return T_OP_LT; }
 926         YY_BREAK
 927 case 24:
 928 YY_RULE_SETUP
 929 #line 193 "ssl_expr_scan.l"
 930 { return T_OP_LT; }
 931         YY_BREAK
 932 case 25:
 933 YY_RULE_SETUP
 934 #line 194 "ssl_expr_scan.l"
 935 { return T_OP_LE; }
 936         YY_BREAK
 937 case 26:
 938 YY_RULE_SETUP
 939 #line 195 "ssl_expr_scan.l"
 940 { return T_OP_LE; }
 941         YY_BREAK
 942 case 27:
 943 YY_RULE_SETUP
 944 #line 196 "ssl_expr_scan.l"
 945 { return T_OP_GT; }
 946         YY_BREAK
 947 case 28:
 948 YY_RULE_SETUP
 949 #line 197 "ssl_expr_scan.l"
 950 { return T_OP_GT; }
 951         YY_BREAK
 952 case 29:
 953 YY_RULE_SETUP
 954 #line 198 "ssl_expr_scan.l"
 955 { return T_OP_GE; }
 956         YY_BREAK
 957 case 30:
 958 YY_RULE_SETUP
 959 #line 199 "ssl_expr_scan.l"
 960 { return T_OP_GE; }
 961         YY_BREAK
 962 case 31:
 963 YY_RULE_SETUP
 964 #line 200 "ssl_expr_scan.l"
 965 { return T_OP_REG; }
 966         YY_BREAK
 967 case 32:
 968 YY_RULE_SETUP
 969 #line 201 "ssl_expr_scan.l"
 970 { return T_OP_NRE; }
 971         YY_BREAK
 972 case 33:
 973 YY_RULE_SETUP
 974 #line 202 "ssl_expr_scan.l"
 975 { return T_OP_AND; }
 976         YY_BREAK
 977 case 34:
 978 YY_RULE_SETUP
 979 #line 203 "ssl_expr_scan.l"
 980 { return T_OP_AND; }
 981         YY_BREAK
 982 case 35:
 983 YY_RULE_SETUP
 984 #line 204 "ssl_expr_scan.l"
 985 { return T_OP_OR; }
 986         YY_BREAK
 987 case 36:
 988 YY_RULE_SETUP
 989 #line 205 "ssl_expr_scan.l"
 990 { return T_OP_OR; }
 991         YY_BREAK
 992 case 37:
 993 YY_RULE_SETUP
 994 #line 206 "ssl_expr_scan.l"
 995 { return T_OP_NOT; }
 996         YY_BREAK
 997 case 38:
 998 YY_RULE_SETUP
 999 #line 207 "ssl_expr_scan.l"
1000 { return T_OP_NOT; }
1001         YY_BREAK
1002 case 39:
1003 YY_RULE_SETUP
1004 #line 208 "ssl_expr_scan.l"
1005 { return T_OP_IN; }
1006         YY_BREAK
1007 /*
1008   * Functions
1009   */
1010 case 40:
1011 YY_RULE_SETUP
1012 #line 213 "ssl_expr_scan.l"
1013 { return T_FUNC_FILE; }
1014         YY_BREAK
1015 /*
1016   * Specials
1017   */
1018 case 41:
1019 YY_RULE_SETUP
1020 #line 218 "ssl_expr_scan.l"
1021 { return T_TRUE; }
1022         YY_BREAK
1023 case 42:
1024 YY_RULE_SETUP
1025 #line 219 "ssl_expr_scan.l"
1026 { return T_FALSE; }
1027         YY_BREAK
1028 /*
1029   * Digits
1030   */
1031 case 43:
1032 YY_RULE_SETUP
1033 #line 224 "ssl_expr_scan.l"
1034 {
1035     yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, yytext);
1036     return T_DIGIT;
1037 }
1038         YY_BREAK
1039 /*
1040   * Identifiers
1041   */
1042 case 44:
1043 YY_RULE_SETUP
1044 #line 232 "ssl_expr_scan.l"
1045 {
1046     yylval.cpVal = apr_pstrdup(ssl_expr_info.pool, yytext);
1047     return T_ID;
1048 }
1049         YY_BREAK
1050 /*
1051   * Anything else is returned as is...
1052   */
1053 case 45:
1054 YY_RULE_SETUP
1055 #line 240 "ssl_expr_scan.l"
1056 {
1057     return yytext[0];
1058 }
1059         YY_BREAK
1060 case 46:
1061 YY_RULE_SETUP
1062 #line 244 "ssl_expr_scan.l"
1063 YY_FATAL_ERROR( "flex scanner jammed" );
1064         YY_BREAK
1065 #line 1098 "lex.ssl_expr_yy.c"
1066 case YY_STATE_EOF(INITIAL):
1067 case YY_STATE_EOF(str):
1068 case YY_STATE_EOF(regex):
1069         yyterminate();
1070
1071         case YY_END_OF_BUFFER:
1072                 {
1073                 /* Amount of text matched not including the EOB char. */
1074                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1075
1076                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1077                 *yy_cp = yy_hold_char;
1078                 YY_RESTORE_YY_MORE_OFFSET
1079
1080                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1081                         {
1082                         /* We're scanning a new file or input source.  It's
1083                          * possible that this happened because the user
1084                          * just pointed yyin at a new source and called
1085                          * yylex().  If so, then we have to assure
1086                          * consistency between yy_current_buffer and our
1087                          * globals.  Here is the right place to do so, because
1088                          * this is the first action (other than possibly a
1089                          * back-up) that will match for the new input source.
1090                          */
1091                         yy_n_chars = yy_current_buffer->yy_n_chars;
1092                         yy_current_buffer->yy_input_file = yyin;
1093                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1094                         }
1095
1096                 /* Note that here we test for yy_c_buf_p "<=" to the position
1097                  * of the first EOB in the buffer, since yy_c_buf_p will
1098                  * already have been incremented past the NUL character
1099                  * (since all states make transitions on EOB to the
1100                  * end-of-buffer state).  Contrast this with the test
1101                  * in input().
1102                  */
1103                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1104                         { /* This was really a NUL. */
1105                         yy_state_type yy_next_state;
1106
1107                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1108
1109                         yy_current_state = yy_get_previous_state();
1110
1111                         /* Okay, we're now positioned to make the NUL
1112                          * transition.  We couldn't have
1113                          * yy_get_previous_state() go ahead and do it
1114                          * for us because it doesn't know how to deal
1115                          * with the possibility of jamming (and we don't
1116                          * want to build jamming into it because then it
1117                          * will run more slowly).
1118                          */
1119
1120                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1121
1122                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1123
1124                         if ( yy_next_state )
1125                                 {
1126                                 /* Consume the NUL. */
1127                                 yy_cp = ++yy_c_buf_p;
1128                                 yy_current_state = yy_next_state;
1129                                 goto yy_match;
1130                                 }
1131
1132                         else
1133                                 {
1134                                 yy_cp = yy_last_accepting_cpos;
1135                                 yy_current_state = yy_last_accepting_state;
1136                                 goto yy_find_action;
1137                                 }
1138                         }
1139
1140                 else switch ( yy_get_next_buffer() )
1141                         {
1142                         case EOB_ACT_END_OF_FILE:
1143                                 {
1144                                 yy_did_buffer_switch_on_eof = 0;
1145
1146                                 if ( yywrap() )
1147                                         {
1148                                         /* Note: because we've taken care in
1149                                          * yy_get_next_buffer() to have set up
1150                                          * yytext, we can now set up
1151                                          * yy_c_buf_p so that if some total
1152                                          * hoser (like flex itself) wants to
1153                                          * call the scanner after we return the
1154                                          * YY_NULL, it'll still work - another
1155                                          * YY_NULL will get returned.
1156                                          */
1157                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1158
1159                                         yy_act = YY_STATE_EOF(YY_START);
1160                                         goto do_action;
1161                                         }
1162
1163                                 else
1164                                         {
1165                                         if ( ! yy_did_buffer_switch_on_eof )
1166                                                 YY_NEW_FILE;
1167                                         }
1168                                 break;
1169                                 }
1170
1171                         case EOB_ACT_CONTINUE_SCAN:
1172                                 yy_c_buf_p =
1173                                         yytext_ptr + yy_amount_of_matched_text;
1174
1175                                 yy_current_state = yy_get_previous_state();
1176
1177                                 yy_cp = yy_c_buf_p;
1178                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1179                                 goto yy_match;
1180
1181                         case EOB_ACT_LAST_MATCH:
1182                                 yy_c_buf_p =
1183                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1184
1185                                 yy_current_state = yy_get_previous_state();
1186
1187                                 yy_cp = yy_c_buf_p;
1188                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1189                                 goto yy_find_action;
1190                         }
1191                 break;
1192                 }
1193
1194         default:
1195                 YY_FATAL_ERROR(
1196                         "fatal flex scanner internal error--no action found" );
1197         } /* end of action switch */
1198                 } /* end of scanning one token */
1199         } /* end of yylex */
1200
1201
1202 /* yy_get_next_buffer - try to read in a new buffer
1203  *
1204  * Returns a code representing an action:
1205  *      EOB_ACT_LAST_MATCH -
1206  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1207  *      EOB_ACT_END_OF_FILE - end of file
1208  */
1209
1210 static int yy_get_next_buffer()
1211         {
1212         register char *dest = yy_current_buffer->yy_ch_buf;
1213         register char *source = yytext_ptr;
1214         register int number_to_move, i;
1215         int ret_val;
1216
1217         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1218                 YY_FATAL_ERROR(
1219                 "fatal flex scanner internal error--end of buffer missed" );
1220
1221         if ( yy_current_buffer->yy_fill_buffer == 0 )
1222                 { /* Don't try to fill the buffer, so this is an EOF. */
1223                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1224                         {
1225                         /* We matched a single character, the EOB, so
1226                          * treat this as a final EOF.
1227                          */
1228                         return EOB_ACT_END_OF_FILE;
1229                         }
1230
1231                 else
1232                         {
1233                         /* We matched some text prior to the EOB, first
1234                          * process it.
1235                          */
1236                         return EOB_ACT_LAST_MATCH;
1237                         }
1238                 }
1239
1240         /* Try to read more data. */
1241
1242         /* First move last chars to start of buffer. */
1243         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1244
1245         for ( i = 0; i < number_to_move; ++i )
1246                 *(dest++) = *(source++);
1247
1248         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1249                 /* don't do the read, it's not guaranteed to return an EOF,
1250                  * just force an EOF
1251                  */
1252                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1253
1254         else
1255                 {
1256                 int num_to_read =
1257                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1258
1259                 while ( num_to_read <= 0 )
1260                         { /* Not enough room in the buffer - grow it. */
1261 #ifdef YY_USES_REJECT
1262                         YY_FATAL_ERROR(
1263 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1264 #else
1265
1266                         /* just a shorter name for the current buffer */
1267                         YY_BUFFER_STATE b = yy_current_buffer;
1268
1269                         int yy_c_buf_p_offset =
1270                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1271
1272                         if ( b->yy_is_our_buffer )
1273                                 {
1274                                 int new_size = b->yy_buf_size * 2;
1275
1276                                 if ( new_size <= 0 )
1277                                         b->yy_buf_size += b->yy_buf_size / 8;
1278                                 else
1279                                         b->yy_buf_size *= 2;
1280
1281                                 b->yy_ch_buf = (char *)
1282                                         /* Include room in for 2 EOB chars. */
1283                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1284                                                          b->yy_buf_size + 2 );
1285                                 }
1286                         else
1287                                 /* Can't grow it, we don't own it. */
1288                                 b->yy_ch_buf = 0;
1289
1290                         if ( ! b->yy_ch_buf )
1291                                 YY_FATAL_ERROR(
1292                                 "fatal error - scanner input buffer overflow" );
1293
1294                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1295
1296                         num_to_read = yy_current_buffer->yy_buf_size -
1297                                                 number_to_move - 1;
1298 #endif
1299                         }
1300
1301                 if ( num_to_read > YY_READ_BUF_SIZE )
1302                         num_to_read = YY_READ_BUF_SIZE;
1303
1304                 /* Read in more data. */
1305                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1306                         yy_n_chars, num_to_read );
1307
1308                 yy_current_buffer->yy_n_chars = yy_n_chars;
1309                 }
1310
1311         if ( yy_n_chars == 0 )
1312                 {
1313                 if ( number_to_move == YY_MORE_ADJ )
1314                         {
1315                         ret_val = EOB_ACT_END_OF_FILE;
1316                         yyrestart( yyin );
1317                         }
1318
1319                 else
1320                         {
1321                         ret_val = EOB_ACT_LAST_MATCH;
1322                         yy_current_buffer->yy_buffer_status =
1323                                 YY_BUFFER_EOF_PENDING;
1324                         }
1325                 }
1326
1327         else
1328                 ret_val = EOB_ACT_CONTINUE_SCAN;
1329
1330         yy_n_chars += number_to_move;
1331         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1332         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1333
1334         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1335
1336         return ret_val;
1337         }
1338
1339
1340 /* yy_get_previous_state - get the state just before the EOB char was reached */
1341
1342 static yy_state_type yy_get_previous_state()
1343         {
1344         register yy_state_type yy_current_state;
1345         register char *yy_cp;
1346
1347         yy_current_state = yy_start;
1348
1349         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1350                 {
1351                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1352                 if ( yy_accept[yy_current_state] )
1353                         {
1354                         yy_last_accepting_state = yy_current_state;
1355                         yy_last_accepting_cpos = yy_cp;
1356                         }
1357                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1358                         {
1359                         yy_current_state = (int) yy_def[yy_current_state];
1360                         if ( yy_current_state >= 86 )
1361                                 yy_c = yy_meta[(unsigned int) yy_c];
1362                         }
1363                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1364                 }
1365
1366         return yy_current_state;
1367         }
1368
1369
1370 /* yy_try_NUL_trans - try to make a transition on the NUL character
1371  *
1372  * synopsis
1373  *      next_state = yy_try_NUL_trans( current_state );
1374  */
1375
1376 #ifdef YY_USE_PROTOS
1377 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1378 #else
1379 static yy_state_type yy_try_NUL_trans( yy_current_state )
1380 yy_state_type yy_current_state;
1381 #endif
1382         {
1383         register int yy_is_jam;
1384         register char *yy_cp = yy_c_buf_p;
1385
1386         register YY_CHAR yy_c = 1;
1387         if ( yy_accept[yy_current_state] )
1388                 {
1389                 yy_last_accepting_state = yy_current_state;
1390                 yy_last_accepting_cpos = yy_cp;
1391                 }
1392         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1393                 {
1394                 yy_current_state = (int) yy_def[yy_current_state];
1395                 if ( yy_current_state >= 86 )
1396                         yy_c = yy_meta[(unsigned int) yy_c];
1397                 }
1398         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1399         yy_is_jam = (yy_current_state == 85);
1400
1401         return yy_is_jam ? 0 : yy_current_state;
1402         }
1403
1404
1405 #ifndef YY_NO_UNPUT
1406 #ifdef YY_USE_PROTOS
1407 static void yyunput( int c, register char *yy_bp )
1408 #else
1409 static void yyunput( c, yy_bp )
1410 int c;
1411 register char *yy_bp;
1412 #endif
1413         {
1414         register char *yy_cp = yy_c_buf_p;
1415
1416         /* undo effects of setting up yytext */
1417         *yy_cp = yy_hold_char;
1418
1419         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1420                 { /* need to shift things up to make room */
1421                 /* +2 for EOB chars. */
1422                 register int number_to_move = yy_n_chars + 2;
1423                 register char *dest = &yy_current_buffer->yy_ch_buf[
1424                                         yy_current_buffer->yy_buf_size + 2];
1425                 register char *source =
1426                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1427
1428                 while ( source > yy_current_buffer->yy_ch_buf )
1429                         *--dest = *--source;
1430
1431                 yy_cp += (int) (dest - source);
1432                 yy_bp += (int) (dest - source);
1433                 yy_current_buffer->yy_n_chars =
1434                         yy_n_chars = yy_current_buffer->yy_buf_size;
1435
1436                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1437                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1438                 }
1439
1440         *--yy_cp = (char) c;
1441
1442
1443         yytext_ptr = yy_bp;
1444         yy_hold_char = *yy_cp;
1445         yy_c_buf_p = yy_cp;
1446         }
1447 #endif  /* ifndef YY_NO_UNPUT */
1448
1449
1450 #ifdef __cplusplus
1451 static int yyinput()
1452 #else
1453 static int input()
1454 #endif
1455         {
1456         int c;
1457
1458         *yy_c_buf_p = yy_hold_char;
1459
1460         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1461                 {
1462                 /* yy_c_buf_p now points to the character we want to return.
1463                  * If this occurs *before* the EOB characters, then it's a
1464                  * valid NUL; if not, then we've hit the end of the buffer.
1465                  */
1466                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1467                         /* This was really a NUL. */
1468                         *yy_c_buf_p = '\0';
1469
1470                 else
1471                         { /* need more input */
1472                         int offset = yy_c_buf_p - yytext_ptr;
1473                         ++yy_c_buf_p;
1474
1475                         switch ( yy_get_next_buffer() )
1476                                 {
1477                                 case EOB_ACT_LAST_MATCH:
1478                                         /* This happens because yy_g_n_b()
1479                                          * sees that we've accumulated a
1480                                          * token and flags that we need to
1481                                          * try matching the token before
1482                                          * proceeding.  But for input(),
1483                                          * there's no matching to consider.
1484                                          * So convert the EOB_ACT_LAST_MATCH
1485                                          * to EOB_ACT_END_OF_FILE.
1486                                          */
1487
1488                                         /* Reset buffer status. */
1489                                         yyrestart( yyin );
1490
1491                                         /* fall through */
1492
1493                                 case EOB_ACT_END_OF_FILE:
1494                                         {
1495                                         if ( yywrap() )
1496                                                 return EOF;
1497
1498                                         if ( ! yy_did_buffer_switch_on_eof )
1499                                                 YY_NEW_FILE;
1500 #ifdef __cplusplus
1501                                         return yyinput();
1502 #else
1503                                         return input();
1504 #endif
1505                                         }
1506
1507                                 case EOB_ACT_CONTINUE_SCAN:
1508                                         yy_c_buf_p = yytext_ptr + offset;
1509                                         break;
1510                                 }
1511                         }
1512                 }
1513
1514         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1515         *yy_c_buf_p = '\0';     /* preserve yytext */
1516         yy_hold_char = *++yy_c_buf_p;
1517
1518
1519         return c;
1520         }
1521
1522
1523 #ifdef YY_USE_PROTOS
1524 void yyrestart( FILE *input_file )
1525 #else
1526 void yyrestart( input_file )
1527 FILE *input_file;
1528 #endif
1529         {
1530         if ( ! yy_current_buffer )
1531                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1532
1533         yy_init_buffer( yy_current_buffer, input_file );
1534         yy_load_buffer_state();
1535         }
1536
1537
1538 #ifdef YY_USE_PROTOS
1539 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1540 #else
1541 void yy_switch_to_buffer( new_buffer )
1542 YY_BUFFER_STATE new_buffer;
1543 #endif
1544         {
1545         if ( yy_current_buffer == new_buffer )
1546                 return;
1547
1548         if ( yy_current_buffer )
1549                 {
1550                 /* Flush out information for old buffer. */
1551                 *yy_c_buf_p = yy_hold_char;
1552                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1553                 yy_current_buffer->yy_n_chars = yy_n_chars;
1554                 }
1555
1556         yy_current_buffer = new_buffer;
1557         yy_load_buffer_state();
1558
1559         /* We don't actually know whether we did this switch during
1560          * EOF (yywrap()) processing, but the only time this flag
1561          * is looked at is after yywrap() is called, so it's safe
1562          * to go ahead and always set it.
1563          */
1564         yy_did_buffer_switch_on_eof = 1;
1565         }
1566
1567
1568 #ifdef YY_USE_PROTOS
1569 void yy_load_buffer_state( void )
1570 #else
1571 void yy_load_buffer_state()
1572 #endif
1573         {
1574         yy_n_chars = yy_current_buffer->yy_n_chars;
1575         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1576         yyin = yy_current_buffer->yy_input_file;
1577         yy_hold_char = *yy_c_buf_p;
1578         }
1579
1580
1581 #ifdef YY_USE_PROTOS
1582 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1583 #else
1584 YY_BUFFER_STATE yy_create_buffer( file, size )
1585 FILE *file;
1586 int size;
1587 #endif
1588         {
1589         YY_BUFFER_STATE b;
1590
1591         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1592         if ( ! b )
1593                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1594
1595         b->yy_buf_size = size;
1596
1597         /* yy_ch_buf has to be 2 characters longer than the size given because
1598          * we need to put in 2 end-of-buffer characters.
1599          */
1600         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1601         if ( ! b->yy_ch_buf )
1602                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1603
1604         b->yy_is_our_buffer = 1;
1605
1606         yy_init_buffer( b, file );
1607
1608         return b;
1609         }
1610
1611
1612 #ifdef YY_USE_PROTOS
1613 void yy_delete_buffer( YY_BUFFER_STATE b )
1614 #else
1615 void yy_delete_buffer( b )
1616 YY_BUFFER_STATE b;
1617 #endif
1618         {
1619         if ( ! b )
1620                 return;
1621
1622         if ( b == yy_current_buffer )
1623                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1624
1625         if ( b->yy_is_our_buffer )
1626                 yy_flex_free( (void *) b->yy_ch_buf );
1627
1628         yy_flex_free( (void *) b );
1629         }
1630
1631
1632 #ifndef YY_ALWAYS_INTERACTIVE
1633 #ifndef YY_NEVER_INTERACTIVE
1634 extern int isatty YY_PROTO(( int ));
1635 #endif
1636 #endif
1637
1638 #ifdef YY_USE_PROTOS
1639 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1640 #else
1641 void yy_init_buffer( b, file )
1642 YY_BUFFER_STATE b;
1643 FILE *file;
1644 #endif
1645
1646
1647         {
1648         yy_flush_buffer( b );
1649
1650         b->yy_input_file = file;
1651         b->yy_fill_buffer = 1;
1652
1653 #if YY_ALWAYS_INTERACTIVE
1654         b->yy_is_interactive = 1;
1655 #else
1656 #if YY_NEVER_INTERACTIVE
1657         b->yy_is_interactive = 0;
1658 #else
1659         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1660 #endif
1661 #endif
1662         }
1663
1664
1665 #ifdef YY_USE_PROTOS
1666 void yy_flush_buffer( YY_BUFFER_STATE b )
1667 #else
1668 void yy_flush_buffer( b )
1669 YY_BUFFER_STATE b;
1670 #endif
1671
1672         {
1673         if ( ! b )
1674                 return;
1675
1676         b->yy_n_chars = 0;
1677
1678         /* We always need two end-of-buffer characters.  The first causes
1679          * a transition to the end-of-buffer state.  The second causes
1680          * a jam in that state.
1681          */
1682         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1683         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1684
1685         b->yy_buf_pos = &b->yy_ch_buf[0];
1686
1687         b->yy_at_bol = 1;
1688         b->yy_buffer_status = YY_BUFFER_NEW;
1689
1690         if ( b == yy_current_buffer )
1691                 yy_load_buffer_state();
1692         }
1693
1694
1695 #ifndef YY_NO_SCAN_BUFFER
1696 #ifdef YY_USE_PROTOS
1697 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1698 #else
1699 YY_BUFFER_STATE yy_scan_buffer( base, size )
1700 char *base;
1701 yy_size_t size;
1702 #endif
1703         {
1704         YY_BUFFER_STATE b;
1705
1706         if ( size < 2 ||
1707              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1708              base[size-1] != YY_END_OF_BUFFER_CHAR )
1709                 /* They forgot to leave room for the EOB's. */
1710                 return 0;
1711
1712         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1713         if ( ! b )
1714                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1715
1716         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1717         b->yy_buf_pos = b->yy_ch_buf = base;
1718         b->yy_is_our_buffer = 0;
1719         b->yy_input_file = 0;
1720         b->yy_n_chars = b->yy_buf_size;
1721         b->yy_is_interactive = 0;
1722         b->yy_at_bol = 1;
1723         b->yy_fill_buffer = 0;
1724         b->yy_buffer_status = YY_BUFFER_NEW;
1725
1726         yy_switch_to_buffer( b );
1727
1728         return b;
1729         }
1730 #endif
1731
1732
1733 #ifndef YY_NO_SCAN_STRING
1734 #ifdef YY_USE_PROTOS
1735 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1736 #else
1737 YY_BUFFER_STATE yy_scan_string( yy_str )
1738 yyconst char *yy_str;
1739 #endif
1740         {
1741         int len;
1742         for ( len = 0; yy_str[len]; ++len )
1743                 ;
1744
1745         return yy_scan_bytes( yy_str, len );
1746         }
1747 #endif
1748
1749
1750 #ifndef YY_NO_SCAN_BYTES
1751 #ifdef YY_USE_PROTOS
1752 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1753 #else
1754 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1755 yyconst char *bytes;
1756 int len;
1757 #endif
1758         {
1759         YY_BUFFER_STATE b;
1760         char *buf;
1761         yy_size_t n;
1762         int i;
1763
1764         /* Get memory for full buffer, including space for trailing EOB's. */
1765         n = len + 2;
1766         buf = (char *) yy_flex_alloc( n );
1767         if ( ! buf )
1768                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1769
1770         for ( i = 0; i < len; ++i )
1771                 buf[i] = bytes[i];
1772
1773         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1774
1775         b = yy_scan_buffer( buf, n );
1776         if ( ! b )
1777                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1778
1779         /* It's okay to grow etc. this buffer, and we should throw it
1780          * away when we're done.
1781          */
1782         b->yy_is_our_buffer = 1;
1783
1784         return b;
1785         }
1786 #endif
1787
1788
1789 #ifndef YY_NO_PUSH_STATE
1790 #ifdef YY_USE_PROTOS
1791 static void yy_push_state( int new_state )
1792 #else
1793 static void yy_push_state( new_state )
1794 int new_state;
1795 #endif
1796         {
1797         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1798                 {
1799                 yy_size_t new_size;
1800
1801                 yy_start_stack_depth += YY_START_STACK_INCR;
1802                 new_size = yy_start_stack_depth * sizeof( int );
1803
1804                 if ( ! yy_start_stack )
1805                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1806
1807                 else
1808                         yy_start_stack = (int *) yy_flex_realloc(
1809                                         (void *) yy_start_stack, new_size );
1810
1811                 if ( ! yy_start_stack )
1812                         YY_FATAL_ERROR(
1813                         "out of memory expanding start-condition stack" );
1814                 }
1815
1816         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1817
1818         BEGIN(new_state);
1819         }
1820 #endif
1821
1822
1823 #ifndef YY_NO_POP_STATE
1824 static void yy_pop_state()
1825         {
1826         if ( --yy_start_stack_ptr < 0 )
1827                 YY_FATAL_ERROR( "start-condition stack underflow" );
1828
1829         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1830         }
1831 #endif
1832
1833
1834 #ifndef YY_NO_TOP_STATE
1835 static int yy_top_state()
1836         {
1837         return yy_start_stack[yy_start_stack_ptr - 1];
1838         }
1839 #endif
1840
1841 #ifndef YY_EXIT_FAILURE
1842 #define YY_EXIT_FAILURE 2
1843 #endif
1844
1845 #ifdef YY_USE_PROTOS
1846 static void yy_fatal_error( yyconst char msg[] )
1847 #else
1848 static void yy_fatal_error( msg )
1849 char msg[];
1850 #endif
1851         {
1852         (void) fprintf( stderr, "%s\n", msg );
1853         exit( YY_EXIT_FAILURE );
1854         }
1855
1856
1857
1858 /* Redefine yyless() so it works in section 3 code. */
1859
1860 #undef yyless
1861 #define yyless(n) \
1862         do \
1863                 { \
1864                 /* Undo effects of setting up yytext. */ \
1865                 yytext[yyleng] = yy_hold_char; \
1866                 yy_c_buf_p = yytext + n; \
1867                 yy_hold_char = *yy_c_buf_p; \
1868                 *yy_c_buf_p = '\0'; \
1869                 yyleng = n; \
1870                 } \
1871         while ( 0 )
1872
1873
1874 /* Internal utility routines. */
1875
1876 #ifndef yytext_ptr
1877 #ifdef YY_USE_PROTOS
1878 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1879 #else
1880 static void yy_flex_strncpy( s1, s2, n )
1881 char *s1;
1882 yyconst char *s2;
1883 int n;
1884 #endif
1885         {
1886         register int i;
1887         for ( i = 0; i < n; ++i )
1888                 s1[i] = s2[i];
1889         }
1890 #endif
1891
1892 #ifdef YY_NEED_STRLEN
1893 #ifdef YY_USE_PROTOS
1894 static int yy_flex_strlen( yyconst char *s )
1895 #else
1896 static int yy_flex_strlen( s )
1897 yyconst char *s;
1898 #endif
1899         {
1900         register int n;
1901         for ( n = 0; s[n]; ++n )
1902                 ;
1903
1904         return n;
1905         }
1906 #endif
1907
1908
1909 #ifdef YY_USE_PROTOS
1910 static void *yy_flex_alloc( yy_size_t size )
1911 #else
1912 static void *yy_flex_alloc( size )
1913 yy_size_t size;
1914 #endif
1915         {
1916         return (void *) malloc( size );
1917         }
1918
1919 #ifdef YY_USE_PROTOS
1920 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1921 #else
1922 static void *yy_flex_realloc( ptr, size )
1923 void *ptr;
1924 yy_size_t size;
1925 #endif
1926         {
1927         /* The cast to (char *) in the following accommodates both
1928          * implementations that use char* generic pointers, and those
1929          * that use void* generic pointers.  It works with the latter
1930          * because both ANSI C and C++ allow castless assignment from
1931          * any pointer type to void*, and deal with argument conversions
1932          * as though doing an assignment.
1933          */
1934         return (void *) realloc( (char *) ptr, size );
1935         }
1936
1937 #ifdef YY_USE_PROTOS
1938 static void yy_flex_free( void *ptr )
1939 #else
1940 static void yy_flex_free( ptr )
1941 void *ptr;
1942 #endif
1943         {
1944         free( ptr );
1945         }
1946
1947 #if YY_MAIN
1948 int main()
1949         {
1950         yylex();
1951         return 0;
1952         }
1953 #endif
1954 #line 244 "ssl_expr_scan.l"
1955
1956
1957 int yyinput(char *buf, int max_size)
1958 {
1959     int n;
1960
1961     if ((n = MIN(max_size, ssl_expr_info.inputbuf
1962                          + ssl_expr_info.inputlen
1963                          - ssl_expr_info.inputptr)) <= 0)
1964         return YY_NULL;
1965     memcpy(buf, ssl_expr_info.inputptr, n);
1966     ssl_expr_info.inputptr += n;
1967     return n;
1968 }
1969