main/ast_expr2f.c

   1 #line 2 "ast_expr2f.c"
   2
   3 #line 4 "ast_expr2f.c"
   4
   5 #define  YY_INT_ALIGNED short int
   6
   7 /* A lexical scanner generated by flex */
   8
   9 #define FLEX_SCANNER
  10 #define YY_FLEX_MAJOR_VERSION 2
  11 #define YY_FLEX_MINOR_VERSION 5
  12 #define YY_FLEX_SUBMINOR_VERSION 33
  13 #if YY_FLEX_SUBMINOR_VERSION > 0
  14 #define FLEX_BETA
  15 #endif
  16
  17 /* First, we deal with  platform-specific or compiler-specific issues. */
  18
  19 /* begin standard C headers. */
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <stdlib.h>
  24
  25 /* end standard C headers. */
  26
  27 /* flex integer type definitions */
  28
  29 #ifndef FLEXINT_H
  30 #define FLEXINT_H
  31
  32 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  33
  34 #if !defined __STDC_VERSION__ || __STDC_VERSION__ >= 199901L
  35
  36 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  37  * if you want the limit (max/min) macros for int types.
  38  */
  39 #ifndef __STDC_LIMIT_MACROS
  40 #define __STDC_LIMIT_MACROS 1
  41 #endif
  42
  43 #include <inttypes.h>
  44 typedef int8_t flex_int8_t;
  45 typedef uint8_t flex_uint8_t;
  46 typedef int16_t flex_int16_t;
  47 typedef uint16_t flex_uint16_t;
  48 typedef int32_t flex_int32_t;
  49 typedef uint32_t flex_uint32_t;
  50 #else
  51 typedef signed char flex_int8_t;
  52 typedef short int flex_int16_t;
  53 typedef int flex_int32_t;
  54 typedef unsigned char flex_uint8_t;
  55 typedef unsigned short int flex_uint16_t;
  56 typedef unsigned int flex_uint32_t;
  57 #endif /* ! C99 */
  58
  59 /* Limits of integral types. */
  60 #ifndef INT8_MIN
  61 #define INT8_MIN               (-128)
  62 #endif
  63 #ifndef INT16_MIN
  64 #define INT16_MIN              (-32767-1)
  65 #endif
  66 #ifndef INT32_MIN
  67 #define INT32_MIN              (-2147483647-1)
  68 #endif
  69 #ifndef INT8_MAX
  70 #define INT8_MAX               (127)
  71 #endif
  72 #ifndef INT16_MAX
  73 #define INT16_MAX              (32767)
  74 #endif
  75 #ifndef INT32_MAX
  76 #define INT32_MAX              (2147483647)
  77 #endif
  78 #ifndef UINT8_MAX
  79 #define UINT8_MAX              (255U)
  80 #endif
  81 #ifndef UINT16_MAX
  82 #define UINT16_MAX             (65535U)
  83 #endif
  84 #ifndef UINT32_MAX
  85 #define UINT32_MAX             (4294967295U)
  86 #endif
  87
  88 #endif /* ! FLEXINT_H */
  89
  90 #ifdef __cplusplus
  91
  92 /* The "const" storage-class-modifier is valid. */
  93 #define YY_USE_CONST
  94
  95 #else   /* ! __cplusplus */
  96
  97 #if __STDC__
  98
  99 #define YY_USE_CONST
 100
 101 #endif  /* __STDC__ */
 102 #endif  /* ! __cplusplus */
 103
 104 #ifdef YY_USE_CONST
 105 #define yyconst const
 106 #else
 107 #define yyconst
 108 #endif
 109
 110 /* Returned upon end-of-file. */
 111 #define YY_NULL 0
 112
 113 /* Promotes a possibly negative, possibly signed char to an unsigned
 114  * integer for use as an array index.  If the signed char is negative,
 115  * we want to instead treat it as an 8-bit unsigned char, hence the
 116  * double cast.
 117  */
 118 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 119
 120 /* An opaque pointer. */
 121 #ifndef YY_TYPEDEF_YY_SCANNER_T
 122 #define YY_TYPEDEF_YY_SCANNER_T
 123 typedef void* yyscan_t;
 124 #endif
 125
 126 /* For convenience, these vars (plus the bison vars far below)
 127    are macros in the reentrant scanner. */
 128 #define yyin yyg->yyin_r
 129 #define yyout yyg->yyout_r
 130 #define yyextra yyg->yyextra_r
 131 #define yyleng yyg->yyleng_r
 132 #define yytext yyg->yytext_r
 133 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
 134 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
 135 #define yy_flex_debug yyg->yy_flex_debug_r
 136
 137 int ast_yylex_init (yyscan_t* scanner);
 138
 139 /* Enter a start condition.  This macro really ought to take a parameter,
 140  * but we do it the disgusting crufty way forced on us by the ()-less
 141  * definition of BEGIN.
 142  */
 143 #define BEGIN yyg->yy_start = 1 + 2 *
 144
 145 /* Translate the current start state into a value that can be later handed
 146  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 147  * compatibility.
 148  */
 149 #define YY_START ((yyg->yy_start - 1) / 2)
 150 #define YYSTATE YY_START
 151
 152 /* Action number for EOF rule of a given start state. */
 153 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 154
 155 /* Special action meaning "start processing a new file". */
 156 #define YY_NEW_FILE ast_yyrestart(yyin ,yyscanner )
 157
 158 #define YY_END_OF_BUFFER_CHAR 0
 159
 160 /* Size of default input buffer. */
 161 #ifndef YY_BUF_SIZE
 162 #define YY_BUF_SIZE 16384
 163 #endif
 164
 165 /* The state buf must be large enough to hold one state per character in the main buffer.
 166  */
 167 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 168
 169 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 170 #define YY_TYPEDEF_YY_BUFFER_STATE
 171 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 172 #endif
 173
 174 #define EOB_ACT_CONTINUE_SCAN 0
 175 #define EOB_ACT_END_OF_FILE 1
 176 #define EOB_ACT_LAST_MATCH 2
 177
 178     #define YY_LESS_LINENO(n)
 179
 180 /* Return all but the first "n" matched characters back to the input stream. */
 181 #define yyless(n) \
 182         do \
 183                 { \
 184                 /* Undo effects of setting up yytext. */ \
 185         int yyless_macro_arg = (n); \
 186         YY_LESS_LINENO(yyless_macro_arg);\
 187                 *yy_cp = yyg->yy_hold_char; \
 188                 YY_RESTORE_YY_MORE_OFFSET \
 189                 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 190                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 191                 } \
 192         while ( 0 )
 193
 194 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 195
 196 /* The following is because we cannot portably get our hands on size_t
 197  * (without autoconf's help, which isn't available because we want
 198  * flex-generated scanners to compile on their own).
 199  */
 200
 201 #ifndef YY_TYPEDEF_YY_SIZE_T
 202 #define YY_TYPEDEF_YY_SIZE_T
 203 typedef unsigned int yy_size_t;
 204 #endif
 205
 206 #ifndef YY_STRUCT_YY_BUFFER_STATE
 207 #define YY_STRUCT_YY_BUFFER_STATE
 208 struct yy_buffer_state
 209         {
 210         FILE *yy_input_file;
 211
 212         char *yy_ch_buf;                /* input buffer */
 213         char *yy_buf_pos;               /* current position in input buffer */
 214
 215         /* Size of input buffer in bytes, not including room for EOB
 216          * characters.
 217          */
 218         yy_size_t yy_buf_size;
 219
 220         /* Number of characters read into yy_ch_buf, not including EOB
 221          * characters.
 222          */
 223         int yy_n_chars;
 224
 225         /* Whether we "own" the buffer - i.e., we know we created it,
 226          * and can realloc() it to grow it, and should free() it to
 227          * delete it.
 228          */
 229         int yy_is_our_buffer;
 230
 231         /* Whether this is an "interactive" input source; if so, and
 232          * if we're using stdio for input, then we want to use getc()
 233          * instead of fread(), to make sure we stop fetching input after
 234          * each newline.
 235          */
 236         int yy_is_interactive;
 237
 238         /* Whether we're considered to be at the beginning of a line.
 239          * If so, '^' rules will be active on the next match, otherwise
 240          * not.
 241          */
 242         int yy_at_bol;
 243
 244     int yy_bs_lineno; /**< The line count. */
 245     int yy_bs_column; /**< The column count. */
 246
 247         /* Whether to try to fill the input buffer when we reach the
 248          * end of it.
 249          */
 250         int yy_fill_buffer;
 251
 252         int yy_buffer_status;
 253
 254 #define YY_BUFFER_NEW 0
 255 #define YY_BUFFER_NORMAL 1
 256         /* When an EOF's been seen but there's still some text to process
 257          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 258          * shouldn't try reading from the input source any more.  We might
 259          * still have a bunch of tokens to match, though, because of
 260          * possible backing-up.
 261          *
 262          * When we actually see the EOF, we change the status to "new"
 263          * (via ast_yyrestart()), so that the user can continue scanning by
 264          * just pointing yyin at a new input file.
 265          */
 266 #define YY_BUFFER_EOF_PENDING 2
 267
 268         };
 269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 270
 271 /* We provide macros for accessing buffer states in case in the
 272  * future we want to put the buffer states in a more general
 273  * "scanner state".
 274  *
 275  * Returns the top of the stack, or NULL.
 276  */
 277 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
 278                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
 279                           : NULL)
 280
 281 /* Same as previous macro, but useful when we know that the buffer stack is not
 282  * NULL or when we need an lvalue. For internal use only.
 283  */
 284 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
 285
 286 void ast_yyrestart (FILE *input_file ,yyscan_t yyscanner );
 287 void ast_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 288 YY_BUFFER_STATE ast_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
 289 void ast_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 290 void ast_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 291 void ast_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 292 void ast_yypop_buffer_state (yyscan_t yyscanner );
 293
 294 static void ast_yyensure_buffer_stack (yyscan_t yyscanner );
 295 static void ast_yy_load_buffer_state (yyscan_t yyscanner );
 296 static void ast_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
 297
 298 #define YY_FLUSH_BUFFER ast_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
 299
 300 YY_BUFFER_STATE ast_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 301 YY_BUFFER_STATE ast_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
 302 YY_BUFFER_STATE ast_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 303
 304 void *ast_yyalloc (yy_size_t ,yyscan_t yyscanner );
 305 void *ast_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
 306 void ast_yyfree (void * ,yyscan_t yyscanner );
 307
 308 #define yy_new_buffer ast_yy_create_buffer
 309
 310 #define yy_set_interactive(is_interactive) \
 311         { \
 312         if ( ! YY_CURRENT_BUFFER ){ \
 313         ast_yyensure_buffer_stack (yyscanner); \
 314                 YY_CURRENT_BUFFER_LVALUE =    \
 315             ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 316         } \
 317         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 318         }
 319
 320 #define yy_set_bol(at_bol) \
 321         { \
 322         if ( ! YY_CURRENT_BUFFER ){\
 323         ast_yyensure_buffer_stack (yyscanner); \
 324                 YY_CURRENT_BUFFER_LVALUE =    \
 325             ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 326         } \
 327         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 328         }
 329
 330 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 331
 332 /* Begin user sect3 */
 333
 334 #define ast_yywrap(n) 1
 335 #define YY_SKIP_YYWRAP
 336
 337 typedef unsigned char YY_CHAR;
 338
 339 typedef int yy_state_type;
 340
 341 #define yytext_ptr yytext_r
 342
 343 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
 344 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
 345 static int yy_get_next_buffer (yyscan_t yyscanner );
 346 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 347
 348 /* Done after the current pattern has been matched and before the
 349  * corresponding action - sets up yytext.
 350  */
 351 #define YY_DO_BEFORE_ACTION \
 352         yyg->yytext_ptr = yy_bp; \
 353         yyg->yytext_ptr -= yyg->yy_more_len; \
 354         yyleng = (size_t) (yy_cp - yyg->yytext_ptr); \
 355         yyg->yy_hold_char = *yy_cp; \
 356         *yy_cp = '\0'; \
 357         yyg->yy_c_buf_p = yy_cp;
 358
 359 #define YY_NUM_RULES 35
 360 #define YY_END_OF_BUFFER 36
 361 /* This struct is not used in this scanner,
 362    but its presence is necessary. */
 363 struct yy_trans_info
 364         {
 365         flex_int32_t yy_verify;
 366         flex_int32_t yy_nxt;
 367         };
 368 static yyconst flex_int16_t yy_accept[55] =
 369     {   0,
 370         0,    0,    0,    0,   32,   32,   36,   35,   25,   27,
 371        19,   35,   29,   29,   17,    2,   22,   23,   15,   13,
 372        14,   16,   28,   20,    9,    3,    8,   18,    1,   35,
 373        31,   30,   32,   33,   33,   12,    0,   26,   29,   24,
 374         5,   28,   21,   11,    6,    7,   10,    4,    0,   31,
 375        30,   32,   34,    0
 376     } ;
 377
 378 static yyconst flex_int32_t yy_ec[256] =
 379     {   0,
 380         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 381         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
 382         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 383         1,    2,    4,    5,    6,    7,    8,    9,    6,   10,
 384        11,   12,   13,    6,   14,    6,   15,   16,   16,   16,
 385        16,   16,   16,   16,   16,   16,   16,   17,    6,   18,
 386        19,   20,   21,    6,    6,    6,    6,    6,    6,    6,
 387         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
 388         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
 389         1,    6,    1,    6,    6,    1,    6,    6,    6,    6,
 390
 391         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
 392         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
 393         6,    6,   22,   23,   24,   25,    1,    1,    1,    1,
 394         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 395         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 401
 402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 403         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 407         1,    1,    1,    1,    1
 408     } ;
 409
 410 static yyconst flex_int32_t yy_meta[26] =
 411     {   0,
 412         1,    2,    2,    2,    1,    3,    4,    2,    2,    2,
 413         2,    2,    2,    2,    2,    3,    2,    2,    2,    2,
 414         2,    3,    2,    1,    1
 415     } ;
 416
 417 static yyconst flex_int16_t yy_base[61] =
 418     {   0,
 419         0,    0,    4,    5,   29,   54,   71,  101,  101,  101,
 420        50,   63,   25,   45,  101,   56,  101,  101,  101,  101,
 421       101,  101,   31,   47,   44,   14,   43,  101,   29,   18,
 422       101,  101,    0,  101,   28,  101,   38,  101,   42,  101,
 423       101,   50,  101,  101,  101,  101,  101,  101,   22,  101,
 424       101,    0,  101,  101,   79,   83,   87,   89,   93,   97
 425     } ;
 426
 427 static yyconst flex_int16_t yy_def[61] =
 428     {   0,
 429        54,    1,   55,   55,   56,   56,   54,   54,   54,   54,
 430        54,   57,   54,   58,   54,   54,   54,   54,   54,   54,
 431        54,   54,   54,   54,   54,   54,   54,   54,   54,   59,
 432        54,   54,   60,   54,   54,   54,   57,   54,   54,   54,
 433        54,   54,   54,   54,   54,   54,   54,   54,   59,   54,
 434        54,   60,   54,    0,   54,   54,   54,   54,   54,   54
 435     } ;
 436
 437 static yyconst flex_int16_t yy_nxt[127] =
 438     {   0,
 439         8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
 440        18,   19,   20,   21,   22,   23,   24,   25,   26,   27,
 441        28,    8,   29,    8,    8,   31,   31,   32,   32,   33,
 442        39,   39,   45,   33,   33,   35,   39,   39,   46,   50,
 443        39,   51,   38,   50,   33,   51,   42,   39,   39,   53,
 444        33,   48,   33,   33,   33,   39,   39,   39,   33,   33,
 445        35,   47,   44,   43,   41,   42,   40,   38,   36,   33,
 446        54,   54,   54,   54,   54,   33,   54,   33,   33,   30,
 447        30,   30,   30,   34,   34,   34,   34,   37,   37,   37,
 448        37,   39,   39,   49,   49,   49,   49,   52,   54,   52,
 449
 450         7,   54,   54,   54,   54,   54,   54,   54,   54,   54,
 451        54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
 452        54,   54,   54,   54,   54,   54
 453     } ;
 454
 455 static yyconst flex_int16_t yy_chk[127] =
 456     {   0,
 457         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 458         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 459         1,    1,    1,    1,    1,    3,    4,    3,    4,    5,
 460        13,   13,   26,    5,    5,    5,   23,   23,   26,   30,
 461        13,   30,   37,   49,    5,   49,   23,   39,   39,   35,
 462         5,   29,    5,    5,    6,   42,   42,   39,    6,    6,
 463         6,   27,   25,   24,   16,   42,   14,   12,   11,    6,
 464         7,    0,    0,    0,    0,    6,    0,    6,    6,   55,
 465        55,   55,   55,   56,   56,   56,   56,   57,   57,   57,
 466        57,   58,   58,   59,   59,   59,   59,   60,    0,   60,
 467
 468        54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
 469        54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
 470        54,   54,   54,   54,   54,   54
 471     } ;
 472
 473 /* The intent behind this definition is that it'll catch
 474  * any uses of REJECT which flex missed.
 475  */
 476 #define REJECT reject_used_but_not_detected
 477 #define yymore() (yyg->yy_more_flag = 1)
 478 #define YY_MORE_ADJ yyg->yy_more_len
 479 #define YY_RESTORE_YY_MORE_OFFSET
 480 #line 1 "ast_expr2.fl"
 481 #line 2 "ast_expr2.fl"
 482 /*
 483  * Asterisk -- An open source telephony toolkit.
 484  *
 485  * Copyright (C) 1999 - 2006, Digium, Inc.
 486  *
 487  * Mark Spencer <markster@digium.com>
 488  *
 489  * See http://www.asterisk.org for more information about
 490  * the Asterisk project. Please do not directly contact
 491  * any of the maintainers of this project for assistance;
 492  * the project provides a web site, mailing lists and IRC
 493  * channels for your use.
 494  *
 495  * This program is free software, distributed under the terms of
 496  * the GNU General Public License Version 2. See the LICENSE file
 497  * at the top of the source tree.
 498  */
 499
 500 /*! \file
 501  *
 502  * \brief Dialplan Expression Lexical Scanner
 503  */
 504
 505 #include "asterisk.h"
 506
 507 #if !defined(STANDALONE_AEL)
 508 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 509 #endif
 510
 511 #include <sys/types.h>
 512 #include <stdio.h>
 513 #include <stdlib.h>
 514 #include <string.h>
 515 #include <locale.h>
 516 #include <ctype.h>
 517 #if !defined(SOLARIS) && !defined(__CYGWIN__)
 518 /* #include <err.h> */
 519 #else
 520 #define quad_t int64_t
 521 #endif
 522 #include <errno.h>
 523 #include <regex.h>
 524 #include <limits.h>
 525
 526 #include "asterisk/ast_expr.h"
 527 #include "asterisk/logger.h"
 528 #include "asterisk/strings.h"
 529
 530 enum valtype {
 531         AST_EXPR_integer, AST_EXPR_numeric_string, AST_EXPR_string
 532 } ;
 533
 534 struct val {
 535         enum valtype type;
 536         union {
 537                 char *s;
 538                 quad_t i;
 539         } u;
 540 } ;
 541
 542 #include "ast_expr2.h" /* the o/p of the bison on ast_expr2.y */
 543
 544 #define SET_COLUMNS     do {            \
 545         yylloc_param->first_column = (int)(yyg->yytext_r - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf); \
 546         yylloc_param->last_column += yyleng - 1; \
 547         yylloc_param->first_line = yylloc_param->last_line = 1; \
 548         } while (0)
 549
 550 #define SET_STRING      do {            \
 551         yylval_param->val = calloc(1, sizeof(struct val));      \
 552         yylval_param->val->type = AST_EXPR_string;              \
 553         yylval_param->val->u.s = strdup(yytext);                \
 554         } while (0)
 555
 556 #define SET_NUMERIC_STRING      do {    \
 557         yylval_param->val = calloc(1, sizeof(struct val));      \
 558         yylval_param->val->type = AST_EXPR_numeric_string;      \
 559         yylval_param->val->u.s = strdup(yytext);        \
 560         } while (0)
 561
 562 struct parse_io
 563 {
 564         char *string;
 565         struct val *val;
 566         yyscan_t scanner;
 567 };
 568
 569 void ast_yyset_column(int column_no, yyscan_t yyscanner);
 570 int ast_yyget_column(yyscan_t yyscanner);
 571 static int curlycount = 0;
 572 static char *expr2_token_subst(const char *mess);
 573
 574 #line 575 "ast_expr2f.c"
 575
 576 #define INITIAL 0
 577 #define var 1
 578 #define trail 2
 579
 580 #ifndef YY_NO_UNISTD_H
 581 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 582  * down here because we want the user's section 1 to have been scanned first.
 583  * The user has a chance to override it with an option.
 584  */
 585 #include <unistd.h>
 586 #endif
 587
 588 #ifndef YY_EXTRA_TYPE
 589 #define YY_EXTRA_TYPE void *
 590 #endif
 591
 592 /* Holds the entire state of the reentrant scanner. */
 593 struct yyguts_t
 594     {
 595
 596     /* User-defined. Not touched by flex. */
 597     YY_EXTRA_TYPE yyextra_r;
 598
 599     /* The rest are the same as the globals declared in the non-reentrant scanner. */
 600     FILE *yyin_r, *yyout_r;
 601     size_t yy_buffer_stack_top; /**< index of top of stack. */
 602     size_t yy_buffer_stack_max; /**< capacity of stack. */
 603     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
 604     char yy_hold_char;
 605     int yy_n_chars;
 606     int yyleng_r;
 607     char *yy_c_buf_p;
 608     int yy_init;
 609     int yy_start;
 610     int yy_did_buffer_switch_on_eof;
 611     int yy_start_stack_ptr;
 612     int yy_start_stack_depth;
 613     int *yy_start_stack;
 614     yy_state_type yy_last_accepting_state;
 615     char* yy_last_accepting_cpos;
 616
 617     int yylineno_r;
 618     int yy_flex_debug_r;
 619
 620     char *yytext_r;
 621     int yy_more_flag;
 622     int yy_more_len;
 623
 624     YYSTYPE * yylval_r;
 625
 626     YYLTYPE * yylloc_r;
 627
 628     }; /* end struct yyguts_t */
 629
 630 static int yy_init_globals (yyscan_t yyscanner );
 631
 632     /* This must go here because YYSTYPE and YYLTYPE are included
 633      * from bison output in section 1.*/
 634     #    define yylval yyg->yylval_r
 635
 636     #    define yylloc yyg->yylloc_r
 637
 638 /* Accessor methods to globals.
 639    These are made visible to non-reentrant scanners for convenience. */
 640
 641 int ast_yylex_destroy (yyscan_t yyscanner );
 642
 643 int ast_yyget_debug (yyscan_t yyscanner );
 644
 645 void ast_yyset_debug (int debug_flag ,yyscan_t yyscanner );
 646
 647 YY_EXTRA_TYPE ast_yyget_extra (yyscan_t yyscanner );
 648
 649 void ast_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
 650
 651 FILE *ast_yyget_in (yyscan_t yyscanner );
 652
 653 void ast_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
 654
 655 FILE *ast_yyget_out (yyscan_t yyscanner );
 656
 657 void ast_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 658
 659 int ast_yyget_leng (yyscan_t yyscanner );
 660
 661 char *ast_yyget_text (yyscan_t yyscanner );
 662
 663 int ast_yyget_lineno (yyscan_t yyscanner );
 664
 665 void ast_yyset_lineno (int line_number ,yyscan_t yyscanner );
 666
 667 YYSTYPE * ast_yyget_lval (yyscan_t yyscanner );
 668
 669 void ast_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
 670
 671        YYLTYPE *ast_yyget_lloc (yyscan_t yyscanner );
 672
 673         void ast_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
 674
 675 /* Macros after this point can all be overridden by user definitions in
 676  * section 1.
 677  */
 678
 679 #ifndef YY_SKIP_YYWRAP
 680 #ifdef __cplusplus
 681 extern "C" int ast_yywrap (yyscan_t yyscanner );
 682 #else
 683 extern int ast_yywrap (yyscan_t yyscanner );
 684 #endif
 685 #endif
 686
 687     static void yyunput (int c,char *buf_ptr  ,yyscan_t yyscanner);
 688
 689 #ifndef yytext_ptr
 690 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
 691 #endif
 692
 693 #ifdef YY_NEED_STRLEN
 694 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 695 #endif
 696
 697 #ifndef YY_NO_INPUT
 698
 699 #ifdef __cplusplus
 700 static int yyinput (yyscan_t yyscanner );
 701 #else
 702 static int input (yyscan_t yyscanner );
 703 #endif
 704
 705 #endif
 706
 707 /* Amount of stuff to slurp up with each read. */
 708 #ifndef YY_READ_BUF_SIZE
 709 #define YY_READ_BUF_SIZE 8192
 710 #endif
 711
 712 /* Copy whatever the last rule matched to the standard output. */
 713 #ifndef ECHO
 714 /* This used to be an fputs(), but since the string might contain NUL's,
 715  * we now use fwrite().
 716  */
 717 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 718 #endif
 719
 720 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 721  * is returned in "result".
 722  */
 723 #ifndef YY_INPUT
 724 #define YY_INPUT(buf,result,max_size) \
 725         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 726                 { \
 727                 int c = '*'; \
 728                 size_t n; \
 729                 for ( n = 0; n < max_size && \
 730                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 731                         buf[n] = (char) c; \
 732                 if ( c == '\n' ) \
 733                         buf[n++] = (char) c; \
 734                 if ( c == EOF && ferror( yyin ) ) \
 735                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 736                 result = n; \
 737                 } \
 738         else \
 739                 { \
 740                 errno=0; \
 741                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 742                         { \
 743                         if( errno != EINTR) \
 744                                 { \
 745                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 746                                 break; \
 747                                 } \
 748                         errno=0; \
 749                         clearerr(yyin); \
 750                         } \
 751                 }\
 752 \
 753
 754 #endif
 755
 756 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 757  * we don't want an extra ';' after the "return" because that will cause
 758  * some compilers to complain about unreachable statements.
 759  */
 760 #ifndef yyterminate
 761 #define yyterminate() return YY_NULL
 762 #endif
 763
 764 /* Number of entries by which start-condition stack grows. */
 765 #ifndef YY_START_STACK_INCR
 766 #define YY_START_STACK_INCR 25
 767 #endif
 768
 769 /* Report a fatal error. */
 770 #ifndef YY_FATAL_ERROR
 771 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 772 #endif
 773
 774 /* end tables serialization structures and prototypes */
 775
 776 /* Default declaration of generated scanner - a define so the user can
 777  * easily add parameters.
 778  */
 779 #ifndef YY_DECL
 780 #define YY_DECL_IS_OURS 1
 781
 782 extern int ast_yylex (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
 783
 784 #define YY_DECL int ast_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
 785 #endif /* !YY_DECL */
 786
 787 /* Code executed at the beginning of each rule, after yytext and yyleng
 788  * have been set up.
 789  */
 790 #ifndef YY_USER_ACTION
 791 #define YY_USER_ACTION
 792 #endif
 793
 794 /* Code executed at the end of each rule. */
 795 #ifndef YY_BREAK
 796 #define YY_BREAK break;
 797 #endif
 798
 799 #define YY_RULE_SETUP \
 800         YY_USER_ACTION
 801
 802 /** The main scanner function which does all the work.
 803  */
 804 YY_DECL
 805 {
 806         register yy_state_type yy_current_state;
 807         register char *yy_cp, *yy_bp;
 808         register int yy_act;
 809     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 810
 811 #line 105 "ast_expr2.fl"
 812
 813
 814 #line 815 "ast_expr2f.c"
 815
 816     yylval = yylval_param;
 817
 818     yylloc = yylloc_param;
 819
 820         if ( !yyg->yy_init )
 821                 {
 822                 yyg->yy_init = 1;
 823
 824 #ifdef YY_USER_INIT
 825                 YY_USER_INIT;
 826 #endif
 827
 828                 if ( ! yyg->yy_start )
 829                         yyg->yy_start = 1;      /* first start state */
 830
 831                 if ( ! yyin )
 832                         yyin = stdin;
 833
 834                 if ( ! yyout )
 835                         yyout = stdout;
 836
 837                 if ( ! YY_CURRENT_BUFFER ) {
 838                         ast_yyensure_buffer_stack (yyscanner);
 839                         YY_CURRENT_BUFFER_LVALUE =
 840                                 ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
 841                 }
 842
 843                 ast_yy_load_buffer_state(yyscanner );
 844                 }
 845
 846         while ( 1 )             /* loops until end-of-file is reached */
 847                 {
 848                 yyg->yy_more_len = 0;
 849                 if ( yyg->yy_more_flag )
 850                         {
 851                         yyg->yy_more_len = yyg->yy_c_buf_p - yyg->yytext_ptr;
 852                         yyg->yy_more_flag = 0;
 853                         }
 854                 yy_cp = yyg->yy_c_buf_p;
 855
 856                 /* Support of yytext. */
 857                 *yy_cp = yyg->yy_hold_char;
 858
 859                 /* yy_bp points to the position in yy_ch_buf of the start of
 860                  * the current run.
 861                  */
 862                 yy_bp = yy_cp;
 863
 864                 yy_current_state = yyg->yy_start;
 865 yy_match:
 866                 do
 867                         {
 868                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 869                         if ( yy_accept[yy_current_state] )
 870                                 {
 871                                 yyg->yy_last_accepting_state = yy_current_state;
 872                                 yyg->yy_last_accepting_cpos = yy_cp;
 873                                 }
 874                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 875                                 {
 876                                 yy_current_state = (int) yy_def[yy_current_state];
 877                                 if ( yy_current_state >= 55 )
 878                                         yy_c = yy_meta[(unsigned int) yy_c];
 879                                 }
 880                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 881                         ++yy_cp;
 882                         }
 883                 while ( yy_current_state != 54 );
 884                 yy_cp = yyg->yy_last_accepting_cpos;
 885                 yy_current_state = yyg->yy_last_accepting_state;
 886
 887 yy_find_action:
 888                 yy_act = yy_accept[yy_current_state];
 889
 890                 YY_DO_BEFORE_ACTION;
 891
 892 do_action:      /* This label is used only to access EOF actions. */
 893
 894                 switch ( yy_act )
 895         { /* beginning of action switch */
 896                         case 0: /* must back up */
 897                         /* undo the effects of YY_DO_BEFORE_ACTION */
 898                         *yy_cp = yyg->yy_hold_char;
 899                         yy_cp = yyg->yy_last_accepting_cpos;
 900                         yy_current_state = yyg->yy_last_accepting_state;
 901                         goto yy_find_action;
 902
 903 case 1:
 904 YY_RULE_SETUP
 905 #line 107 "ast_expr2.fl"
 906 { SET_COLUMNS; SET_STRING; return TOK_OR;}
 907         YY_BREAK
 908 case 2:
 909 YY_RULE_SETUP
 910 #line 108 "ast_expr2.fl"
 911 { SET_COLUMNS; SET_STRING; return TOK_AND;}
 912         YY_BREAK
 913 case 3:
 914 YY_RULE_SETUP
 915 #line 109 "ast_expr2.fl"
 916 { SET_COLUMNS; SET_STRING; return TOK_EQ;}
 917         YY_BREAK
 918 case 4:
 919 YY_RULE_SETUP
 920 #line 110 "ast_expr2.fl"
 921 { SET_COLUMNS; SET_STRING; return TOK_OR;}
 922         YY_BREAK
 923 case 5:
 924 YY_RULE_SETUP
 925 #line 111 "ast_expr2.fl"
 926 { SET_COLUMNS; SET_STRING; return TOK_AND;}
 927         YY_BREAK
 928 case 6:
 929 YY_RULE_SETUP
 930 #line 112 "ast_expr2.fl"
 931 { SET_COLUMNS; SET_STRING; return TOK_EQ;}
 932         YY_BREAK
 933 case 7:
 934 YY_RULE_SETUP
 935 #line 113 "ast_expr2.fl"
 936 { SET_COLUMNS; SET_STRING; return TOK_EQTILDE;}
 937         YY_BREAK
 938 case 8:
 939 YY_RULE_SETUP
 940 #line 114 "ast_expr2.fl"
 941 { SET_COLUMNS; SET_STRING; return TOK_GT;}
 942         YY_BREAK
 943 case 9:
 944 YY_RULE_SETUP
 945 #line 115 "ast_expr2.fl"
 946 { SET_COLUMNS; SET_STRING; return TOK_LT;}
 947         YY_BREAK
 948 case 10:
 949 YY_RULE_SETUP
 950 #line 116 "ast_expr2.fl"
 951 { SET_COLUMNS; SET_STRING; return TOK_GE;}
 952         YY_BREAK
 953 case 11:
 954 YY_RULE_SETUP
 955 #line 117 "ast_expr2.fl"
 956 { SET_COLUMNS; SET_STRING; return TOK_LE;}
 957         YY_BREAK
 958 case 12:
 959 YY_RULE_SETUP
 960 #line 118 "ast_expr2.fl"
 961 { SET_COLUMNS; SET_STRING; return TOK_NE;}
 962         YY_BREAK
 963 case 13:
 964 YY_RULE_SETUP
 965 #line 119 "ast_expr2.fl"
 966 { SET_COLUMNS; SET_STRING; return TOK_PLUS;}
 967         YY_BREAK
 968 case 14:
 969 YY_RULE_SETUP
 970 #line 120 "ast_expr2.fl"
 971 { SET_COLUMNS; SET_STRING; return TOK_MINUS;}
 972         YY_BREAK
 973 case 15:
 974 YY_RULE_SETUP
 975 #line 121 "ast_expr2.fl"
 976 { SET_COLUMNS; SET_STRING; return TOK_MULT;}
 977         YY_BREAK
 978 case 16:
 979 YY_RULE_SETUP
 980 #line 122 "ast_expr2.fl"
 981 { SET_COLUMNS; SET_STRING; return TOK_DIV;}
 982         YY_BREAK
 983 case 17:
 984 YY_RULE_SETUP
 985 #line 123 "ast_expr2.fl"
 986 { SET_COLUMNS; SET_STRING; return TOK_MOD;}
 987         YY_BREAK
 988 case 18:
 989 YY_RULE_SETUP
 990 #line 124 "ast_expr2.fl"
 991 { SET_COLUMNS; SET_STRING; return TOK_COND;}
 992         YY_BREAK
 993 case 19:
 994 YY_RULE_SETUP
 995 #line 125 "ast_expr2.fl"
 996 { SET_COLUMNS; SET_STRING; return TOK_COMPL;}
 997         YY_BREAK
 998 case 20:
 999 YY_RULE_SETUP
1000 #line 126 "ast_expr2.fl"
1001 { SET_COLUMNS; SET_STRING; return TOK_COLON;}
1002         YY_BREAK
1003 case 21:
1004 YY_RULE_SETUP
1005 #line 127 "ast_expr2.fl"
1006 { SET_COLUMNS; SET_STRING; return TOK_COLONCOLON;}
1007         YY_BREAK
1008 case 22:
1009 YY_RULE_SETUP
1010 #line 128 "ast_expr2.fl"
1011 { SET_COLUMNS; SET_STRING; return TOK_LP;}
1012         YY_BREAK
1013 case 23:
1014 YY_RULE_SETUP
1015 #line 129 "ast_expr2.fl"
1016 { SET_COLUMNS; SET_STRING; return TOK_RP;}
1017         YY_BREAK
1018 case 24:
1019 YY_RULE_SETUP
1020 #line 130 "ast_expr2.fl"
1021 {
1022                 /* gather the contents of ${} expressions, with trailing stuff,
1023                  * into a single TOKEN.
1024                  * They are much more complex now than they used to be
1025                  */
1026                 curlycount = 0;
1027                 BEGIN(var);
1028                 yymore();
1029         }
1030         YY_BREAK
1031 case 25:
1032 YY_RULE_SETUP
1033 #line 140 "ast_expr2.fl"
1034 {}
1035         YY_BREAK
1036 case 26:
1037 /* rule 26 can match eol */
1038 YY_RULE_SETUP
1039 #line 141 "ast_expr2.fl"
1040 {SET_COLUMNS; SET_STRING; return TOKEN;}
1041         YY_BREAK
1042 case 27:
1043 /* rule 27 can match eol */
1044 YY_RULE_SETUP
1045 #line 143 "ast_expr2.fl"
1046 {/* what to do with eol */}
1047         YY_BREAK
1048 case 28:
1049 YY_RULE_SETUP
1050 #line 144 "ast_expr2.fl"
1051 {
1052                 SET_COLUMNS;
1053                 /* the original behavior of the expression parser was
1054                  * to bring in numbers as a numeric string
1055                  */
1056                 SET_NUMERIC_STRING;
1057                 return TOKEN;
1058         }
1059         YY_BREAK
1060 case 29:
1061 YY_RULE_SETUP
1062 #line 153 "ast_expr2.fl"
1063 {
1064                 SET_COLUMNS;
1065                 SET_STRING;
1066                 return TOKEN;
1067         }
1068         YY_BREAK
1069 case 30:
1070 /* rule 30 can match eol */
1071 YY_RULE_SETUP
1072 #line 160 "ast_expr2.fl"
1073 {
1074                 curlycount--;
1075                 if (curlycount < 0) {
1076                         BEGIN(trail);
1077                         yymore();
1078                 } else {
1079                         yymore();
1080                 }
1081         }
1082         YY_BREAK
1083 case 31:
1084 /* rule 31 can match eol */
1085 YY_RULE_SETUP
1086 #line 170 "ast_expr2.fl"
1087 {
1088                 curlycount++;
1089                 yymore();
1090         }
1091         YY_BREAK
1092 case 32:
1093 YY_RULE_SETUP
1094 #line 176 "ast_expr2.fl"
1095 {
1096                 BEGIN(0);
1097                 SET_COLUMNS;
1098                 SET_STRING;
1099                 return TOKEN;
1100         }
1101         YY_BREAK
1102 case 33:
1103 /* rule 33 can match eol */
1104 YY_RULE_SETUP
1105 #line 183 "ast_expr2.fl"
1106 {
1107                 char c = yytext[yyleng-1];
1108                 BEGIN(0);
1109                 unput(c);
1110                 SET_COLUMNS;
1111                 SET_STRING;
1112                 return TOKEN;
1113         }
1114         YY_BREAK
1115 case 34:
1116 YY_RULE_SETUP
1117 #line 192 "ast_expr2.fl"
1118 {
1119                 curlycount = 0;
1120                 BEGIN(var);
1121                 yymore();
1122         }
1123         YY_BREAK
1124 case YY_STATE_EOF(trail):
1125 #line 198 "ast_expr2.fl"
1126 {
1127                 BEGIN(0);
1128                 SET_COLUMNS;
1129                 SET_STRING;
1130                 return TOKEN;
1131                 /*actually, if an expr is only a variable ref, this could happen a LOT */
1132         }
1133         YY_BREAK
1134 case 35:
1135 YY_RULE_SETUP
1136 #line 206 "ast_expr2.fl"
1137 ECHO;
1138         YY_BREAK
1139 #line 1140 "ast_expr2f.c"
1140 case YY_STATE_EOF(INITIAL):
1141 case YY_STATE_EOF(var):
1142         yyterminate();
1143
1144         case YY_END_OF_BUFFER:
1145                 {
1146                 /* Amount of text matched not including the EOB char. */
1147                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1148
1149                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1150                 *yy_cp = yyg->yy_hold_char;
1151                 YY_RESTORE_YY_MORE_OFFSET
1152
1153                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1154                         {
1155                         /* We're scanning a new file or input source.  It's
1156                          * possible that this happened because the user
1157                          * just pointed yyin at a new source and called
1158                          * ast_yylex().  If so, then we have to assure
1159                          * consistency between YY_CURRENT_BUFFER and our
1160                          * globals.  Here is the right place to do so, because
1161                          * this is the first action (other than possibly a
1162                          * back-up) that will match for the new input source.
1163                          */
1164                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1165                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1166                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1167                         }
1168
1169                 /* Note that here we test for yy_c_buf_p "<=" to the position
1170                  * of the first EOB in the buffer, since yy_c_buf_p will
1171                  * already have been incremented past the NUL character
1172                  * (since all states make transitions on EOB to the
1173                  * end-of-buffer state).  Contrast this with the test
1174                  * in input().
1175                  */
1176                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1177                         { /* This was really a NUL. */
1178                         yy_state_type yy_next_state;
1179
1180                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1181
1182                         yy_current_state = yy_get_previous_state( yyscanner );
1183
1184                         /* Okay, we're now positioned to make the NUL
1185                          * transition.  We couldn't have
1186                          * yy_get_previous_state() go ahead and do it
1187                          * for us because it doesn't know how to deal
1188                          * with the possibility of jamming (and we don't
1189                          * want to build jamming into it because then it
1190                          * will run more slowly).
1191                          */
1192
1193                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1194
1195                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1196
1197                         if ( yy_next_state )
1198                                 {
1199                                 /* Consume the NUL. */
1200                                 yy_cp = ++yyg->yy_c_buf_p;
1201                                 yy_current_state = yy_next_state;
1202                                 goto yy_match;
1203                                 }
1204
1205                         else
1206                                 {
1207                                 yy_cp = yyg->yy_last_accepting_cpos;
1208                                 yy_current_state = yyg->yy_last_accepting_state;
1209                                 goto yy_find_action;
1210                                 }
1211                         }
1212
1213                 else switch ( yy_get_next_buffer( yyscanner ) )
1214                         {
1215                         case EOB_ACT_END_OF_FILE:
1216                                 {
1217                                 yyg->yy_did_buffer_switch_on_eof = 0;
1218
1219                                 if ( ast_yywrap(yyscanner ) )
1220                                         {
1221                                         /* Note: because we've taken care in
1222                                          * yy_get_next_buffer() to have set up
1223                                          * yytext, we can now set up
1224                                          * yy_c_buf_p so that if some total
1225                                          * hoser (like flex itself) wants to
1226                                          * call the scanner after we return the
1227                                          * YY_NULL, it'll still work - another
1228                                          * YY_NULL will get returned.
1229                                          */
1230                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1231
1232                                         yy_act = YY_STATE_EOF(YY_START);
1233                                         goto do_action;
1234                                         }
1235
1236                                 else
1237                                         {
1238                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1239                                                 YY_NEW_FILE;
1240                                         }
1241                                 break;
1242                                 }
1243
1244                         case EOB_ACT_CONTINUE_SCAN:
1245                                 yyg->yy_c_buf_p =
1246                                         yyg->yytext_ptr + yy_amount_of_matched_text;
1247
1248                                 yy_current_state = yy_get_previous_state( yyscanner );
1249
1250                                 yy_cp = yyg->yy_c_buf_p;
1251                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1252                                 goto yy_match;
1253
1254                         case EOB_ACT_LAST_MATCH:
1255                                 yyg->yy_c_buf_p =
1256                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1257
1258                                 yy_current_state = yy_get_previous_state( yyscanner );
1259
1260                                 yy_cp = yyg->yy_c_buf_p;
1261                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1262                                 goto yy_find_action;
1263                         }
1264                 break;
1265                 }
1266
1267         default:
1268                 YY_FATAL_ERROR(
1269                         "fatal flex scanner internal error--no action found" );
1270         } /* end of action switch */
1271                 } /* end of scanning one token */
1272 } /* end of ast_yylex */
1273
1274 /* yy_get_next_buffer - try to read in a new buffer
1275  *
1276  * Returns a code representing an action:
1277  *      EOB_ACT_LAST_MATCH -
1278  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1279  *      EOB_ACT_END_OF_FILE - end of file
1280  */
1281 static int yy_get_next_buffer (yyscan_t yyscanner)
1282 {
1283     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1284         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1285         register char *source = yyg->yytext_ptr;
1286         register int number_to_move, i;
1287         int ret_val;
1288
1289         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1290                 YY_FATAL_ERROR(
1291                 "fatal flex scanner internal error--end of buffer missed" );
1292
1293         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1294                 { /* Don't try to fill the buffer, so this is an EOF. */
1295                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1296                         {
1297                         /* We matched a single character, the EOB, so
1298                          * treat this as a final EOF.
1299                          */
1300                         return EOB_ACT_END_OF_FILE;
1301                         }
1302
1303                 else
1304                         {
1305                         /* We matched some text prior to the EOB, first
1306                          * process it.
1307                          */
1308                         return EOB_ACT_LAST_MATCH;
1309                         }
1310                 }
1311
1312         /* Try to read more data. */
1313
1314         /* First move last chars to start of buffer. */
1315         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1316
1317         for ( i = 0; i < number_to_move; ++i )
1318                 *(dest++) = *(source++);
1319
1320         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1321                 /* don't do the read, it's not guaranteed to return an EOF,
1322                  * just force an EOF
1323                  */
1324                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1325
1326         else
1327                 {
1328                         int num_to_read =
1329                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1330
1331                 while ( num_to_read <= 0 )
1332                         { /* Not enough room in the buffer - grow it. */
1333
1334                         /* just a shorter name for the current buffer */
1335                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1336
1337                         int yy_c_buf_p_offset =
1338                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1339
1340                         if ( b->yy_is_our_buffer )
1341                                 {
1342                                 int new_size = b->yy_buf_size * 2;
1343
1344                                 if ( new_size <= 0 )
1345                                         b->yy_buf_size += b->yy_buf_size / 8;
1346                                 else
1347                                         b->yy_buf_size *= 2;
1348
1349                                 b->yy_ch_buf = (char *)
1350                                         /* Include room in for 2 EOB chars. */
1351                                         ast_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1352                                 }
1353                         else
1354                                 /* Can't grow it, we don't own it. */
1355                                 b->yy_ch_buf = 0;
1356
1357                         if ( ! b->yy_ch_buf )
1358                                 YY_FATAL_ERROR(
1359                                 "fatal error - scanner input buffer overflow" );
1360
1361                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1362
1363                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1364                                                 number_to_move - 1;
1365
1366                         }
1367
1368                 if ( num_to_read > YY_READ_BUF_SIZE )
1369                         num_to_read = YY_READ_BUF_SIZE;
1370
1371                 /* Read in more data. */
1372                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1373                         yyg->yy_n_chars, num_to_read );
1374
1375                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1376                 }
1377
1378         if ( yyg->yy_n_chars == 0 )
1379                 {
1380                 if ( number_to_move == YY_MORE_ADJ )
1381                         {
1382                         ret_val = EOB_ACT_END_OF_FILE;
1383                         ast_yyrestart(yyin  ,yyscanner);
1384                         }
1385
1386                 else
1387                         {
1388                         ret_val = EOB_ACT_LAST_MATCH;
1389                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1390                                 YY_BUFFER_EOF_PENDING;
1391                         }
1392                 }
1393
1394         else
1395                 ret_val = EOB_ACT_CONTINUE_SCAN;
1396
1397         yyg->yy_n_chars += number_to_move;
1398         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1399         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1400
1401         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1402
1403         return ret_val;
1404 }
1405
1406 /* yy_get_previous_state - get the state just before the EOB char was reached */
1407
1408     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1409 {
1410         register yy_state_type yy_current_state;
1411         register char *yy_cp;
1412     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1413
1414         yy_current_state = yyg->yy_start;
1415
1416         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1417                 {
1418                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1419                 if ( yy_accept[yy_current_state] )
1420                         {
1421                         yyg->yy_last_accepting_state = yy_current_state;
1422                         yyg->yy_last_accepting_cpos = yy_cp;
1423                         }
1424                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1425                         {
1426                         yy_current_state = (int) yy_def[yy_current_state];
1427                         if ( yy_current_state >= 55 )
1428                                 yy_c = yy_meta[(unsigned int) yy_c];
1429                         }
1430                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1431                 }
1432
1433         return yy_current_state;
1434 }
1435
1436 /* yy_try_NUL_trans - try to make a transition on the NUL character
1437  *
1438  * synopsis
1439  *      next_state = yy_try_NUL_trans( current_state );
1440  */
1441     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
1442 {
1443         register int yy_is_jam;
1444     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1445         register char *yy_cp = yyg->yy_c_buf_p;
1446
1447         register YY_CHAR yy_c = 1;
1448         if ( yy_accept[yy_current_state] )
1449                 {
1450                 yyg->yy_last_accepting_state = yy_current_state;
1451                 yyg->yy_last_accepting_cpos = yy_cp;
1452                 }
1453         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1454                 {
1455                 yy_current_state = (int) yy_def[yy_current_state];
1456                 if ( yy_current_state >= 55 )
1457                         yy_c = yy_meta[(unsigned int) yy_c];
1458                 }
1459         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1460         yy_is_jam = (yy_current_state == 54);
1461
1462         return yy_is_jam ? 0 : yy_current_state;
1463 }
1464
1465     static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
1466 {
1467         register char *yy_cp;
1468     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1469
1470     yy_cp = yyg->yy_c_buf_p;
1471
1472         /* undo effects of setting up yytext */
1473         *yy_cp = yyg->yy_hold_char;
1474
1475         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1476                 { /* need to shift things up to make room */
1477                 /* +2 for EOB chars. */
1478                 register int number_to_move = yyg->yy_n_chars + 2;
1479                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1480                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1481                 register char *source =
1482                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1483
1484                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1485                         *--dest = *--source;
1486
1487                 yy_cp += (int) (dest - source);
1488                 yy_bp += (int) (dest - source);
1489                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1490                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1491
1492                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1493                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1494                 }
1495
1496         *--yy_cp = (char) c;
1497
1498         yyg->yytext_ptr = yy_bp;
1499         yyg->yy_hold_char = *yy_cp;
1500         yyg->yy_c_buf_p = yy_cp;
1501 }
1502
1503 #ifndef YY_NO_INPUT
1504 #ifdef __cplusplus
1505     static int yyinput (yyscan_t yyscanner)
1506 #else
1507     static int input  (yyscan_t yyscanner)
1508 #endif
1509
1510 {
1511         int c;
1512     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1513
1514         *yyg->yy_c_buf_p = yyg->yy_hold_char;
1515
1516         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1517                 {
1518                 /* yy_c_buf_p now points to the character we want to return.
1519                  * If this occurs *before* the EOB characters, then it's a
1520                  * valid NUL; if not, then we've hit the end of the buffer.
1521                  */
1522                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1523                         /* This was really a NUL. */
1524                         *yyg->yy_c_buf_p = '\0';
1525
1526                 else
1527                         { /* need more input */
1528                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1529                         ++yyg->yy_c_buf_p;
1530
1531                         switch ( yy_get_next_buffer( yyscanner ) )
1532                                 {
1533                                 case EOB_ACT_LAST_MATCH:
1534                                         /* This happens because yy_g_n_b()
1535                                          * sees that we've accumulated a
1536                                          * token and flags that we need to
1537                                          * try matching the token before
1538                                          * proceeding.  But for input(),
1539                                          * there's no matching to consider.
1540                                          * So convert the EOB_ACT_LAST_MATCH
1541                                          * to EOB_ACT_END_OF_FILE.
1542                                          */
1543
1544                                         /* Reset buffer status. */
1545                                         ast_yyrestart(yyin ,yyscanner);
1546
1547                                         /*FALLTHROUGH*/
1548
1549                                 case EOB_ACT_END_OF_FILE:
1550                                         {
1551                                         if ( ast_yywrap(yyscanner ) )
1552                                                 return EOF;
1553
1554                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1555                                                 YY_NEW_FILE;
1556 #ifdef __cplusplus
1557                                         return yyinput(yyscanner);
1558 #else
1559                                         return input(yyscanner);
1560 #endif
1561                                         }
1562
1563                                 case EOB_ACT_CONTINUE_SCAN:
1564                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1565                                         break;
1566                                 }
1567                         }
1568                 }
1569
1570         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1571         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
1572         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1573
1574         return c;
1575 }
1576 #endif  /* ifndef YY_NO_INPUT */
1577
1578 /** Immediately switch to a different input stream.
1579  * @param input_file A readable stream.
1580  * @param yyscanner The scanner object.
1581  * @note This function does not reset the start condition to @c INITIAL .
1582  */
1583     void ast_yyrestart  (FILE * input_file , yyscan_t yyscanner)
1584 {
1585     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1586
1587         if ( ! YY_CURRENT_BUFFER ){
1588         ast_yyensure_buffer_stack (yyscanner);
1589                 YY_CURRENT_BUFFER_LVALUE =
1590             ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1591         }
1592
1593         ast_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1594         ast_yy_load_buffer_state(yyscanner );
1595 }
1596
1597 /** Switch to a different input buffer.
1598  * @param new_buffer The new input buffer.
1599  * @param yyscanner The scanner object.
1600  */
1601     void ast_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
1602 {
1603     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1604
1605         /* TODO. We should be able to replace this entire function body
1606          * with
1607          *              ast_yypop_buffer_state();
1608          *              ast_yypush_buffer_state(new_buffer);
1609      */
1610         ast_yyensure_buffer_stack (yyscanner);
1611         if ( YY_CURRENT_BUFFER == new_buffer )
1612                 return;
1613
1614         if ( YY_CURRENT_BUFFER )
1615                 {
1616                 /* Flush out information for old buffer. */
1617                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1618                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1619                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1620                 }
1621
1622         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1623         ast_yy_load_buffer_state(yyscanner );
1624
1625         /* We don't actually know whether we did this switch during
1626          * EOF (ast_yywrap()) processing, but the only time this flag
1627          * is looked at is after ast_yywrap() is called, so it's safe
1628          * to go ahead and always set it.
1629          */
1630         yyg->yy_did_buffer_switch_on_eof = 1;
1631 }
1632
1633 static void ast_yy_load_buffer_state  (yyscan_t yyscanner)
1634 {
1635     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1636         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1637         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1638         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1639         yyg->yy_hold_char = *yyg->yy_c_buf_p;
1640 }
1641
1642 /** Allocate and initialize an input buffer state.
1643  * @param file A readable stream.
1644  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1645  * @param yyscanner The scanner object.
1646  * @return the allocated buffer state.
1647  */
1648     YY_BUFFER_STATE ast_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
1649 {
1650         YY_BUFFER_STATE b;
1651
1652         b = (YY_BUFFER_STATE) ast_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1653         if ( ! b )
1654                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_create_buffer()" );
1655
1656         b->yy_buf_size = size;
1657
1658         /* yy_ch_buf has to be 2 characters longer than the size given because
1659          * we need to put in 2 end-of-buffer characters.
1660          */
1661         b->yy_ch_buf = (char *) ast_yyalloc(b->yy_buf_size + 2 ,yyscanner );
1662         if ( ! b->yy_ch_buf )
1663                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_create_buffer()" );
1664
1665         b->yy_is_our_buffer = 1;
1666
1667         ast_yy_init_buffer(b,file ,yyscanner);
1668
1669         return b;
1670 }
1671
1672 /** Destroy the buffer.
1673  * @param b a buffer created with ast_yy_create_buffer()
1674  * @param yyscanner The scanner object.
1675  */
1676     void ast_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1677 {
1678     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1679
1680         if ( ! b )
1681                 return;
1682
1683         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1684                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1685
1686         if ( b->yy_is_our_buffer )
1687                 ast_yyfree((void *) b->yy_ch_buf ,yyscanner );
1688
1689         ast_yyfree((void *) b ,yyscanner );
1690 }
1691
1692 #ifndef __cplusplus
1693 extern int isatty (int );
1694 #endif /* __cplusplus */
1695
1696 /* Initializes or reinitializes a buffer.
1697  * This function is sometimes called more than once on the same buffer,
1698  * such as during a ast_yyrestart() or at EOF.
1699  */
1700     static void ast_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
1701
1702 {
1703         int oerrno = errno;
1704     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1705
1706         ast_yy_flush_buffer(b ,yyscanner);
1707
1708         b->yy_input_file = file;
1709         b->yy_fill_buffer = 1;
1710
1711     /* If b is the current buffer, then ast_yy_init_buffer was _probably_
1712      * called from ast_yyrestart() or through yy_get_next_buffer.
1713      * In that case, we don't want to reset the lineno or column.
1714      */
1715     if (b != YY_CURRENT_BUFFER){
1716         b->yy_bs_lineno = 1;
1717         b->yy_bs_column = 0;
1718     }
1719
1720         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1721
1722         errno = oerrno;
1723 }
1724
1725 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1726  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1727  * @param yyscanner The scanner object.
1728  */
1729     void ast_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1730 {
1731     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1732         if ( ! b )
1733                 return;
1734
1735         b->yy_n_chars = 0;
1736
1737         /* We always need two end-of-buffer characters.  The first causes
1738          * a transition to the end-of-buffer state.  The second causes
1739          * a jam in that state.
1740          */
1741         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1742         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1743
1744         b->yy_buf_pos = &b->yy_ch_buf[0];
1745
1746         b->yy_at_bol = 1;
1747         b->yy_buffer_status = YY_BUFFER_NEW;
1748
1749         if ( b == YY_CURRENT_BUFFER )
1750                 ast_yy_load_buffer_state(yyscanner );
1751 }
1752
1753 /** Pushes the new state onto the stack. The new state becomes
1754  *  the current state. This function will allocate the stack
1755  *  if necessary.
1756  *  @param new_buffer The new state.
1757  *  @param yyscanner The scanner object.
1758  */
1759 void ast_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1760 {
1761     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1762         if (new_buffer == NULL)
1763                 return;
1764
1765         ast_yyensure_buffer_stack(yyscanner);
1766
1767         /* This block is copied from ast_yy_switch_to_buffer. */
1768         if ( YY_CURRENT_BUFFER )
1769                 {
1770                 /* Flush out information for old buffer. */
1771                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1772                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1773                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1774                 }
1775
1776         /* Only push if top exists. Otherwise, replace top. */
1777         if (YY_CURRENT_BUFFER)
1778                 yyg->yy_buffer_stack_top++;
1779         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1780
1781         /* copied from ast_yy_switch_to_buffer. */
1782         ast_yy_load_buffer_state(yyscanner );
1783         yyg->yy_did_buffer_switch_on_eof = 1;
1784 }
1785
1786 /** Removes and deletes the top of the stack, if present.
1787  *  The next element becomes the new top.
1788  *  @param yyscanner The scanner object.
1789  */
1790 void ast_yypop_buffer_state (yyscan_t yyscanner)
1791 {
1792     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1793         if (!YY_CURRENT_BUFFER)
1794                 return;
1795
1796         ast_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1797         YY_CURRENT_BUFFER_LVALUE = NULL;
1798         if (yyg->yy_buffer_stack_top > 0)
1799                 --yyg->yy_buffer_stack_top;
1800
1801         if (YY_CURRENT_BUFFER) {
1802                 ast_yy_load_buffer_state(yyscanner );
1803                 yyg->yy_did_buffer_switch_on_eof = 1;
1804         }
1805 }
1806
1807 /* Allocates the stack if it does not exist.
1808  *  Guarantees space for at least one push.
1809  */
1810 static void ast_yyensure_buffer_stack (yyscan_t yyscanner)
1811 {
1812         int num_to_alloc;
1813     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1814
1815         if (!yyg->yy_buffer_stack) {
1816
1817                 /* First allocation is just for 2 elements, since we don't know if this
1818                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1819                  * immediate realloc on the next call.
1820          */
1821                 num_to_alloc = 1;
1822                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ast_yyalloc
1823                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1824                                                                 , yyscanner);
1825
1826                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1827
1828                 yyg->yy_buffer_stack_max = num_to_alloc;
1829                 yyg->yy_buffer_stack_top = 0;
1830                 return;
1831         }
1832
1833         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1834
1835                 /* Increase the buffer to prepare for a possible push. */
1836                 int grow_size = 8 /* arbitrary grow size */;
1837
1838                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1839                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ast_yyrealloc
1840                                                                 (yyg->yy_buffer_stack,
1841                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1842                                                                 , yyscanner);
1843
1844                 /* zero only the new slots.*/
1845                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1846                 yyg->yy_buffer_stack_max = num_to_alloc;
1847         }
1848 }
1849
1850 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1851  * @param base the character buffer
1852  * @param size the size in bytes of the character buffer
1853  * @param yyscanner The scanner object.
1854  * @return the newly allocated buffer state object.
1855  */
1856 YY_BUFFER_STATE ast_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
1857 {
1858         YY_BUFFER_STATE b;
1859
1860         if ( size < 2 ||
1861              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1862              base[size-1] != YY_END_OF_BUFFER_CHAR )
1863                 /* They forgot to leave room for the EOB's. */
1864                 return 0;
1865
1866         b = (YY_BUFFER_STATE) ast_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1867         if ( ! b )
1868                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_scan_buffer()" );
1869
1870         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1871         b->yy_buf_pos = b->yy_ch_buf = base;
1872         b->yy_is_our_buffer = 0;
1873         b->yy_input_file = 0;
1874         b->yy_n_chars = b->yy_buf_size;
1875         b->yy_is_interactive = 0;
1876         b->yy_at_bol = 1;
1877         b->yy_fill_buffer = 0;
1878         b->yy_buffer_status = YY_BUFFER_NEW;
1879
1880         ast_yy_switch_to_buffer(b ,yyscanner );
1881
1882         return b;
1883 }
1884
1885 /** Setup the input buffer state to scan a string. The next call to ast_yylex() will
1886  * scan from a @e copy of @a str.
1887  * @param str a NUL-terminated string to scan
1888  * @param yyscanner The scanner object.
1889  * @return the newly allocated buffer state object.
1890  * @note If you want to scan bytes that may contain NUL values, then use
1891  *       ast_yy_scan_bytes() instead.
1892  */
1893 YY_BUFFER_STATE ast_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
1894 {
1895
1896         return ast_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
1897 }
1898
1899 /** Setup the input buffer state to scan the given bytes. The next call to ast_yylex() will
1900  * scan from a @e copy of @a bytes.
1901  * @param bytes the byte buffer to scan
1902  * @param len the number of bytes in the buffer pointed to by @a bytes.
1903  * @param yyscanner The scanner object.
1904  * @return the newly allocated buffer state object.
1905  */
1906 YY_BUFFER_STATE ast_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
1907 {
1908         YY_BUFFER_STATE b;
1909         char *buf;
1910         yy_size_t n;
1911         int i;
1912
1913         /* Get memory for full buffer, including space for trailing EOB's. */
1914         n = _yybytes_len + 2;
1915         buf = (char *) ast_yyalloc(n ,yyscanner );
1916         if ( ! buf )
1917                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_scan_bytes()" );
1918
1919         for ( i = 0; i < _yybytes_len; ++i )
1920                 buf[i] = yybytes[i];
1921
1922         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1923
1924         b = ast_yy_scan_buffer(buf,n ,yyscanner);
1925         if ( ! b )
1926                 YY_FATAL_ERROR( "bad buffer in ast_yy_scan_bytes()" );
1927
1928         /* It's okay to grow etc. this buffer, and we should throw it
1929          * away when we're done.
1930          */
1931         b->yy_is_our_buffer = 1;
1932
1933         return b;
1934 }
1935
1936 #ifndef YY_EXIT_FAILURE
1937 #define YY_EXIT_FAILURE 2
1938 #endif
1939
1940 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
1941 {
1942         (void) fprintf( stderr, "%s\n", msg );
1943         exit( YY_EXIT_FAILURE );
1944 }
1945
1946 /* Redefine yyless() so it works in section 3 code. */
1947
1948 #undef yyless
1949 #define yyless(n) \
1950         do \
1951                 { \
1952                 /* Undo effects of setting up yytext. */ \
1953         int yyless_macro_arg = (n); \
1954         YY_LESS_LINENO(yyless_macro_arg);\
1955                 yytext[yyleng] = yyg->yy_hold_char; \
1956                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1957                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1958                 *yyg->yy_c_buf_p = '\0'; \
1959                 yyleng = yyless_macro_arg; \
1960                 } \
1961         while ( 0 )
1962
1963 /* Accessor  methods (get/set functions) to struct members. */
1964
1965 /** Get the user-defined data for this scanner.
1966  * @param yyscanner The scanner object.
1967  */
1968 YY_EXTRA_TYPE ast_yyget_extra  (yyscan_t yyscanner)
1969 {
1970     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1971     return yyextra;
1972 }
1973
1974 /** Get the current line number.
1975  * @param yyscanner The scanner object.
1976  */
1977 int ast_yyget_lineno  (yyscan_t yyscanner)
1978 {
1979     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1980
1981         if (! YY_CURRENT_BUFFER)
1982             return 0;
1983
1984     return yylineno;
1985 }
1986
1987 /** Get the current column number.
1988  * @param yyscanner The scanner object.
1989  */
1990 int ast_yyget_column  (yyscan_t yyscanner)
1991 {
1992     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1993
1994         if (! YY_CURRENT_BUFFER)
1995             return 0;
1996
1997     return yycolumn;
1998 }
1999
2000 /** Get the input stream.
2001  * @param yyscanner The scanner object.
2002  */
2003 FILE *ast_yyget_in  (yyscan_t yyscanner)
2004 {
2005     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2006     return yyin;
2007 }
2008
2009 /** Get the output stream.
2010  * @param yyscanner The scanner object.
2011  */
2012 FILE *ast_yyget_out  (yyscan_t yyscanner)
2013 {
2014     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2015     return yyout;
2016 }
2017
2018 /** Get the length of the current token.
2019  * @param yyscanner The scanner object.
2020  */
2021 int ast_yyget_leng  (yyscan_t yyscanner)
2022 {
2023     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2024     return yyleng;
2025 }
2026
2027 /** Get the current token.
2028  * @param yyscanner The scanner object.
2029  */
2030
2031 char *ast_yyget_text  (yyscan_t yyscanner)
2032 {
2033     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2034     return yytext;
2035 }
2036
2037 /** Set the user-defined data. This data is never touched by the scanner.
2038  * @param user_defined The data to be associated with this scanner.
2039  * @param yyscanner The scanner object.
2040  */
2041 void ast_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
2042 {
2043     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2044     yyextra = user_defined ;
2045 }
2046
2047 /** Set the current line number.
2048  * @param line_number
2049  * @param yyscanner The scanner object.
2050  */
2051 void ast_yyset_lineno (int  line_number , yyscan_t yyscanner)
2052 {
2053     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2054
2055         /* lineno is only valid if an input buffer exists. */
2056         if (! YY_CURRENT_BUFFER )
2057            yy_fatal_error( "ast_yyset_lineno called with no buffer" , yyscanner);
2058
2059     yylineno = line_number;
2060 }
2061
2062 /** Set the current column.
2063  * @param line_number
2064  * @param yyscanner The scanner object.
2065  */
2066 void ast_yyset_column (int  column_no , yyscan_t yyscanner)
2067 {
2068     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2069
2070         /* column is only valid if an input buffer exists. */
2071         if (! YY_CURRENT_BUFFER )
2072            yy_fatal_error( "ast_yyset_column called with no buffer" , yyscanner);
2073
2074     yycolumn = column_no;
2075 }
2076
2077 /** Set the input stream. This does not discard the current
2078  * input buffer.
2079  * @param in_str A readable stream.
2080  * @param yyscanner The scanner object.
2081  * @see ast_yy_switch_to_buffer
2082  */
2083 void ast_yyset_in (FILE *  in_str , yyscan_t yyscanner)
2084 {
2085     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2086     yyin = in_str ;
2087 }
2088
2089 void ast_yyset_out (FILE *  out_str , yyscan_t yyscanner)
2090 {
2091     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2092     yyout = out_str ;
2093 }
2094
2095 int ast_yyget_debug  (yyscan_t yyscanner)
2096 {
2097     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2098     return yy_flex_debug;
2099 }
2100
2101 void ast_yyset_debug (int  bdebug , yyscan_t yyscanner)
2102 {
2103     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2104     yy_flex_debug = bdebug ;
2105 }
2106
2107 /* Accessor methods for yylval and yylloc */
2108
2109 YYSTYPE * ast_yyget_lval  (yyscan_t yyscanner)
2110 {
2111     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2112     return yylval;
2113 }
2114
2115 void ast_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
2116 {
2117     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2118     yylval = yylval_param;
2119 }
2120
2121 YYLTYPE *ast_yyget_lloc  (yyscan_t yyscanner)
2122 {
2123     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2124     return yylloc;
2125 }
2126
2127 void ast_yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
2128 {
2129     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2130     yylloc = yylloc_param;
2131 }
2132
2133 /* User-visible API */
2134
2135 /* ast_yylex_init is special because it creates the scanner itself, so it is
2136  * the ONLY reentrant function that doesn't take the scanner as the last argument.
2137  * That's why we explicitly handle the declaration, instead of using our macros.
2138  */
2139
2140 int ast_yylex_init(yyscan_t* ptr_yy_globals)
2141
2142 {
2143     if (ptr_yy_globals == NULL){
2144         errno = EINVAL;
2145         return 1;
2146     }
2147
2148     *ptr_yy_globals = (yyscan_t) ast_yyalloc ( sizeof( struct yyguts_t ), NULL );
2149
2150     if (*ptr_yy_globals == NULL){
2151         errno = ENOMEM;
2152         return 1;
2153     }
2154
2155     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2156     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2157
2158     return yy_init_globals ( *ptr_yy_globals );
2159 }
2160
2161 static int yy_init_globals (yyscan_t yyscanner)
2162 {
2163     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2164     /* Initialization is the same as for the non-reentrant scanner.
2165      * This function is called from ast_yylex_destroy(), so don't allocate here.
2166      */
2167
2168     yyg->yy_buffer_stack = 0;
2169     yyg->yy_buffer_stack_top = 0;
2170     yyg->yy_buffer_stack_max = 0;
2171     yyg->yy_c_buf_p = (char *) 0;
2172     yyg->yy_init = 0;
2173     yyg->yy_start = 0;
2174
2175     yyg->yy_start_stack_ptr = 0;
2176     yyg->yy_start_stack_depth = 0;
2177     yyg->yy_start_stack =  NULL;
2178
2179 /* Defined in main.c */
2180 #ifdef YY_STDINIT
2181     yyin = stdin;
2182     yyout = stdout;
2183 #else
2184     yyin = (FILE *) 0;
2185     yyout = (FILE *) 0;
2186 #endif
2187
2188     /* For future reference: Set errno on error, since we are called by
2189      * ast_yylex_init()
2190      */
2191     return 0;
2192 }
2193
2194 /* ast_yylex_destroy is for both reentrant and non-reentrant scanners. */
2195 int ast_yylex_destroy  (yyscan_t yyscanner)
2196 {
2197     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2198
2199     /* Pop the buffer stack, destroying each element. */
2200         while(YY_CURRENT_BUFFER){
2201                 ast_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2202                 YY_CURRENT_BUFFER_LVALUE = NULL;
2203                 ast_yypop_buffer_state(yyscanner);
2204         }
2205
2206         /* Destroy the stack itself. */
2207         ast_yyfree(yyg->yy_buffer_stack ,yyscanner);
2208         yyg->yy_buffer_stack = NULL;
2209
2210     /* Destroy the start condition stack. */
2211         ast_yyfree(yyg->yy_start_stack ,yyscanner );
2212         yyg->yy_start_stack = NULL;
2213
2214     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2215      * ast_yylex() is called, initialization will occur. */
2216     yy_init_globals( yyscanner);
2217
2218     /* Destroy the main struct (reentrant only). */
2219     ast_yyfree ( yyscanner , yyscanner );
2220     yyscanner = NULL;
2221     return 0;
2222 }
2223
2224 /*
2225  * Internal utility routines.
2226  */
2227
2228 #ifndef yytext_ptr
2229 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2230 {
2231         register int i;
2232         for ( i = 0; i < n; ++i )
2233                 s1[i] = s2[i];
2234 }
2235 #endif
2236
2237 #ifdef YY_NEED_STRLEN
2238 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2239 {
2240         register int n;
2241         for ( n = 0; s[n]; ++n )
2242                 ;
2243
2244         return n;
2245 }
2246 #endif
2247
2248 void *ast_yyalloc (yy_size_t  size , yyscan_t yyscanner)
2249 {
2250         return (void *) malloc( size );
2251 }
2252
2253 void *ast_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
2254 {
2255         /* The cast to (char *) in the following accommodates both
2256          * implementations that use char* generic pointers, and those
2257          * that use void* generic pointers.  It works with the latter
2258          * because both ANSI C and C++ allow castless assignment from
2259          * any pointer type to void*, and deal with argument conversions
2260          * as though doing an assignment.
2261          */
2262         return (void *) realloc( (char *) ptr, size );
2263 }
2264
2265 #define YYTABLES_NAME "yytables"
2266
2267 #line 206 "ast_expr2.fl"
2268
2269
2270
2271 /* I'm putting the interface routine to the whole parse here in the flexer input file
2272    mainly because of all the flexer initialization that has to be done. Shouldn't matter
2273    where it is, as long as it's somewhere. I didn't want to define a prototype for the
2274    ast_yy_scan_string in the .y file, because then, I'd have to define YY_BUFFER_STATE there...
2275         UGH! that would be inappropriate. */
2276
2277 int ast_yyparse(void *); /* need to/should define this prototype for the call to yyparse */
2278 int ast_yyerror(const char *, YYLTYPE *, struct parse_io *); /* likewise */
2279
2280 void ast_yyfree(void *ptr, yyscan_t yyscanner)
2281 {
2282       if (ptr) /* the normal generated ast_yyfree func just frees its first arg;
2283                     this get complaints on some systems, as sometimes this
2284                     arg is a nil ptr! It's usually not fatal, but is irritating! */
2285               free( (char *) ptr );
2286 }
2287
2288 int ast_expr(char *expr, char *buf, int length)
2289 {
2290         struct parse_io io;
2291         int return_value = 0;
2292
2293         memset(&io, 0, sizeof(io));
2294         io.string = expr;  /* to pass to the error routine */
2295
2296         ast_yylex_init(&io.scanner);
2297
2298         ast_yy_scan_string(expr, io.scanner);
2299
2300         ast_yyparse ((void *) &io);
2301
2302         ast_yylex_destroy(io.scanner);
2303
2304         if (!io.val) {
2305                 if (length > 1) {
2306                         strcpy(buf, "0");
2307                         return_value = 1;
2308                 }
2309         } else {
2310                 if (io.val->type == AST_EXPR_integer) {
2311                         int res_length;
2312
2313                         res_length = snprintf(buf, length, "%ld", (long int) io.val->u.i);
2314                         return_value = (res_length <= length) ? res_length : length;
2315                 } else {
2316 #if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
2317                         strncpy(buf, io.val->u.s, length - 1);
2318 #else /* !STANDALONE && !LOW_MEMORY */
2319                         ast_copy_string(buf, io.val->u.s, length);
2320 #endif /* STANDALONE || LOW_MEMORY */
2321                         return_value = strlen(buf);
2322                         free(io.val->u.s);
2323                 }
2324                 free(io.val);
2325         }
2326         return return_value;
2327 }
2328
2329
2330 char extra_error_message[4095];
2331 int extra_error_message_supplied = 0;
2332 void  ast_expr_register_extra_error_info(char *message);
2333 void  ast_expr_clear_extra_error_info(void);
2334
2335 void  ast_expr_register_extra_error_info(char *message)
2336 {
2337        extra_error_message_supplied=1;
2338        strcpy(extra_error_message, message);
2339 }
2340
2341 void  ast_expr_clear_extra_error_info(void)
2342 {
2343        extra_error_message_supplied=0;
2344        extra_error_message[0] = 0;
2345 }
2346
2347 static char *expr2_token_equivs1[] =
2348 {
2349         "TOKEN",
2350         "TOK_COND",
2351         "TOK_COLONCOLON",
2352         "TOK_OR",
2353         "TOK_AND",
2354         "TOK_EQ",
2355         "TOK_GT",
2356         "TOK_LT",
2357         "TOK_GE",
2358         "TOK_LE",
2359         "TOK_NE",
2360         "TOK_PLUS",
2361         "TOK_MINUS",
2362         "TOK_MULT",
2363         "TOK_DIV",
2364         "TOK_MOD",
2365         "TOK_COMPL",
2366         "TOK_COLON",
2367         "TOK_EQTILDE",
2368         "TOK_RP",
2369         "TOK_LP"
2370 };
2371
2372 static char *expr2_token_equivs2[] =
2373 {
2374         "<token>",
2375         "?",
2376         "::",
2377         "|",
2378         "&",
2379         "=",
2380         ">",
2381         "<",
2382         ">=",
2383         "<=",
2384         "!=",
2385         "+",
2386         "-",
2387         "*",
2388         "/",
2389         "%",
2390         "!",
2391         ":",
2392         "=~",
2393         ")",
2394         "("
2395 };
2396
2397
2398 static char *expr2_token_subst(const char *mess)
2399 {
2400         /* calc a length, malloc, fill, and return; yyerror had better free it! */
2401         int len=0,i;
2402         const char *p;
2403         char *res, *s,*t;
2404         int expr2_token_equivs_entries = sizeof(expr2_token_equivs1)/sizeof(char*);
2405
2406         for (p=mess; *p; p++) {
2407                 for (i=0; i<expr2_token_equivs_entries; i++) {
2408                         if ( strncmp(p,expr2_token_equivs1[i],strlen(expr2_token_equivs1[i])) == 0 )
2409                         {
2410                                 len+=strlen(expr2_token_equivs2[i])+2;
2411                                 p += strlen(expr2_token_equivs1[i])-1;
2412                                 break;
2413                         }
2414                 }
2415                 len++;
2416         }
2417         res = (char*)malloc(len+1);
2418         res[0] = 0;
2419         s = res;
2420         for (p=mess; *p;) {
2421                 int found = 0;
2422                 for (i=0; i<expr2_token_equivs_entries; i++) {
2423                         if ( strncmp(p,expr2_token_equivs1[i],strlen(expr2_token_equivs1[i])) == 0 ) {
2424                                 *s++ = '\'';
2425                                 for (t=expr2_token_equivs2[i]; *t;) {
2426                                         *s++ = *t++;
2427                                 }
2428                                 *s++ = '\'';
2429                                 p += strlen(expr2_token_equivs1[i]);
2430                                 found = 1;
2431                                 break;
2432                         }
2433                 }
2434                 if( !found )
2435                         *s++ = *p++;
2436         }
2437         *s++ = 0;
2438         return res;
2439 }
2440
2441 int ast_yyerror (const char *s,  yyltype *loc, struct parse_io *parseio )
2442 {
2443         struct yyguts_t * yyg = (struct yyguts_t*)(parseio->scanner);
2444         char spacebuf[8000]; /* best safe than sorry */
2445         char spacebuf2[8000]; /* best safe than sorry */
2446         int i=0;
2447         char *s2 = expr2_token_subst(s);
2448         spacebuf[0] = 0;
2449
2450         for(i=0;i< (int)(yytext - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf);i++) spacebuf2[i] = ' ';  /* uh... assuming yyg is defined, then I can use the yycolumn macro,
2451                                                                                                                                                                                                 which is the same thing as... get this:
2452                                                                                                         yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]->yy_bs_column
2453                                                                                                         I was tempted to just use yy_buf_pos in the STATE, but..., well:
2454                                                                                                                 a. the yy_buf_pos is the current position in the buffer, which
2455                                                                                                                         may not relate to the entire string/buffer because of the
2456                                                                                                                         buffering.
2457                                                                                                                 b. but, analysis of the situation is that when you use the
2458                                                                                                                         ast_yy_scan_string func, it creates a single buffer the size of
2459                                                                                                                         string, so the two would be the same...
2460                                                                                                         so, in the end, the yycolumn macro is available, shorter, therefore easier. */
2461         spacebuf2[i++]='^';
2462         spacebuf2[i]= 0;
2463
2464 #ifdef STANDALONE3
2465         /* easier to read in the standalone version */
2466         printf("ast_yyerror(): %s syntax error: %s; Input:\n%s\n%s\n",
2467                         (extra_error_message_supplied?extra_error_message:""), s2, parseio->string,spacebuf2);
2468 #else
2469         ast_log(LOG_WARNING,"ast_yyerror(): %s syntax error: %s; Input:\n%s\n%s\n",
2470                         (extra_error_message_supplied?extra_error_message:""), s2, parseio->string,spacebuf2);
2471 #endif
2472 #ifndef STANDALONE
2473         ast_log(LOG_WARNING,"If you have questions, please refer to doc/channelvariables.txt in the asterisk source.\n");
2474 #endif
2475         free(s2);
2476         return(0);
2477 }
2478