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