etc/afpd/spotlight_rawquery_lexer.c

   1
   2 #line 3 "spotlight_rawquery_lexer.c"
   3
   4 #define  YY_INT_ALIGNED short int
   5
   6 /* A lexical scanner generated by flex */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION 2
  10 #define YY_FLEX_MINOR_VERSION 5
  11 #define YY_FLEX_SUBMINOR_VERSION 35
  12 #if YY_FLEX_SUBMINOR_VERSION > 0
  13 #define FLEX_BETA
  14 #endif
  15
  16 /* First, we deal with  platform-specific or compiler-specific issues. */
  17
  18 /* begin standard C headers. */
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23
  24 /* end standard C headers. */
  25
  26 /* flex integer type definitions */
  27
  28 #ifndef FLEXINT_H
  29 #define FLEXINT_H
  30
  31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  32
  33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  34
  35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  36  * if you want the limit (max/min) macros for int types.
  37  */
  38 #ifndef __STDC_LIMIT_MACROS
  39 #define __STDC_LIMIT_MACROS 1
  40 #endif
  41
  42 #include <inttypes.h>
  43 typedef int8_t flex_int8_t;
  44 typedef uint8_t flex_uint8_t;
  45 typedef int16_t flex_int16_t;
  46 typedef uint16_t flex_uint16_t;
  47 typedef int32_t flex_int32_t;
  48 typedef uint32_t flex_uint32_t;
  49 #else
  50 typedef signed char flex_int8_t;
  51 typedef short int flex_int16_t;
  52 typedef int flex_int32_t;
  53 typedef unsigned char flex_uint8_t;
  54 typedef unsigned short int flex_uint16_t;
  55 typedef unsigned int flex_uint32_t;
  56 #endif /* ! C99 */
  57
  58 /* Limits of integral types. */
  59 #ifndef INT8_MIN
  60 #define INT8_MIN               (-128)
  61 #endif
  62 #ifndef INT16_MIN
  63 #define INT16_MIN              (-32767-1)
  64 #endif
  65 #ifndef INT32_MIN
  66 #define INT32_MIN              (-2147483647-1)
  67 #endif
  68 #ifndef INT8_MAX
  69 #define INT8_MAX               (127)
  70 #endif
  71 #ifndef INT16_MAX
  72 #define INT16_MAX              (32767)
  73 #endif
  74 #ifndef INT32_MAX
  75 #define INT32_MAX              (2147483647)
  76 #endif
  77 #ifndef UINT8_MAX
  78 #define UINT8_MAX              (255U)
  79 #endif
  80 #ifndef UINT16_MAX
  81 #define UINT16_MAX             (65535U)
  82 #endif
  83 #ifndef UINT32_MAX
  84 #define UINT32_MAX             (4294967295U)
  85 #endif
  86
  87 #endif /* ! FLEXINT_H */
  88
  89 #ifdef __cplusplus
  90
  91 /* The "const" storage-class-modifier is valid. */
  92 #define YY_USE_CONST
  93
  94 #else   /* ! __cplusplus */
  95
  96 /* C99 requires __STDC__ to be defined as 1. */
  97 #if defined (__STDC__)
  98
  99 #define YY_USE_CONST
 100
 101 #endif  /* defined (__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 /* Enter a start condition.  This macro really ought to take a parameter,
 121  * but we do it the disgusting crufty way forced on us by the ()-less
 122  * definition of BEGIN.
 123  */
 124 #define BEGIN (yy_start) = 1 + 2 *
 125
 126 /* Translate the current start state into a value that can be later handed
 127  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 128  * compatibility.
 129  */
 130 #define YY_START (((yy_start) - 1) / 2)
 131 #define YYSTATE YY_START
 132
 133 /* Action number for EOF rule of a given start state. */
 134 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 135
 136 /* Special action meaning "start processing a new file". */
 137 #define YY_NEW_FILE yyrestart(yyin  )
 138
 139 #define YY_END_OF_BUFFER_CHAR 0
 140
 141 /* Size of default input buffer. */
 142 #ifndef YY_BUF_SIZE
 143 #define YY_BUF_SIZE 16384
 144 #endif
 145
 146 /* The state buf must be large enough to hold one state per character in the main buffer.
 147  */
 148 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 149
 150 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 151 #define YY_TYPEDEF_YY_BUFFER_STATE
 152 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 153 #endif
 154
 155 extern int yyleng;
 156
 157 extern FILE *yyin, *yyout;
 158
 159 #define EOB_ACT_CONTINUE_SCAN 0
 160 #define EOB_ACT_END_OF_FILE 1
 161 #define EOB_ACT_LAST_MATCH 2
 162
 163     #define YY_LESS_LINENO(n)
 164
 165 /* Return all but the first "n" matched characters back to the input stream. */
 166 #define yyless(n) \
 167         do \
 168                 { \
 169                 /* Undo effects of setting up yytext. */ \
 170         int yyless_macro_arg = (n); \
 171         YY_LESS_LINENO(yyless_macro_arg);\
 172                 *yy_cp = (yy_hold_char); \
 173                 YY_RESTORE_YY_MORE_OFFSET \
 174                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 175                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 176                 } \
 177         while ( 0 )
 178
 179 #define unput(c) yyunput( c, (yytext_ptr)  )
 180
 181 #ifndef YY_TYPEDEF_YY_SIZE_T
 182 #define YY_TYPEDEF_YY_SIZE_T
 183 typedef size_t yy_size_t;
 184 #endif
 185
 186 #ifndef YY_STRUCT_YY_BUFFER_STATE
 187 #define YY_STRUCT_YY_BUFFER_STATE
 188 struct yy_buffer_state
 189         {
 190         FILE *yy_input_file;
 191
 192         char *yy_ch_buf;                /* input buffer */
 193         char *yy_buf_pos;               /* current position in input buffer */
 194
 195         /* Size of input buffer in bytes, not including room for EOB
 196          * characters.
 197          */
 198         yy_size_t yy_buf_size;
 199
 200         /* Number of characters read into yy_ch_buf, not including EOB
 201          * characters.
 202          */
 203         int yy_n_chars;
 204
 205         /* Whether we "own" the buffer - i.e., we know we created it,
 206          * and can realloc() it to grow it, and should free() it to
 207          * delete it.
 208          */
 209         int yy_is_our_buffer;
 210
 211         /* Whether this is an "interactive" input source; if so, and
 212          * if we're using stdio for input, then we want to use getc()
 213          * instead of fread(), to make sure we stop fetching input after
 214          * each newline.
 215          */
 216         int yy_is_interactive;
 217
 218         /* Whether we're considered to be at the beginning of a line.
 219          * If so, '^' rules will be active on the next match, otherwise
 220          * not.
 221          */
 222         int yy_at_bol;
 223
 224     int yy_bs_lineno; /**< The line count. */
 225     int yy_bs_column; /**< The column count. */
 226
 227         /* Whether to try to fill the input buffer when we reach the
 228          * end of it.
 229          */
 230         int yy_fill_buffer;
 231
 232         int yy_buffer_status;
 233
 234 #define YY_BUFFER_NEW 0
 235 #define YY_BUFFER_NORMAL 1
 236         /* When an EOF's been seen but there's still some text to process
 237          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 238          * shouldn't try reading from the input source any more.  We might
 239          * still have a bunch of tokens to match, though, because of
 240          * possible backing-up.
 241          *
 242          * When we actually see the EOF, we change the status to "new"
 243          * (via yyrestart()), so that the user can continue scanning by
 244          * just pointing yyin at a new input file.
 245          */
 246 #define YY_BUFFER_EOF_PENDING 2
 247
 248         };
 249 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 250
 251 /* Stack of input buffers. */
 252 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 253 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 254 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 255
 256 /* We provide macros for accessing buffer states in case in the
 257  * future we want to put the buffer states in a more general
 258  * "scanner state".
 259  *
 260  * Returns the top of the stack, or NULL.
 261  */
 262 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 263                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 264                           : NULL)
 265
 266 /* Same as previous macro, but useful when we know that the buffer stack is not
 267  * NULL or when we need an lvalue. For internal use only.
 268  */
 269 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 270
 271 /* yy_hold_char holds the character lost when yytext is formed. */
 272 static char yy_hold_char;
 273 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 274 int yyleng;
 275
 276 /* Points to current character in buffer. */
 277 static char *yy_c_buf_p = (char *) 0;
 278 static int yy_init = 0;         /* whether we need to initialize */
 279 static int yy_start = 0;        /* start state number */
 280
 281 /* Flag which is used to allow yywrap()'s to do buffer switches
 282  * instead of setting up a fresh yyin.  A bit of a hack ...
 283  */
 284 static int yy_did_buffer_switch_on_eof;
 285
 286 void yyrestart (FILE *input_file  );
 287 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 288 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 289 void yy_delete_buffer (YY_BUFFER_STATE b  );
 290 void yy_flush_buffer (YY_BUFFER_STATE b  );
 291 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 292 void yypop_buffer_state (void );
 293
 294 static void yyensure_buffer_stack (void );
 295 static void yy_load_buffer_state (void );
 296 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 297
 298 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 299
 300 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 301 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 302 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
 303
 304 void *yyalloc (yy_size_t  );
 305 void *yyrealloc (void *,yy_size_t  );
 306 void yyfree (void *  );
 307
 308 #define yy_new_buffer yy_create_buffer
 309
 310 #define yy_set_interactive(is_interactive) \
 311         { \
 312         if ( ! YY_CURRENT_BUFFER ){ \
 313         yyensure_buffer_stack (); \
 314                 YY_CURRENT_BUFFER_LVALUE =    \
 315             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 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         yyensure_buffer_stack (); \
 324                 YY_CURRENT_BUFFER_LVALUE =    \
 325             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 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 typedef unsigned char YY_CHAR;
 335
 336 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 337
 338 typedef int yy_state_type;
 339
 340 extern int yylineno;
 341
 342 int yylineno = 1;
 343
 344 extern char *yytext;
 345 #define yytext_ptr yytext
 346
 347 static yy_state_type yy_get_previous_state (void );
 348 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 349 static int yy_get_next_buffer (void );
 350 static void yy_fatal_error (yyconst char msg[]  );
 351
 352 /* Done after the current pattern has been matched and before the
 353  * corresponding action - sets up yytext.
 354  */
 355 #define YY_DO_BEFORE_ACTION \
 356         (yytext_ptr) = yy_bp; \
 357         yyleng = (size_t) (yy_cp - yy_bp); \
 358         (yy_hold_char) = *yy_cp; \
 359         *yy_cp = '\0'; \
 360         (yy_c_buf_p) = yy_cp;
 361
 362 #define YY_NUM_RULES 14
 363 #define YY_END_OF_BUFFER 15
 364 /* This struct is not used in this scanner,
 365    but its presence is necessary. */
 366 struct yy_trans_info
 367         {
 368         flex_int32_t yy_verify;
 369         flex_int32_t yy_nxt;
 370         };
 371 static yyconst flex_int16_t yy_accept[61] =
 372     {   0,
 373         0,    0,   15,   14,   13,   13,    6,   14,   14,    7,
 374         8,    5,   12,   14,    5,    5,   14,    0,    0,    9,
 375         5,   11,    5,    5,   10,    0,    0,    5,    5,    4,
 376         0,    0,    5,    5,    0,    0,    5,    5,    0,    0,
 377         5,    0,    0,    1,    0,    0,    0,    2,    0,    0,
 378         0,    0,    0,    0,    0,    0,    0,    0,    3,    0
 379     } ;
 380
 381 static yyconst flex_int32_t yy_ec[256] =
 382     {   0,
 383         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 385         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 386         1,    2,    1,    4,    1,    5,    1,    6,    1,    7,
 387         8,    9,    1,   10,   11,   12,    1,    1,    1,    1,
 388         1,    1,    1,    1,    1,    1,    1,   13,    1,    1,
 389        14,    1,    1,    1,    9,    9,    9,    9,    9,    9,
 390         9,    9,   15,    9,    9,    9,    9,    9,    9,    9,
 391         9,   16,    9,   17,    9,    9,    9,    9,    9,   18,
 392         1,    1,    1,    1,    1,    1,   19,    9,   20,   21,
 393
 394        22,    9,   23,    9,   24,    9,    9,    9,   25,   26,
 395        27,    9,    9,    9,   28,   29,    9,    9,   30,    9,
 396         9,    9,    1,   31,    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         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 403         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 404
 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,    1,    1,    1,    1,    1,
 408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 409         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 410         1,    1,    1,    1,    1
 411     } ;
 412
 413 static yyconst flex_int32_t yy_meta[32] =
 414     {   0,
 415         1,    1,    2,    1,    1,    1,    1,    1,    3,    1,
 416         3,    1,    1,    1,    3,    3,    3,    3,    3,    3,
 417         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 418         1
 419     } ;
 420
 421 static yyconst flex_int16_t yy_base[75] =
 422     {   0,
 423         0,    0,  181,    0,    0,  182,    0,  150,  170,    0,
 424         0,   31,    0,  159,  144,  137,  133,    0,  137,    0,
 425        62,    0,  142,  134,    0,    0,  127,   93,  130,    0,
 426       135,  114,  132,  115,    0,  126,  126,  116,    0,  111,
 427       118,  123,  105,  121,    0,  104,    0,  182,  113,    0,
 428         0,  115,    0,    0,   83,    0,    0,   47,  182,  182,
 429       141,  144,  147,   31,  150,  153,  156,  159,  162,  165,
 430       168,  171,  174,  177
 431     } ;
 432
 433 static yyconst flex_int16_t yy_def[75] =
 434     {   0,
 435        60,    1,   60,   61,   61,   60,   61,   61,   61,   61,
 436        61,   60,   61,   61,   12,   12,   61,   62,   62,   62,
 437        60,   62,   21,   21,   62,   63,   63,   60,   28,   28,
 438        60,   60,   64,   64,   65,   60,   64,   64,   66,   60,
 439        64,   60,   60,   64,   67,   60,   68,   60,   60,   69,
 440        70,   60,   71,   72,   60,   73,   74,   60,   60,    0,
 441        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 442        60,   60,   60,   60
 443     } ;
 444
 445 static yyconst flex_int16_t yy_nxt[214] =
 446     {   0,
 447         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
 448         4,    4,    4,   14,   15,   12,   12,   12,   12,   16,
 449        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 450        17,   18,   18,   37,   18,   18,   18,   18,   18,   21,
 451        18,   18,   18,   18,   18,   21,   21,   21,   21,   21,
 452        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
 453        21,   18,   26,   26,   59,   26,   26,   26,   26,   26,
 454        28,   26,   26,   26,   26,   26,   28,   28,   28,   28,
 455        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
 456        28,   28,   26,   31,   31,   56,   31,   31,   31,   31,
 457
 458        31,   33,   31,   31,   31,   31,   31,   33,   33,   33,
 459        33,   33,   33,   33,   33,   33,   33,   33,   33,   33,
 460        33,   33,   33,   31,   35,   35,   60,   53,   60,   50,
 461        48,   60,   46,   45,   43,   36,   60,   40,   41,   44,
 462        38,   18,   35,   18,   26,   35,   26,   31,   34,   31,
 463        39,   32,   39,   42,   30,   42,   47,   29,   47,   49,
 464        27,   49,   51,   25,   51,   52,   24,   52,   54,   23,
 465        54,   55,   22,   55,   57,   20,   57,   58,   19,   58,
 466        60,    3,   60,   60,   60,   60,   60,   60,   60,   60,
 467        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 468
 469        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 470        60,   60,   60
 471     } ;
 472
 473 static yyconst flex_int16_t yy_chk[214] =
 474     {   0,
 475         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 476         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 477         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 478         1,   12,   12,   64,   12,   12,   12,   12,   12,   12,
 479        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 480        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 481        12,   12,   21,   21,   58,   21,   21,   21,   21,   21,
 482        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
 483        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
 484        21,   21,   21,   28,   28,   55,   28,   28,   28,   28,
 485
 486        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
 487        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
 488        28,   28,   28,   28,   32,   34,   38,   52,   41,   49,
 489        46,   44,   43,   42,   40,   32,   37,   36,   38,   41,
 490        34,   61,   33,   61,   62,   31,   62,   63,   29,   63,
 491        65,   27,   65,   66,   24,   66,   67,   23,   67,   68,
 492        19,   68,   69,   17,   69,   70,   16,   70,   71,   15,
 493        71,   72,   14,   72,   73,    9,   73,   74,    8,   74,
 494         3,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 495        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 496
 497        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 498        60,   60,   60
 499     } ;
 500
 501 static yy_state_type yy_last_accepting_state;
 502 static char *yy_last_accepting_cpos;
 503
 504 extern int yy_flex_debug;
 505 int yy_flex_debug = 0;
 506
 507 /* The intent behind this definition is that it'll catch
 508  * any uses of REJECT which flex missed.
 509  */
 510 #define REJECT reject_used_but_not_detected
 511 #define yymore() yymore_used_but_not_detected
 512 #define YY_MORE_ADJ 0
 513 #define YY_RESTORE_YY_MORE_OFFSET
 514 char *yytext;
 515 #line 1 "spotlight_rawquery_lexer.l"
 516 #line 2 "spotlight_rawquery_lexer.l"
 517 #include <string.h>
 518 #include <gio/gio.h>
 519 #include <atalk/talloc.h>
 520 #include "spotlight.h"
 521 #include "spotlight_rawquery_parser.h"
 522 #line 523 "spotlight_rawquery_lexer.c"
 523
 524 #define INITIAL 0
 525
 526 #ifndef YY_NO_UNISTD_H
 527 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 528  * down here because we want the user's section 1 to have been scanned first.
 529  * The user has a chance to override it with an option.
 530  */
 531 #include <unistd.h>
 532 #endif
 533
 534 #ifndef YY_EXTRA_TYPE
 535 #define YY_EXTRA_TYPE void *
 536 #endif
 537
 538 static int yy_init_globals (void );
 539
 540 /* Accessor methods to globals.
 541    These are made visible to non-reentrant scanners for convenience. */
 542
 543 int yylex_destroy (void );
 544
 545 int yyget_debug (void );
 546
 547 void yyset_debug (int debug_flag  );
 548
 549 YY_EXTRA_TYPE yyget_extra (void );
 550
 551 void yyset_extra (YY_EXTRA_TYPE user_defined  );
 552
 553 FILE *yyget_in (void );
 554
 555 void yyset_in  (FILE * in_str  );
 556
 557 FILE *yyget_out (void );
 558
 559 void yyset_out  (FILE * out_str  );
 560
 561 int yyget_leng (void );
 562
 563 char *yyget_text (void );
 564
 565 int yyget_lineno (void );
 566
 567 void yyset_lineno (int line_number  );
 568
 569 /* Macros after this point can all be overridden by user definitions in
 570  * section 1.
 571  */
 572
 573 #ifndef YY_SKIP_YYWRAP
 574 #ifdef __cplusplus
 575 extern "C" int yywrap (void );
 576 #else
 577 extern int yywrap (void );
 578 #endif
 579 #endif
 580
 581     static void yyunput (int c,char *buf_ptr  );
 582
 583 #ifndef yytext_ptr
 584 static void yy_flex_strncpy (char *,yyconst char *,int );
 585 #endif
 586
 587 #ifdef YY_NEED_STRLEN
 588 static int yy_flex_strlen (yyconst char * );
 589 #endif
 590
 591 #ifndef YY_NO_INPUT
 592
 593 #ifdef __cplusplus
 594 static int yyinput (void );
 595 #else
 596 static int input (void );
 597 #endif
 598
 599 #endif
 600
 601 /* Amount of stuff to slurp up with each read. */
 602 #ifndef YY_READ_BUF_SIZE
 603 #define YY_READ_BUF_SIZE 8192
 604 #endif
 605
 606 /* Copy whatever the last rule matched to the standard output. */
 607 #ifndef ECHO
 608 /* This used to be an fputs(), but since the string might contain NUL's,
 609  * we now use fwrite().
 610  */
 611 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 612 #endif
 613
 614 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 615  * is returned in "result".
 616  */
 617 #ifndef YY_INPUT
 618 #define YY_INPUT(buf,result,max_size) \
 619         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 620                 { \
 621                 int c = '*'; \
 622                 unsigned n; \
 623                 for ( n = 0; n < max_size && \
 624                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 625                         buf[n] = (char) c; \
 626                 if ( c == '\n' ) \
 627                         buf[n++] = (char) c; \
 628                 if ( c == EOF && ferror( yyin ) ) \
 629                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 630                 result = n; \
 631                 } \
 632         else \
 633                 { \
 634                 errno=0; \
 635                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 636                         { \
 637                         if( errno != EINTR) \
 638                                 { \
 639                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 640                                 break; \
 641                                 } \
 642                         errno=0; \
 643                         clearerr(yyin); \
 644                         } \
 645                 }\
 646 \
 647
 648 #endif
 649
 650 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 651  * we don't want an extra ';' after the "return" because that will cause
 652  * some compilers to complain about unreachable statements.
 653  */
 654 #ifndef yyterminate
 655 #define yyterminate() return YY_NULL
 656 #endif
 657
 658 /* Number of entries by which start-condition stack grows. */
 659 #ifndef YY_START_STACK_INCR
 660 #define YY_START_STACK_INCR 25
 661 #endif
 662
 663 /* Report a fatal error. */
 664 #ifndef YY_FATAL_ERROR
 665 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 666 #endif
 667
 668 /* end tables serialization structures and prototypes */
 669
 670 /* Default declaration of generated scanner - a define so the user can
 671  * easily add parameters.
 672  */
 673 #ifndef YY_DECL
 674 #define YY_DECL_IS_OURS 1
 675
 676 extern int yylex (void);
 677
 678 #define YY_DECL int yylex (void)
 679 #endif /* !YY_DECL */
 680
 681 /* Code executed at the beginning of each rule, after yytext and yyleng
 682  * have been set up.
 683  */
 684 #ifndef YY_USER_ACTION
 685 #define YY_USER_ACTION
 686 #endif
 687
 688 /* Code executed at the end of each rule. */
 689 #ifndef YY_BREAK
 690 #define YY_BREAK break;
 691 #endif
 692
 693 #define YY_RULE_SETUP \
 694         YY_USER_ACTION
 695
 696 /** The main scanner function which does all the work.
 697  */
 698 YY_DECL
 699 {
 700         register yy_state_type yy_current_state;
 701         register char *yy_cp, *yy_bp;
 702         register int yy_act;
 703
 704 #line 9 "spotlight_rawquery_lexer.l"
 705
 706 #line 707 "spotlight_rawquery_lexer.c"
 707
 708         if ( !(yy_init) )
 709                 {
 710                 (yy_init) = 1;
 711
 712 #ifdef YY_USER_INIT
 713                 YY_USER_INIT;
 714 #endif
 715
 716                 if ( ! (yy_start) )
 717                         (yy_start) = 1; /* first start state */
 718
 719                 if ( ! yyin )
 720                         yyin = stdin;
 721
 722                 if ( ! yyout )
 723                         yyout = stdout;
 724
 725                 if ( ! YY_CURRENT_BUFFER ) {
 726                         yyensure_buffer_stack ();
 727                         YY_CURRENT_BUFFER_LVALUE =
 728                                 yy_create_buffer(yyin,YY_BUF_SIZE );
 729                 }
 730
 731                 yy_load_buffer_state( );
 732                 }
 733
 734         while ( 1 )             /* loops until end-of-file is reached */
 735                 {
 736                 yy_cp = (yy_c_buf_p);
 737
 738                 /* Support of yytext. */
 739                 *yy_cp = (yy_hold_char);
 740
 741                 /* yy_bp points to the position in yy_ch_buf of the start of
 742                  * the current run.
 743                  */
 744                 yy_bp = yy_cp;
 745
 746                 yy_current_state = (yy_start);
 747 yy_match:
 748                 do
 749                         {
 750                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 751                         if ( yy_accept[yy_current_state] )
 752                                 {
 753                                 (yy_last_accepting_state) = yy_current_state;
 754                                 (yy_last_accepting_cpos) = yy_cp;
 755                                 }
 756                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 757                                 {
 758                                 yy_current_state = (int) yy_def[yy_current_state];
 759                                 if ( yy_current_state >= 61 )
 760                                         yy_c = yy_meta[(unsigned int) yy_c];
 761                                 }
 762                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 763                         ++yy_cp;
 764                         }
 765                 while ( yy_base[yy_current_state] != 182 );
 766
 767 yy_find_action:
 768                 yy_act = yy_accept[yy_current_state];
 769                 if ( yy_act == 0 )
 770                         { /* have to back up */
 771                         yy_cp = (yy_last_accepting_cpos);
 772                         yy_current_state = (yy_last_accepting_state);
 773                         yy_act = yy_accept[yy_current_state];
 774                         }
 775
 776                 YY_DO_BEFORE_ACTION;
 777
 778 do_action:      /* This label is used only to access EOF actions. */
 779
 780                 switch ( yy_act )
 781         { /* beginning of action switch */
 782                         case 0: /* must back up */
 783                         /* undo the effects of YY_DO_BEFORE_ACTION */
 784                         *yy_cp = (yy_hold_char);
 785                         yy_cp = (yy_last_accepting_cpos);
 786                         yy_current_state = (yy_last_accepting_state);
 787                         goto yy_find_action;
 788
 789 case 1:
 790 YY_RULE_SETUP
 791 #line 10 "spotlight_rawquery_lexer.l"
 792 return FUNC_INRANGE;
 793         YY_BREAK
 794 case 2:
 795 YY_RULE_SETUP
 796 #line 11 "spotlight_rawquery_lexer.l"
 797 return DATE_SPEC;
 798         YY_BREAK
 799 case 3:
 800 YY_RULE_SETUP
 801 #line 12 "spotlight_rawquery_lexer.l"
 802 {yylval.sval = talloc_strdup(ssp_slq, yytext); return DATE;}
 803         YY_BREAK
 804 case 4:
 805 YY_RULE_SETUP
 806 #line 13 "spotlight_rawquery_lexer.l"
 807 /* ignore case specifier */
 808         YY_BREAK
 809 case 5:
 810 YY_RULE_SETUP
 811 #line 14 "spotlight_rawquery_lexer.l"
 812 {yylval.sval = talloc_strdup(ssp_slq, yytext); return WORD;}
 813         YY_BREAK
 814 case 6:
 815 YY_RULE_SETUP
 816 #line 15 "spotlight_rawquery_lexer.l"
 817 return QUOTE;
 818         YY_BREAK
 819 case 7:
 820 YY_RULE_SETUP
 821 #line 16 "spotlight_rawquery_lexer.l"
 822 return OBRACE;
 823         YY_BREAK
 824 case 8:
 825 YY_RULE_SETUP
 826 #line 17 "spotlight_rawquery_lexer.l"
 827 return CBRACE;
 828         YY_BREAK
 829 case 9:
 830 YY_RULE_SETUP
 831 #line 18 "spotlight_rawquery_lexer.l"
 832 return AND;
 833         YY_BREAK
 834 case 10:
 835 YY_RULE_SETUP
 836 #line 19 "spotlight_rawquery_lexer.l"
 837 return OR;
 838         YY_BREAK
 839 case 11:
 840 YY_RULE_SETUP
 841 #line 20 "spotlight_rawquery_lexer.l"
 842 return EQUAL;
 843         YY_BREAK
 844 case 12:
 845 YY_RULE_SETUP
 846 #line 21 "spotlight_rawquery_lexer.l"
 847 return COMMA;
 848         YY_BREAK
 849 case 13:
 850 /* rule 13 can match eol */
 851 YY_RULE_SETUP
 852 #line 22 "spotlight_rawquery_lexer.l"
 853 /* ignore */
 854         YY_BREAK
 855 case 14:
 856 YY_RULE_SETUP
 857 #line 23 "spotlight_rawquery_lexer.l"
 858 ECHO;
 859         YY_BREAK
 860 #line 861 "spotlight_rawquery_lexer.c"
 861 case YY_STATE_EOF(INITIAL):
 862         yyterminate();
 863
 864         case YY_END_OF_BUFFER:
 865                 {
 866                 /* Amount of text matched not including the EOB char. */
 867                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 868
 869                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 870                 *yy_cp = (yy_hold_char);
 871                 YY_RESTORE_YY_MORE_OFFSET
 872
 873                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 874                         {
 875                         /* We're scanning a new file or input source.  It's
 876                          * possible that this happened because the user
 877                          * just pointed yyin at a new source and called
 878                          * yylex().  If so, then we have to assure
 879                          * consistency between YY_CURRENT_BUFFER and our
 880                          * globals.  Here is the right place to do so, because
 881                          * this is the first action (other than possibly a
 882                          * back-up) that will match for the new input source.
 883                          */
 884                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 885                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 886                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 887                         }
 888
 889                 /* Note that here we test for yy_c_buf_p "<=" to the position
 890                  * of the first EOB in the buffer, since yy_c_buf_p will
 891                  * already have been incremented past the NUL character
 892                  * (since all states make transitions on EOB to the
 893                  * end-of-buffer state).  Contrast this with the test
 894                  * in input().
 895                  */
 896                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
 897                         { /* This was really a NUL. */
 898                         yy_state_type yy_next_state;
 899
 900                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 901
 902                         yy_current_state = yy_get_previous_state(  );
 903
 904                         /* Okay, we're now positioned to make the NUL
 905                          * transition.  We couldn't have
 906                          * yy_get_previous_state() go ahead and do it
 907                          * for us because it doesn't know how to deal
 908                          * with the possibility of jamming (and we don't
 909                          * want to build jamming into it because then it
 910                          * will run more slowly).
 911                          */
 912
 913                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 914
 915                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 916
 917                         if ( yy_next_state )
 918                                 {
 919                                 /* Consume the NUL. */
 920                                 yy_cp = ++(yy_c_buf_p);
 921                                 yy_current_state = yy_next_state;
 922                                 goto yy_match;
 923                                 }
 924
 925                         else
 926                                 {
 927                                 yy_cp = (yy_c_buf_p);
 928                                 goto yy_find_action;
 929                                 }
 930                         }
 931
 932                 else switch ( yy_get_next_buffer(  ) )
 933                         {
 934                         case EOB_ACT_END_OF_FILE:
 935                                 {
 936                                 (yy_did_buffer_switch_on_eof) = 0;
 937
 938                                 if ( yywrap( ) )
 939                                         {
 940                                         /* Note: because we've taken care in
 941                                          * yy_get_next_buffer() to have set up
 942                                          * yytext, we can now set up
 943                                          * yy_c_buf_p so that if some total
 944                                          * hoser (like flex itself) wants to
 945                                          * call the scanner after we return the
 946                                          * YY_NULL, it'll still work - another
 947                                          * YY_NULL will get returned.
 948                                          */
 949                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 950
 951                                         yy_act = YY_STATE_EOF(YY_START);
 952                                         goto do_action;
 953                                         }
 954
 955                                 else
 956                                         {
 957                                         if ( ! (yy_did_buffer_switch_on_eof) )
 958                                                 YY_NEW_FILE;
 959                                         }
 960                                 break;
 961                                 }
 962
 963                         case EOB_ACT_CONTINUE_SCAN:
 964                                 (yy_c_buf_p) =
 965                                         (yytext_ptr) + yy_amount_of_matched_text;
 966
 967                                 yy_current_state = yy_get_previous_state(  );
 968
 969                                 yy_cp = (yy_c_buf_p);
 970                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 971                                 goto yy_match;
 972
 973                         case EOB_ACT_LAST_MATCH:
 974                                 (yy_c_buf_p) =
 975                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 976
 977                                 yy_current_state = yy_get_previous_state(  );
 978
 979                                 yy_cp = (yy_c_buf_p);
 980                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 981                                 goto yy_find_action;
 982                         }
 983                 break;
 984                 }
 985
 986         default:
 987                 YY_FATAL_ERROR(
 988                         "fatal flex scanner internal error--no action found" );
 989         } /* end of action switch */
 990                 } /* end of scanning one token */
 991 } /* end of yylex */
 992
 993 /* yy_get_next_buffer - try to read in a new buffer
 994  *
 995  * Returns a code representing an action:
 996  *      EOB_ACT_LAST_MATCH -
 997  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 998  *      EOB_ACT_END_OF_FILE - end of file
 999  */
1000 static int yy_get_next_buffer (void)
1001 {
1002         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1003         register char *source = (yytext_ptr);
1004         register int number_to_move, i;
1005         int ret_val;
1006
1007         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1008                 YY_FATAL_ERROR(
1009                 "fatal flex scanner internal error--end of buffer missed" );
1010
1011         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1012                 { /* Don't try to fill the buffer, so this is an EOF. */
1013                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1014                         {
1015                         /* We matched a single character, the EOB, so
1016                          * treat this as a final EOF.
1017                          */
1018                         return EOB_ACT_END_OF_FILE;
1019                         }
1020
1021                 else
1022                         {
1023                         /* We matched some text prior to the EOB, first
1024                          * process it.
1025                          */
1026                         return EOB_ACT_LAST_MATCH;
1027                         }
1028                 }
1029
1030         /* Try to read more data. */
1031
1032         /* First move last chars to start of buffer. */
1033         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1034
1035         for ( i = 0; i < number_to_move; ++i )
1036                 *(dest++) = *(source++);
1037
1038         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1039                 /* don't do the read, it's not guaranteed to return an EOF,
1040                  * just force an EOF
1041                  */
1042                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1043
1044         else
1045                 {
1046                         int num_to_read =
1047                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1048
1049                 while ( num_to_read <= 0 )
1050                         { /* Not enough room in the buffer - grow it. */
1051
1052                         /* just a shorter name for the current buffer */
1053                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1054
1055                         int yy_c_buf_p_offset =
1056                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1057
1058                         if ( b->yy_is_our_buffer )
1059                                 {
1060                                 int new_size = b->yy_buf_size * 2;
1061
1062                                 if ( new_size <= 0 )
1063                                         b->yy_buf_size += b->yy_buf_size / 8;
1064                                 else
1065                                         b->yy_buf_size *= 2;
1066
1067                                 b->yy_ch_buf = (char *)
1068                                         /* Include room in for 2 EOB chars. */
1069                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1070                                 }
1071                         else
1072                                 /* Can't grow it, we don't own it. */
1073                                 b->yy_ch_buf = 0;
1074
1075                         if ( ! b->yy_ch_buf )
1076                                 YY_FATAL_ERROR(
1077                                 "fatal error - scanner input buffer overflow" );
1078
1079                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1080
1081                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1082                                                 number_to_move - 1;
1083
1084                         }
1085
1086                 if ( num_to_read > YY_READ_BUF_SIZE )
1087                         num_to_read = YY_READ_BUF_SIZE;
1088
1089                 /* Read in more data. */
1090                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1091                         (yy_n_chars), (size_t) num_to_read );
1092
1093                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1094                 }
1095
1096         if ( (yy_n_chars) == 0 )
1097                 {
1098                 if ( number_to_move == YY_MORE_ADJ )
1099                         {
1100                         ret_val = EOB_ACT_END_OF_FILE;
1101                         yyrestart(yyin  );
1102                         }
1103
1104                 else
1105                         {
1106                         ret_val = EOB_ACT_LAST_MATCH;
1107                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1108                                 YY_BUFFER_EOF_PENDING;
1109                         }
1110                 }
1111
1112         else
1113                 ret_val = EOB_ACT_CONTINUE_SCAN;
1114
1115         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1116                 /* Extend the array by 50%, plus the number we really need. */
1117                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1118                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1119                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1120                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1121         }
1122
1123         (yy_n_chars) += number_to_move;
1124         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1125         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1126
1127         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1128
1129         return ret_val;
1130 }
1131
1132 /* yy_get_previous_state - get the state just before the EOB char was reached */
1133
1134     static yy_state_type yy_get_previous_state (void)
1135 {
1136         register yy_state_type yy_current_state;
1137         register char *yy_cp;
1138
1139         yy_current_state = (yy_start);
1140
1141         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1142                 {
1143                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1144                 if ( yy_accept[yy_current_state] )
1145                         {
1146                         (yy_last_accepting_state) = yy_current_state;
1147                         (yy_last_accepting_cpos) = yy_cp;
1148                         }
1149                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1150                         {
1151                         yy_current_state = (int) yy_def[yy_current_state];
1152                         if ( yy_current_state >= 61 )
1153                                 yy_c = yy_meta[(unsigned int) yy_c];
1154                         }
1155                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1156                 }
1157
1158         return yy_current_state;
1159 }
1160
1161 /* yy_try_NUL_trans - try to make a transition on the NUL character
1162  *
1163  * synopsis
1164  *      next_state = yy_try_NUL_trans( current_state );
1165  */
1166     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1167 {
1168         register int yy_is_jam;
1169         register char *yy_cp = (yy_c_buf_p);
1170
1171         register YY_CHAR yy_c = 1;
1172         if ( yy_accept[yy_current_state] )
1173                 {
1174                 (yy_last_accepting_state) = yy_current_state;
1175                 (yy_last_accepting_cpos) = yy_cp;
1176                 }
1177         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1178                 {
1179                 yy_current_state = (int) yy_def[yy_current_state];
1180                 if ( yy_current_state >= 61 )
1181                         yy_c = yy_meta[(unsigned int) yy_c];
1182                 }
1183         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1184         yy_is_jam = (yy_current_state == 60);
1185
1186         return yy_is_jam ? 0 : yy_current_state;
1187 }
1188
1189     static void yyunput (int c, register char * yy_bp )
1190 {
1191         register char *yy_cp;
1192
1193     yy_cp = (yy_c_buf_p);
1194
1195         /* undo effects of setting up yytext */
1196         *yy_cp = (yy_hold_char);
1197
1198         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1199                 { /* need to shift things up to make room */
1200                 /* +2 for EOB chars. */
1201                 register int number_to_move = (yy_n_chars) + 2;
1202                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1203                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1204                 register char *source =
1205                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1206
1207                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1208                         *--dest = *--source;
1209
1210                 yy_cp += (int) (dest - source);
1211                 yy_bp += (int) (dest - source);
1212                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1213                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1214
1215                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1216                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1217                 }
1218
1219         *--yy_cp = (char) c;
1220
1221         (yytext_ptr) = yy_bp;
1222         (yy_hold_char) = *yy_cp;
1223         (yy_c_buf_p) = yy_cp;
1224 }
1225
1226 #ifndef YY_NO_INPUT
1227 #ifdef __cplusplus
1228     static int yyinput (void)
1229 #else
1230     static int input  (void)
1231 #endif
1232
1233 {
1234         int c;
1235
1236         *(yy_c_buf_p) = (yy_hold_char);
1237
1238         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1239                 {
1240                 /* yy_c_buf_p now points to the character we want to return.
1241                  * If this occurs *before* the EOB characters, then it's a
1242                  * valid NUL; if not, then we've hit the end of the buffer.
1243                  */
1244                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1245                         /* This was really a NUL. */
1246                         *(yy_c_buf_p) = '\0';
1247
1248                 else
1249                         { /* need more input */
1250                         int offset = (yy_c_buf_p) - (yytext_ptr);
1251                         ++(yy_c_buf_p);
1252
1253                         switch ( yy_get_next_buffer(  ) )
1254                                 {
1255                                 case EOB_ACT_LAST_MATCH:
1256                                         /* This happens because yy_g_n_b()
1257                                          * sees that we've accumulated a
1258                                          * token and flags that we need to
1259                                          * try matching the token before
1260                                          * proceeding.  But for input(),
1261                                          * there's no matching to consider.
1262                                          * So convert the EOB_ACT_LAST_MATCH
1263                                          * to EOB_ACT_END_OF_FILE.
1264                                          */
1265
1266                                         /* Reset buffer status. */
1267                                         yyrestart(yyin );
1268
1269                                         /*FALLTHROUGH*/
1270
1271                                 case EOB_ACT_END_OF_FILE:
1272                                         {
1273                                         if ( yywrap( ) )
1274                                                 return EOF;
1275
1276                                         if ( ! (yy_did_buffer_switch_on_eof) )
1277                                                 YY_NEW_FILE;
1278 #ifdef __cplusplus
1279                                         return yyinput();
1280 #else
1281                                         return input();
1282 #endif
1283                                         }
1284
1285                                 case EOB_ACT_CONTINUE_SCAN:
1286                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1287                                         break;
1288                                 }
1289                         }
1290                 }
1291
1292         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1293         *(yy_c_buf_p) = '\0';   /* preserve yytext */
1294         (yy_hold_char) = *++(yy_c_buf_p);
1295
1296         return c;
1297 }
1298 #endif  /* ifndef YY_NO_INPUT */
1299
1300 /** Immediately switch to a different input stream.
1301  * @param input_file A readable stream.
1302  *
1303  * @note This function does not reset the start condition to @c INITIAL .
1304  */
1305     void yyrestart  (FILE * input_file )
1306 {
1307
1308         if ( ! YY_CURRENT_BUFFER ){
1309         yyensure_buffer_stack ();
1310                 YY_CURRENT_BUFFER_LVALUE =
1311             yy_create_buffer(yyin,YY_BUF_SIZE );
1312         }
1313
1314         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1315         yy_load_buffer_state( );
1316 }
1317
1318 /** Switch to a different input buffer.
1319  * @param new_buffer The new input buffer.
1320  *
1321  */
1322     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1323 {
1324
1325         /* TODO. We should be able to replace this entire function body
1326          * with
1327          *              yypop_buffer_state();
1328          *              yypush_buffer_state(new_buffer);
1329      */
1330         yyensure_buffer_stack ();
1331         if ( YY_CURRENT_BUFFER == new_buffer )
1332                 return;
1333
1334         if ( YY_CURRENT_BUFFER )
1335                 {
1336                 /* Flush out information for old buffer. */
1337                 *(yy_c_buf_p) = (yy_hold_char);
1338                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1339                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1340                 }
1341
1342         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1343         yy_load_buffer_state( );
1344
1345         /* We don't actually know whether we did this switch during
1346          * EOF (yywrap()) processing, but the only time this flag
1347          * is looked at is after yywrap() is called, so it's safe
1348          * to go ahead and always set it.
1349          */
1350         (yy_did_buffer_switch_on_eof) = 1;
1351 }
1352
1353 static void yy_load_buffer_state  (void)
1354 {
1355         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1356         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1357         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1358         (yy_hold_char) = *(yy_c_buf_p);
1359 }
1360
1361 /** Allocate and initialize an input buffer state.
1362  * @param file A readable stream.
1363  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1364  *
1365  * @return the allocated buffer state.
1366  */
1367     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
1368 {
1369         YY_BUFFER_STATE b;
1370
1371         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1372         if ( ! b )
1373                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1374
1375         b->yy_buf_size = size;
1376
1377         /* yy_ch_buf has to be 2 characters longer than the size given because
1378          * we need to put in 2 end-of-buffer characters.
1379          */
1380         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
1381         if ( ! b->yy_ch_buf )
1382                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1383
1384         b->yy_is_our_buffer = 1;
1385
1386         yy_init_buffer(b,file );
1387
1388         return b;
1389 }
1390
1391 /** Destroy the buffer.
1392  * @param b a buffer created with yy_create_buffer()
1393  *
1394  */
1395     void yy_delete_buffer (YY_BUFFER_STATE  b )
1396 {
1397
1398         if ( ! b )
1399                 return;
1400
1401         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1402                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1403
1404         if ( b->yy_is_our_buffer )
1405                 yyfree((void *) b->yy_ch_buf  );
1406
1407         yyfree((void *) b  );
1408 }
1409
1410 #ifndef __cplusplus
1411 extern int isatty (int );
1412 #endif /* __cplusplus */
1413
1414 /* Initializes or reinitializes a buffer.
1415  * This function is sometimes called more than once on the same buffer,
1416  * such as during a yyrestart() or at EOF.
1417  */
1418     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1419
1420 {
1421         int oerrno = errno;
1422
1423         yy_flush_buffer(b );
1424
1425         b->yy_input_file = file;
1426         b->yy_fill_buffer = 1;
1427
1428     /* If b is the current buffer, then yy_init_buffer was _probably_
1429      * called from yyrestart() or through yy_get_next_buffer.
1430      * In that case, we don't want to reset the lineno or column.
1431      */
1432     if (b != YY_CURRENT_BUFFER){
1433         b->yy_bs_lineno = 1;
1434         b->yy_bs_column = 0;
1435     }
1436
1437         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1438
1439         errno = oerrno;
1440 }
1441
1442 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1443  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1444  *
1445  */
1446     void yy_flush_buffer (YY_BUFFER_STATE  b )
1447 {
1448         if ( ! b )
1449                 return;
1450
1451         b->yy_n_chars = 0;
1452
1453         /* We always need two end-of-buffer characters.  The first causes
1454          * a transition to the end-of-buffer state.  The second causes
1455          * a jam in that state.
1456          */
1457         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1458         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1459
1460         b->yy_buf_pos = &b->yy_ch_buf[0];
1461
1462         b->yy_at_bol = 1;
1463         b->yy_buffer_status = YY_BUFFER_NEW;
1464
1465         if ( b == YY_CURRENT_BUFFER )
1466                 yy_load_buffer_state( );
1467 }
1468
1469 /** Pushes the new state onto the stack. The new state becomes
1470  *  the current state. This function will allocate the stack
1471  *  if necessary.
1472  *  @param new_buffer The new state.
1473  *
1474  */
1475 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1476 {
1477         if (new_buffer == NULL)
1478                 return;
1479
1480         yyensure_buffer_stack();
1481
1482         /* This block is copied from yy_switch_to_buffer. */
1483         if ( YY_CURRENT_BUFFER )
1484                 {
1485                 /* Flush out information for old buffer. */
1486                 *(yy_c_buf_p) = (yy_hold_char);
1487                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1488                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1489                 }
1490
1491         /* Only push if top exists. Otherwise, replace top. */
1492         if (YY_CURRENT_BUFFER)
1493                 (yy_buffer_stack_top)++;
1494         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1495
1496         /* copied from yy_switch_to_buffer. */
1497         yy_load_buffer_state( );
1498         (yy_did_buffer_switch_on_eof) = 1;
1499 }
1500
1501 /** Removes and deletes the top of the stack, if present.
1502  *  The next element becomes the new top.
1503  *
1504  */
1505 void yypop_buffer_state (void)
1506 {
1507         if (!YY_CURRENT_BUFFER)
1508                 return;
1509
1510         yy_delete_buffer(YY_CURRENT_BUFFER );
1511         YY_CURRENT_BUFFER_LVALUE = NULL;
1512         if ((yy_buffer_stack_top) > 0)
1513                 --(yy_buffer_stack_top);
1514
1515         if (YY_CURRENT_BUFFER) {
1516                 yy_load_buffer_state( );
1517                 (yy_did_buffer_switch_on_eof) = 1;
1518         }
1519 }
1520
1521 /* Allocates the stack if it does not exist.
1522  *  Guarantees space for at least one push.
1523  */
1524 static void yyensure_buffer_stack (void)
1525 {
1526         int num_to_alloc;
1527
1528         if (!(yy_buffer_stack)) {
1529
1530                 /* First allocation is just for 2 elements, since we don't know if this
1531                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1532                  * immediate realloc on the next call.
1533          */
1534                 num_to_alloc = 1;
1535                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1536                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1537                                                                 );
1538                 if ( ! (yy_buffer_stack) )
1539                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1540
1541                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1542
1543                 (yy_buffer_stack_max) = num_to_alloc;
1544                 (yy_buffer_stack_top) = 0;
1545                 return;
1546         }
1547
1548         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1549
1550                 /* Increase the buffer to prepare for a possible push. */
1551                 int grow_size = 8 /* arbitrary grow size */;
1552
1553                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1554                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1555                                                                 ((yy_buffer_stack),
1556                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1557                                                                 );
1558                 if ( ! (yy_buffer_stack) )
1559                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1560
1561                 /* zero only the new slots.*/
1562                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1563                 (yy_buffer_stack_max) = num_to_alloc;
1564         }
1565 }
1566
1567 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1568  * @param base the character buffer
1569  * @param size the size in bytes of the character buffer
1570  *
1571  * @return the newly allocated buffer state object.
1572  */
1573 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
1574 {
1575         YY_BUFFER_STATE b;
1576
1577         if ( size < 2 ||
1578              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1579              base[size-1] != YY_END_OF_BUFFER_CHAR )
1580                 /* They forgot to leave room for the EOB's. */
1581                 return 0;
1582
1583         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1584         if ( ! b )
1585                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1586
1587         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1588         b->yy_buf_pos = b->yy_ch_buf = base;
1589         b->yy_is_our_buffer = 0;
1590         b->yy_input_file = 0;
1591         b->yy_n_chars = b->yy_buf_size;
1592         b->yy_is_interactive = 0;
1593         b->yy_at_bol = 1;
1594         b->yy_fill_buffer = 0;
1595         b->yy_buffer_status = YY_BUFFER_NEW;
1596
1597         yy_switch_to_buffer(b  );
1598
1599         return b;
1600 }
1601
1602 /** Setup the input buffer state to scan a string. The next call to yylex() will
1603  * scan from a @e copy of @a str.
1604  * @param yystr a NUL-terminated string to scan
1605  *
1606  * @return the newly allocated buffer state object.
1607  * @note If you want to scan bytes that may contain NUL values, then use
1608  *       yy_scan_bytes() instead.
1609  */
1610 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1611 {
1612
1613         return yy_scan_bytes(yystr,strlen(yystr) );
1614 }
1615
1616 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1617  * scan from a @e copy of @a bytes.
1618  * @param bytes the byte buffer to scan
1619  * @param len the number of bytes in the buffer pointed to by @a bytes.
1620  *
1621  * @return the newly allocated buffer state object.
1622  */
1623 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1624 {
1625         YY_BUFFER_STATE b;
1626         char *buf;
1627         yy_size_t n;
1628         int i;
1629
1630         /* Get memory for full buffer, including space for trailing EOB's. */
1631         n = _yybytes_len + 2;
1632         buf = (char *) yyalloc(n  );
1633         if ( ! buf )
1634                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1635
1636         for ( i = 0; i < _yybytes_len; ++i )
1637                 buf[i] = yybytes[i];
1638
1639         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1640
1641         b = yy_scan_buffer(buf,n );
1642         if ( ! b )
1643                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1644
1645         /* It's okay to grow etc. this buffer, and we should throw it
1646          * away when we're done.
1647          */
1648         b->yy_is_our_buffer = 1;
1649
1650         return b;
1651 }
1652
1653 #ifndef YY_EXIT_FAILURE
1654 #define YY_EXIT_FAILURE 2
1655 #endif
1656
1657 static void yy_fatal_error (yyconst char* msg )
1658 {
1659         (void) fprintf( stderr, "%s\n", msg );
1660         exit( YY_EXIT_FAILURE );
1661 }
1662
1663 /* Redefine yyless() so it works in section 3 code. */
1664
1665 #undef yyless
1666 #define yyless(n) \
1667         do \
1668                 { \
1669                 /* Undo effects of setting up yytext. */ \
1670         int yyless_macro_arg = (n); \
1671         YY_LESS_LINENO(yyless_macro_arg);\
1672                 yytext[yyleng] = (yy_hold_char); \
1673                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1674                 (yy_hold_char) = *(yy_c_buf_p); \
1675                 *(yy_c_buf_p) = '\0'; \
1676                 yyleng = yyless_macro_arg; \
1677                 } \
1678         while ( 0 )
1679
1680 /* Accessor  methods (get/set functions) to struct members. */
1681
1682 /** Get the current line number.
1683  *
1684  */
1685 int yyget_lineno  (void)
1686 {
1687
1688     return yylineno;
1689 }
1690
1691 /** Get the input stream.
1692  *
1693  */
1694 FILE *yyget_in  (void)
1695 {
1696         return yyin;
1697 }
1698
1699 /** Get the output stream.
1700  *
1701  */
1702 FILE *yyget_out  (void)
1703 {
1704         return yyout;
1705 }
1706
1707 /** Get the length of the current token.
1708  *
1709  */
1710 int yyget_leng  (void)
1711 {
1712         return yyleng;
1713 }
1714
1715 /** Get the current token.
1716  *
1717  */
1718
1719 char *yyget_text  (void)
1720 {
1721         return yytext;
1722 }
1723
1724 /** Set the current line number.
1725  * @param line_number
1726  *
1727  */
1728 void yyset_lineno (int  line_number )
1729 {
1730
1731     yylineno = line_number;
1732 }
1733
1734 /** Set the input stream. This does not discard the current
1735  * input buffer.
1736  * @param in_str A readable stream.
1737  *
1738  * @see yy_switch_to_buffer
1739  */
1740 void yyset_in (FILE *  in_str )
1741 {
1742         yyin = in_str ;
1743 }
1744
1745 void yyset_out (FILE *  out_str )
1746 {
1747         yyout = out_str ;
1748 }
1749
1750 int yyget_debug  (void)
1751 {
1752         return yy_flex_debug;
1753 }
1754
1755 void yyset_debug (int  bdebug )
1756 {
1757         yy_flex_debug = bdebug ;
1758 }
1759
1760 static int yy_init_globals (void)
1761 {
1762         /* Initialization is the same as for the non-reentrant scanner.
1763      * This function is called from yylex_destroy(), so don't allocate here.
1764      */
1765
1766     (yy_buffer_stack) = 0;
1767     (yy_buffer_stack_top) = 0;
1768     (yy_buffer_stack_max) = 0;
1769     (yy_c_buf_p) = (char *) 0;
1770     (yy_init) = 0;
1771     (yy_start) = 0;
1772
1773 /* Defined in main.c */
1774 #ifdef YY_STDINIT
1775     yyin = stdin;
1776     yyout = stdout;
1777 #else
1778     yyin = (FILE *) 0;
1779     yyout = (FILE *) 0;
1780 #endif
1781
1782     /* For future reference: Set errno on error, since we are called by
1783      * yylex_init()
1784      */
1785     return 0;
1786 }
1787
1788 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1789 int yylex_destroy  (void)
1790 {
1791
1792     /* Pop the buffer stack, destroying each element. */
1793         while(YY_CURRENT_BUFFER){
1794                 yy_delete_buffer(YY_CURRENT_BUFFER  );
1795                 YY_CURRENT_BUFFER_LVALUE = NULL;
1796                 yypop_buffer_state();
1797         }
1798
1799         /* Destroy the stack itself. */
1800         yyfree((yy_buffer_stack) );
1801         (yy_buffer_stack) = NULL;
1802
1803     /* Reset the globals. This is important in a non-reentrant scanner so the next time
1804      * yylex() is called, initialization will occur. */
1805     yy_init_globals( );
1806
1807     return 0;
1808 }
1809
1810 /*
1811  * Internal utility routines.
1812  */
1813
1814 #ifndef yytext_ptr
1815 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1816 {
1817         register int i;
1818         for ( i = 0; i < n; ++i )
1819                 s1[i] = s2[i];
1820 }
1821 #endif
1822
1823 #ifdef YY_NEED_STRLEN
1824 static int yy_flex_strlen (yyconst char * s )
1825 {
1826         register int n;
1827         for ( n = 0; s[n]; ++n )
1828                 ;
1829
1830         return n;
1831 }
1832 #endif
1833
1834 void *yyalloc (yy_size_t  size )
1835 {
1836         return (void *) malloc( size );
1837 }
1838
1839 void *yyrealloc  (void * ptr, yy_size_t  size )
1840 {
1841         /* The cast to (char *) in the following accommodates both
1842          * implementations that use char* generic pointers, and those
1843          * that use void* generic pointers.  It works with the latter
1844          * because both ANSI C and C++ allow castless assignment from
1845          * any pointer type to void*, and deal with argument conversions
1846          * as though doing an assignment.
1847          */
1848         return (void *) realloc( (char *) ptr, size );
1849 }
1850
1851 void yyfree (void * ptr )
1852 {
1853         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
1854 }
1855
1856 #define YYTABLES_NAME "yytables"
1857
1858 #line 23 "spotlight_rawquery_lexer.l"
1859
1860
1861