/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, * if you want the limit (max/min) macros for int types.
*/ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 #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) ((unsignedint) (unsignedchar) c)
/* For convenience, these vars (plus the bison vars far below)
are macros in the reentrant scanner. */ #define yyin yyg->yyin_r #define yyout yyg->yyout_r #define yyextra yyg->yyextra_r #define yyleng yyg->yyleng_r #define yytext yyg->yytext_r #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) #define yy_flex_debug yyg->yy_flex_debug_r
/* 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 yyg->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 ((yyg->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 ap_expr_yyrestart(yyin ,yyscanner )
#define YY_END_OF_BUFFER_CHAR 0
/* Size of default input buffer. */ #ifndef YY_BUF_SIZE #ifdef __ia64__ /* On IA-64, the buffer size is 16k, not 8k. * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. * Ditto for the __ia64__ case accordingly.
*/ #define YY_BUF_SIZE 32768 #else #define YY_BUF_SIZE 16384 #endif/* __ia64__ */ #endif
/* The state buf must be large enough to hold one state per character in the main buffer.
*/ #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
/* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \
{ \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
*yy_cp = yyg->yy_hold_char; \
YY_RESTORE_YY_MORE_OFFSET \
yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \ while ( 0 )
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;
int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */
/* 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 ap_expr_yyrestart()), so that the user can continue scanning by * just pointing yyin at a new input file.
*/ #define YY_BUFFER_EOF_PENDING 2
}; #endif/* !YY_STRUCT_YY_BUFFER_STATE */
/* 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". * * Returns the top of the stack, or NULL.
*/ #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
: NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only.
*/ #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
/* Done after the current pattern has been matched and before the * corresponding action - sets up yytext.
*/ #define YY_DO_BEFORE_ACTION \
yyg->yytext_ptr = yy_bp; \
yyleng = (size_t) (yy_cp - yy_bp); \
yyg->yy_hold_char = *yy_cp; \
*yy_cp = '\0'; \
yyg->yy_c_buf_p = yy_cp;
/* 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 #line 1 "util_expr_scan.l" /* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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.
*/ /* * ap_expr_scan.l, based on ssl_expr_scan.l from mod_ssl
*/ /* _________________________________________________________________ ** ** Expression Scanner ** _________________________________________________________________
*/ #define YY_NO_INPUT 1
#ifndef YY_NO_UNISTD_H /* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option.
*/ #include <unistd.h> #endif
/* Holds the entire state of the reentrant scanner. */ struct yyguts_t
{
/* User-defined. Not touched by flex. */
YY_EXTRA_TYPE yyextra_r;
/* The rest are the same as the globals declared in the non-reentrant scanner. */
FILE *yyin_r, *yyout_r;
size_t yy_buffer_stack_top; /**< index of top of stack. */
size_t yy_buffer_stack_max; /**< capacity of stack. */
YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ char yy_hold_char; int yy_n_chars; int yyleng_r; char *yy_c_buf_p; int yy_init; int yy_start; int yy_did_buffer_switch_on_eof; int yy_start_stack_ptr; int yy_start_stack_depth; int *yy_start_stack;
yy_state_type yy_last_accepting_state; char* yy_last_accepting_cpos;
int yylineno_r; int yy_flex_debug_r;
char *yytext_r; int yy_more_flag; int yy_more_len;
YYSTYPE * yylval_r;
}; /* end struct yyguts_t */
staticint yy_init_globals (yyscan_t yyscanner );
/* This must go here because YYSTYPE and YYLTYPE are included
* from bison output in section 1.*/ # define yylval yyg->yylval_r
int ap_expr_yylex_init (yyscan_t* scanner);
int ap_expr_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
/* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */
/* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #ifdef __ia64__ /* On IA-64, the buffer size is 16k, not 8k */ #define YY_READ_BUF_SIZE 16384 #else #define YY_READ_BUF_SIZE 8192 #endif/* __ia64__ */ #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 do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) #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_LVALUE->yy_is_interactive ) \
{ \ int c = '*'; \
size_t 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 \
{ \
errno=0; \ while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
{ \ if( errno != EINTR) \
{ \
YY_FATAL_ERROR( "input in flex scanner failed" ); \ break; \
} \
errno=0; \
clearerr(yyin); \
} \
}\
\
#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
/* 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
/** The main scanner function which does all the work.
*/
YY_DECL
{ register yy_state_type yy_current_state; registerchar *yy_cp, *yy_bp; registerint yy_act; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
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 = yyg->yy_hold_char;
yy_cp = yyg->yy_last_accepting_cpos;
yy_current_state = yyg->yy_last_accepting_state; goto yy_find_action;
case 1: /* rule 1 can match eol */
YY_RULE_SETUP #line 103 "util_expr_scan.l"
{ /* NOP */
}
YY_BREAK /* * strings ("..." and '...')
*/ case 2:
YY_RULE_SETUP #line 110 "util_expr_scan.l"
{
str_ptr = str_buf;
str_del = yytext[0];
BEGIN(str); return T_STR_BEGIN;
}
YY_BREAK case 3:
YY_RULE_SETUP #line 116 "util_expr_scan.l"
{ if (yytext[0] == str_del) { if (YY_START == var) {
PERROR("Unterminated variable in string");
} elseif (str_ptr == str_buf) {
BEGIN(INITIAL); return T_STR_END;
} else { /* return what we have so far and scan delimiter again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
yyless(0);
str_ptr = str_buf; return T_STRING;
}
} else {
STR_APPEND(yytext[0]);
}
}
YY_BREAK case 4: /* rule 4 can match eol */
YY_RULE_SETUP #line 138 "util_expr_scan.l"
{
PERROR("Unterminated string or variable");
}
YY_BREAK case YY_STATE_EOF(var): case YY_STATE_EOF(vararg): #line 141 "util_expr_scan.l"
{
PERROR("Unterminated string or variable");
}
YY_BREAK case YY_STATE_EOF(str): #line 144 "util_expr_scan.l"
{ if (!(yyextra->flags & AP_EXPR_FLAG_STRING_RESULT)) {
PERROR("Unterminated string or variable");
} else {
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
str_ptr = str_buf;
BEGIN(INITIAL); return T_STRING;
}
}
YY_BREAK case 5:
YY_RULE_SETUP #line 157 "util_expr_scan.l"
{ int result;
(void)sscanf(yytext+1, "%o", &result); if (result > 0xff) {
PERROR("Escape sequence out of bound");
} else {
STR_APPEND(result);
}
}
YY_BREAK case 6:
YY_RULE_SETUP #line 168 "util_expr_scan.l"
{
PERROR("Bad escape sequence");
}
YY_BREAK case 7:
YY_RULE_SETUP #line 171 "util_expr_scan.l"
{ STR_APPEND('\n'); }
YY_BREAK case 8:
YY_RULE_SETUP #line 172 "util_expr_scan.l"
{ STR_APPEND('\r'); }
YY_BREAK case 9:
YY_RULE_SETUP #line 173 "util_expr_scan.l"
{ STR_APPEND('\t'); }
YY_BREAK case 10:
YY_RULE_SETUP #line 174 "util_expr_scan.l"
{ STR_APPEND('\b'); }
YY_BREAK case 11:
YY_RULE_SETUP #line 175 "util_expr_scan.l"
{ STR_APPEND('\f'); }
YY_BREAK case 12: /* rule 12 can match eol */
YY_RULE_SETUP #line 176 "util_expr_scan.l"
{ STR_APPEND(yytext[1]); }
YY_BREAK /* regexp backref inside string/arg */ case 13:
YY_RULE_SETUP #line 179 "util_expr_scan.l"
{ if (str_ptr != str_buf) { /* return what we have so far and scan '$x' again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
str_ptr = str_buf;
yyless(0); return T_STRING;
} else {
yylval->num = yytext[1] - '0'; return T_REGEX_BACKREF;
}
}
YY_BREAK case 14:
YY_RULE_SETUP #line 194 "util_expr_scan.l"
{ char *cp = yytext; while (*cp != '\0') {
STR_APPEND(*cp);
cp++;
}
}
YY_BREAK /* variable inside string/arg */ case 15:
YY_RULE_SETUP #line 203 "util_expr_scan.l"
{ if (str_ptr != str_buf) { /* return what we have so far and scan '%{' again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
yyless(0);
str_ptr = str_buf; return T_STRING;
} else {
yy_push_state(var, yyscanner); return T_VAR_BEGIN;
}
}
YY_BREAK case 16:
YY_RULE_SETUP #line 218 "util_expr_scan.l"
{
STR_APPEND(yytext[0]);
}
YY_BREAK case 17:
YY_RULE_SETUP #line 222 "util_expr_scan.l"
{
STR_APPEND(yytext[0]);
}
YY_BREAK case 18:
YY_RULE_SETUP #line 226 "util_expr_scan.l"
{
yy_push_state(var, yyscanner); return T_VAR_BEGIN;
}
YY_BREAK case 19:
YY_RULE_SETUP #line 231 "util_expr_scan.l"
{
yylval->num = yytext[1] - '0'; return T_REGEX_BACKREF;
}
YY_BREAK /* * fixed name variable expansion %{XXX} and function call in %{func:arg} syntax
*/ case 20:
YY_RULE_SETUP #line 239 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); return T_ID;
}
YY_BREAK case 21:
YY_RULE_SETUP #line 244 "util_expr_scan.l"
{
yy_pop_state(yyscanner); return T_VAR_END;
}
YY_BREAK case 22:
YY_RULE_SETUP #line 249 "util_expr_scan.l"
{
BEGIN(vararg); return yytext[0];
}
YY_BREAK case 23: /* rule 23 can match eol */
YY_RULE_SETUP #line 254 "util_expr_scan.l"
{ char *msg = apr_psprintf(yyextra->pool, "Invalid character in variable name '%c'", yytext[0]);
PERROR(msg);
}
YY_BREAK case 24:
YY_RULE_SETUP #line 260 "util_expr_scan.l"
{ if (str_ptr != str_buf) { /* return what we have so far and scan '}' again */
*str_ptr = '\0';
yylval->cpVal = apr_pstrdup(yyextra->pool, str_buf);
str_ptr = str_buf;
yyless(0); return T_STRING;
} else {
yy_pop_state(yyscanner); return T_VAR_END;
}
}
YY_BREAK /* * Regular Expression
*/ case 25:
YY_RULE_SETUP #line 278 "util_expr_scan.l"
{
regex_del = yytext[1];
regex_ptr = regex_buf;
BEGIN(regex);
}
YY_BREAK case 26:
YY_RULE_SETUP #line 283 "util_expr_scan.l"
{
regex_del = yytext[0];
regex_ptr = regex_buf;
BEGIN(regex);
}
YY_BREAK case 27: /* rule 27 can match eol */
YY_RULE_SETUP #line 288 "util_expr_scan.l"
{ if (yytext[0] == regex_del) {
*regex_ptr = '\0';
BEGIN(regex_flags);
} else {
*regex_ptr++ = yytext[0]; if (regex_ptr >= regex_buf + sizeof(regex_buf))
PERROR("Regexp too long");
}
}
YY_BREAK case 28:
YY_RULE_SETUP #line 299 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, regex_buf);
BEGIN(INITIAL); return T_REGEX_I;
}
YY_BREAK case 29: /* rule 29 can match eol */
YY_RULE_SETUP #line 304 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, regex_buf);
yyless(0);
BEGIN(INITIAL); return T_REGEX;
}
YY_BREAK case YY_STATE_EOF(regex_flags): #line 310 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, regex_buf);
BEGIN(INITIAL); return T_REGEX;
}
YY_BREAK /* * Operators
*/ case 30:
YY_RULE_SETUP #line 319 "util_expr_scan.l"
{ return T_OP_STR_EQ; }
YY_BREAK case 31:
YY_RULE_SETUP #line 320 "util_expr_scan.l"
{ return T_OP_STR_NE; }
YY_BREAK case 32:
YY_RULE_SETUP #line 321 "util_expr_scan.l"
{ return T_OP_STR_LT; }
YY_BREAK case 33:
YY_RULE_SETUP #line 322 "util_expr_scan.l"
{ return T_OP_STR_LE; }
YY_BREAK case 34:
YY_RULE_SETUP #line 323 "util_expr_scan.l"
{ return T_OP_STR_GT; }
YY_BREAK case 35:
YY_RULE_SETUP #line 324 "util_expr_scan.l"
{ return T_OP_STR_GE; }
YY_BREAK case 36:
YY_RULE_SETUP #line 325 "util_expr_scan.l"
{ return T_OP_REG; }
YY_BREAK case 37:
YY_RULE_SETUP #line 326 "util_expr_scan.l"
{ return T_OP_NRE; }
YY_BREAK case 38:
YY_RULE_SETUP #line 327 "util_expr_scan.l"
{ return T_OP_AND; }
YY_BREAK case 39:
YY_RULE_SETUP #line 328 "util_expr_scan.l"
{ return T_OP_AND; }
YY_BREAK case 40:
YY_RULE_SETUP #line 329 "util_expr_scan.l"
{ return T_OP_OR; }
YY_BREAK case 41:
YY_RULE_SETUP #line 330 "util_expr_scan.l"
{ return T_OP_OR; }
YY_BREAK case 42:
YY_RULE_SETUP #line 331 "util_expr_scan.l"
{ return T_OP_NOT; }
YY_BREAK case 43:
YY_RULE_SETUP #line 332 "util_expr_scan.l"
{ return T_OP_NOT; }
YY_BREAK case 44:
YY_RULE_SETUP #line 333 "util_expr_scan.l"
{ return T_OP_CONCAT; }
YY_BREAK case 45:
YY_RULE_SETUP #line 334 "util_expr_scan.l"
{ return T_OP_IN; }
YY_BREAK case 46:
YY_RULE_SETUP #line 335 "util_expr_scan.l"
{ return T_OP_EQ; }
YY_BREAK case 47:
YY_RULE_SETUP #line 336 "util_expr_scan.l"
{ return T_OP_NE; }
YY_BREAK case 48:
YY_RULE_SETUP #line 337 "util_expr_scan.l"
{ return T_OP_GE; }
YY_BREAK case 49:
YY_RULE_SETUP #line 338 "util_expr_scan.l"
{ return T_OP_LE; }
YY_BREAK case 50:
YY_RULE_SETUP #line 339 "util_expr_scan.l"
{ return T_OP_GT; }
YY_BREAK case 51:
YY_RULE_SETUP #line 340 "util_expr_scan.l"
{ return T_OP_LT; }
YY_BREAK /* for compatibility with ssl_expr */ case 52:
YY_RULE_SETUP #line 343 "util_expr_scan.l"
{ return T_OP_LT; }
YY_BREAK case 53:
YY_RULE_SETUP #line 344 "util_expr_scan.l"
{ return T_OP_LE; }
YY_BREAK case 54:
YY_RULE_SETUP #line 345 "util_expr_scan.l"
{ return T_OP_GT; }
YY_BREAK case 55:
YY_RULE_SETUP #line 346 "util_expr_scan.l"
{ return T_OP_GE; }
YY_BREAK case 56:
YY_RULE_SETUP #line 347 "util_expr_scan.l"
{ return T_OP_NE; }
YY_BREAK case 57:
YY_RULE_SETUP #line 348 "util_expr_scan.l"
{ return T_OP_EQ; }
YY_BREAK case 58:
YY_RULE_SETUP #line 349 "util_expr_scan.l"
{ return T_OP_IN; }
YY_BREAK case 59:
YY_RULE_SETUP #line 351 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); return T_OP_UNARY;
}
YY_BREAK case 60:
YY_RULE_SETUP #line 356 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext + 1); return T_OP_BINARY;
}
YY_BREAK /* * Specials
*/ case 61:
YY_RULE_SETUP #line 364 "util_expr_scan.l"
{ return T_TRUE; }
YY_BREAK case 62:
YY_RULE_SETUP #line 365 "util_expr_scan.l"
{ return T_FALSE; }
YY_BREAK /* * Digits
*/ case 63:
YY_RULE_SETUP #line 370 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); return T_DIGIT;
}
YY_BREAK /* * Identifiers
*/ case 64:
YY_RULE_SETUP #line 378 "util_expr_scan.l"
{
yylval->cpVal = apr_pstrdup(yyextra->pool, yytext); return T_ID;
}
YY_BREAK /* * These are parts of the grammar and are returned as is
*/ case 65:
YY_RULE_SETUP #line 386 "util_expr_scan.l"
{ return yytext[0];
}
YY_BREAK /* * Anything else is an error
*/ case 66: /* rule 66 can match eol */
YY_RULE_SETUP #line 393 "util_expr_scan.l"
{ char *msg = apr_psprintf(yyextra->pool, "Parse error near '%c'", yytext[0]);
PERROR(msg);
}
YY_BREAK case 67:
YY_RULE_SETUP #line 398 "util_expr_scan.l"
YY_FATAL_ERROR( "flex scanner jammed" );
YY_BREAK #line 1523 "util_expr_scan.c" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(regex):
yyterminate();
case YY_END_OF_BUFFER:
{ /* Amount of text matched not including the EOB char. */ int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
/* Undo the effects of YY_DO_BEFORE_ACTION. */
*yy_cp = yyg->yy_hold_char;
YY_RESTORE_YY_MORE_OFFSET
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
{ /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * ap_expr_yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source.
*/
yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
}
/* Note that here we test for yy_c_buf_p "<=" to the position * of the first EOB in the buffer, since yy_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input().
*/ if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
{ /* This was really a NUL. */
yy_state_type yy_next_state;
/* Okay, we're now positioned to make the NUL * transition. We couldn't have * yy_get_previous_state() go ahead and do it * for us because it doesn't know how to deal * with the possibility of jamming (and we don't * want to build jamming into it because then it * will run more slowly).
*/
if ( ap_expr_yywrap(yyscanner ) )
{ /* Note: because we've taken care in * yy_get_next_buffer() to have set up * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the * YY_NULL, it'll still work - another * YY_NULL will get returned.
*/
yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
default:
YY_FATAL_ERROR( "fatal flex scanner internal error--no action found" );
} /* end of action switch */
} /* end of scanning one token */
} /* end of ap_expr_yylex */
/* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file
*/ staticint yy_get_next_buffer (yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; registerchar *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; registerchar *source = yyg->yytext_ptr; registerint number_to_move, i; int ret_val;
if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" );
if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
{ /* Don't try to fill the buffer, so this is an EOF. */ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
{ /* We matched a single character, the EOB, so * treat this as a final EOF.
*/ return EOB_ACT_END_OF_FILE;
}
else
{ /* We matched some text prior to the EOB, first * process it.
*/ return EOB_ACT_LAST_MATCH;
}
}
/* Try to read more data. */
/* First move last chars to start of buffer. */
number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF
*/
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
else
{ int num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
{ /* Not enough room in the buffer - grow it. */
/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
int yy_c_buf_p_offset =
(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
if ( b->yy_is_our_buffer )
{ int new_size = b->yy_buf_size * 2;
/* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = yy_try_NUL_trans( current_state );
*/ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
{ registerint yy_is_jam; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ registerchar *yy_cp = yyg->yy_c_buf_p;
{ int c; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
*yyg->yy_c_buf_p = yyg->yy_hold_char;
if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
{ /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer.
*/ if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) /* This was really a NUL. */
*yyg->yy_c_buf_p = '\0';
else
{ /* need more input */ int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
++yyg->yy_c_buf_p;
switch ( yy_get_next_buffer( yyscanner ) )
{ case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE.
*/
/** Immediately switch to a different input stream. * @param input_file A readable stream. * @param yyscanner The scanner object. * @note This function does not reset the start condition to @c INITIAL .
*/ void ap_expr_yyrestart (FILE * input_file , yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
/** Switch to a different input buffer. * @param new_buffer The new input buffer. * @param yyscanner The scanner object.
*/ void ap_expr_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
/* TODO. We should be able to replace this entire function body * with * ap_expr_yypop_buffer_state(); * ap_expr_yypush_buffer_state(new_buffer);
*/
ap_expr_yyensure_buffer_stack (yyscanner); if ( YY_CURRENT_BUFFER == new_buffer ) return;
if ( YY_CURRENT_BUFFER )
{ /* Flush out information for old buffer. */
*yyg->yy_c_buf_p = yyg->yy_hold_char;
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
}
/* We don't actually know whether we did this switch during * EOF (ap_expr_yywrap()) processing, but the only time this flag * is looked at is after ap_expr_yywrap() is called, so it's safe * to go ahead and always set it.
*/
yyg->yy_did_buffer_switch_on_eof = 1;
}
/** Allocate and initialize an input buffer state. * @param file A readable stream. * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. * @param yyscanner The scanner object. * @return the allocated buffer state.
*/
YY_BUFFER_STATE ap_expr_yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) ap_expr_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters.
*/
b->yy_ch_buf = (char *) ap_expr_yyalloc(b->yy_buf_size + 2 ,yyscanner ); if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yy_create_buffer()" );
b->yy_is_our_buffer = 1;
ap_expr_yy_init_buffer(b,file ,yyscanner);
return b;
}
/** Destroy the buffer. * @param b a buffer created with ap_expr_yy_create_buffer() * @param yyscanner The scanner object.
*/ void ap_expr_yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if ( ! b ) return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
ap_expr_yyfree((void *) b->yy_ch_buf ,yyscanner );
ap_expr_yyfree((void *) b ,yyscanner );
}
/* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a ap_expr_yyrestart() or at EOF.
*/ staticvoid ap_expr_yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
/* If b is the current buffer, then ap_expr_yy_init_buffer was _probably_ * called from ap_expr_yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column.
*/ if (b != YY_CURRENT_BUFFER){
b->yy_bs_lineno = 1;
b->yy_bs_column = 0;
}
b->yy_is_interactive = 0;
errno = oerrno;
}
/** Discard all buffered characters. On the next scan, YY_INPUT will be called. * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * @param yyscanner The scanner object.
*/ void ap_expr_yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if ( ! b ) return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
if ( b == YY_CURRENT_BUFFER )
ap_expr_yy_load_buffer_state(yyscanner );
}
/** Pushes the new state onto the stack. The new state becomes * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. * @param yyscanner The scanner object.
*/ void ap_expr_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (new_buffer == NULL) return;
ap_expr_yyensure_buffer_stack(yyscanner);
/* This block is copied from ap_expr_yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER )
{ /* Flush out information for old buffer. */
*yyg->yy_c_buf_p = yyg->yy_hold_char;
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
}
/* Only push if top exists. Otherwise, replace top. */ if (YY_CURRENT_BUFFER)
yyg->yy_buffer_stack_top++;
YY_CURRENT_BUFFER_LVALUE = new_buffer;
/** Removes and deletes the top of the stack, if present. * The next element becomes the new top. * @param yyscanner The scanner object.
*/ void ap_expr_yypop_buffer_state (yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; if (!YY_CURRENT_BUFFER) return;
ap_expr_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
YY_CURRENT_BUFFER_LVALUE = NULL; if (yyg->yy_buffer_stack_top > 0)
--yyg->yy_buffer_stack_top;
if (YY_CURRENT_BUFFER) {
ap_expr_yy_load_buffer_state(yyscanner );
yyg->yy_did_buffer_switch_on_eof = 1;
}
}
/* Allocates the stack if it does not exist. * Guarantees space for at least one push.
*/ staticvoid ap_expr_yyensure_buffer_stack (yyscan_t yyscanner)
{ int num_to_alloc; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (!yyg->yy_buffer_stack) {
/* First allocation is just for 2 elements, since we don't know if this * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call.
*/
num_to_alloc = 1;
yyg->yy_buffer_stack = (struct yy_buffer_state**)ap_expr_yyalloc
(num_to_alloc * sizeof(struct yy_buffer_state*)
, yyscanner); if ( ! yyg->yy_buffer_stack )
YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yyensure_buffer_stack()" );
if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
/* Increase the buffer to prepare for a possible push. */ int grow_size = 8 /* arbitrary grow size */;
num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
yyg->yy_buffer_stack = (struct yy_buffer_state**)ap_expr_yyrealloc
(yyg->yy_buffer_stack,
num_to_alloc * sizeof(struct yy_buffer_state*)
, yyscanner); if ( ! yyg->yy_buffer_stack )
YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yyensure_buffer_stack()" );
/* zero only the new slots.*/
memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
yyg->yy_buffer_stack_max = num_to_alloc;
}
}
/** Setup the input buffer state to scan directly from a user-specified character buffer. * @param base the character buffer * @param size the size in bytes of the character buffer * @param yyscanner The scanner object. * @return the newly allocated buffer state object.
*/
YY_BUFFER_STATE ap_expr_yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
if ( size < 2 ||
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return 0;
b = (YY_BUFFER_STATE) ap_expr_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner ); if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yy_scan_buffer()" );
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
b->yy_buf_pos = b->yy_ch_buf = base;
b->yy_is_our_buffer = 0;
b->yy_input_file = 0;
b->yy_n_chars = b->yy_buf_size;
b->yy_is_interactive = 0;
b->yy_at_bol = 1;
b->yy_fill_buffer = 0;
b->yy_buffer_status = YY_BUFFER_NEW;
ap_expr_yy_switch_to_buffer(b ,yyscanner );
return b;
}
/** Setup the input buffer state to scan a string. The next call to ap_expr_yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * @param yyscanner The scanner object. * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use * ap_expr_yy_scan_bytes() instead.
*/
YY_BUFFER_STATE ap_expr_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
{
/** Setup the input buffer state to scan the given bytes. The next call to ap_expr_yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * @param yyscanner The scanner object. * @return the newly allocated buffer state object.
*/
YY_BUFFER_STATE ap_expr_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
{
YY_BUFFER_STATE b; char *buf;
yy_size_t n; int i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = _yybytes_len + 2;
buf = (char *) ap_expr_yyalloc(n ,yyscanner ); if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in ap_expr_yy_scan_bytes()" );
for ( i = 0; i < _yybytes_len; ++i )
buf[i] = yybytes[i];
/* Accessor methods (get/set functions) to struct members. */
/** Get the user-defined data for this scanner. * @param yyscanner The scanner object.
*/
YY_EXTRA_TYPE ap_expr_yyget_extra (yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; return yyextra;
}
/** Get the current line number. * @param yyscanner The scanner object.
*/ int ap_expr_yyget_lineno (yyscan_t yyscanner)
{ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (! YY_CURRENT_BUFFER)
--> --------------------
--> maximum size reached
--> --------------------
¤ Dauer der Verarbeitung: 0.30 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
