1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 * anjuta
4 * Copyright (C) Eran Ifrah (Main file for CodeLite www.codelite.org/ )
5 * Copyright (C) Massimo Cora' 2009 <maxcvs@email.it> (Customizations for Anjuta)
6 *
7 * anjuta is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * anjuta is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15 * See the GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 //////////////////////////////////////////////////////////////////////////////
22 //////////////////////////////////////////////////////////////////////////////
23 //
24 // copyright : (C) 2008 by Eran Ifrah
25 // file name : lex.yy.cpp
26 //
27 // -------------------------------------------------------------------------
28 // A
29 // _____ _ _ _ _
30 // / __ \ | | | | (_) |
31 // | / \/ ___ __| | ___| | _| |_ ___
32 // | | / _ \ / _ |/ _ \ | | | __/ _ )
33 // | \__/\ (_) | (_| | __/ |___| | || __/
34 // \____/\___/ \__,_|\___\_____/_|\__\___|
35 //
36 // F i l e
37 //
38 // This program is free software; you can redistribute it and/or modify
39 // it under the terms of the GNU General Public License as published by
40 // the Free Software Foundation; either version 2 of the License, or
41 // (at your option) any later version.
42 //
43 //////////////////////////////////////////////////////////////////////////////
44 //////////////////////////////////////////////////////////////////////////////
45 /* A lexical scanner generated by flex */
46
47 /* Scanner skeleton version:
48 * $Header: /CVS/wxUS/wxXtudio/Apps/USClient/lex.yy.cpp,v 1.3 2005/12/13 07:53:23 eran Exp $
49 */
50
51 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
52 #ifdef c_plusplus
53 #ifndef __cplusplus
54 #define __cplusplus
55 #endif
56 #endif
57
58 #ifdef __cplusplus
59 #include <stdlib.h>
60 #include <unistd.h>
61 #include <iostream>
62
63 #include "flex-lexer-klass.h"
64 #endif
65
66 namespace flex
67 {
68
69 #define FLEX_SCANNER
70 #define YY_FLEX_MAJOR_VERSION 2
71 #define YY_FLEX_MINOR_VERSION 5
72
73 #ifdef __cplusplus
74
75 /* Use prototypes in function declarations. */
76 #define YY_USE_PROTOS
77
78 /* The "const" storage-class-modifier is valid. */
79 #define YY_USE_CONST
80
81 #else /* ! __cplusplus */
82
83 #if __STDC__
84
85 #define YY_USE_PROTOS
86 #define YY_USE_CONST
87
88 #endif /* __STDC__ */
89 #endif /* ! __cplusplus */
90
91 #ifdef __TURBOC__
92 #pragma warn -rch
93 #pragma warn -use
94 #include <io.h>
95 #include <stdlib.h>
96 #define YY_USE_CONST
97 #define YY_USE_PROTOS
98 #endif
99
100 #ifdef YY_USE_CONST
101 #define yyconst const
102 #else
103 #define yyconst
104 #endif
105
106
107 #ifdef YY_USE_PROTOS
108 #define YY_PROTO(proto) proto
109 #else
110 #define YY_PROTO(proto) ()
111 #endif
112
113 /* Returned upon end-of-file. */
114 #define YY_NULL 0
115
116 /* Promotes a possibly negative, possibly signed char to an unsigned
117 * integer for use as an array index. If the signed char is negative,
118 * we want to instead treat it as an 8-bit unsigned char, hence the
119 * double cast.
120 */
121 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
122
123 /* Enter a start condition. This macro really ought to take a parameter,
124 * but we do it the disgusting crufty way forced on us by the ()-less
125 * definition of BEGIN.
126 */
127 #define BEGIN yy_start = 1 + 2 *
128
129 /* Translate the current start state into a value that can be later handed
130 * to BEGIN to return to the state. The YYSTATE alias is for lex
131 * compatibility.
132 */
133 #define YY_START ((yy_start - 1) / 2)
134 #define YYSTATE YY_START
135
136 /* Action number for EOF rule of a given start state. */
137 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
138
139 /* Special action meaning "start processing a new file". */
140 #define YY_NEW_FILE yyrestart( yyin )
141
142 #define YY_END_OF_BUFFER_CHAR 0
143
144 /* Size of default input buffer. */
145 #define YY_BUF_SIZE 16384
146
147 typedef struct yy_buffer_state *YY_BUFFER_STATE;
148
149 extern int yyleng;
150
151 #define EOB_ACT_CONTINUE_SCAN 0
152 #define EOB_ACT_END_OF_FILE 1
153 #define EOB_ACT_LAST_MATCH 2
154
155 /* The funky do-while in the following #define is used to turn the definition
156 * int a single C statement (which needs a semi-colon terminator). This
157 * avoids problems with code like:
158 *
159 * if ( condition_holds )
160 * yyless( 5 );
161 * else
162 * do_something_else();
163 *
164 * Prior to using the do-while the compiler would get upset at the
165 * "else" because it interpreted the "if" statement as being all
166 * done when it reached the ';' after the yyless() call.
167 */
168
169 /* Return all but the first 'n' matched characters back to the input stream. */
170
171 #define yyless(n) \
172 do \
173 { \
174 /* Undo effects of setting up yytext. */ \
175 *yy_cp = yy_hold_char; \
176 YY_RESTORE_YY_MORE_OFFSET \
177 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
178 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
179 } \
180 while ( 0 )
181
182 #define unput(c) yyunput( c, yytext_ptr )
183
184 /* The following is because we cannot portably get our hands on size_t
185 * (without autoconf's help, which isn't available because we want
186 * flex-generated scanners to compile on their own).
187 */
188 typedef unsigned int yy_size_t;
189
190
191 struct yy_buffer_state
192 {
193 std::istream* yy_input_file;
194
195 char *yy_ch_buf; /* input buffer */
196 char *yy_buf_pos; /* current position in input buffer */
197
198 /* Size of input buffer in bytes, not including room for EOB
199 * characters.
200 */
201 yy_size_t yy_buf_size;
202
203 /* Number of characters read into yy_ch_buf, not including EOB
204 * characters.
205 */
206 int yy_n_chars;
207
208 /* Whether we "own" the buffer - i.e., we know we created it,
209 * and can realloc() it to grow it, and should free() it to
210 * delete it.
211 */
212 int yy_is_our_buffer;
213
214 /* Whether this is an "interactive" input source; if so, and
215 * if we're using stdio for input, then we want to use getc()
216 * instead of fread(), to make sure we stop fetching input after
217 * each newline.
218 */
219 int yy_is_interactive;
220
221 /* Whether we're considered to be at the beginning of a line.
222 * If so, '^' rules will be active on the next match, otherwise
223 * not.
224 */
225 int yy_at_bol;
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 #define YY_BUFFER_NEW 0
234 #define YY_BUFFER_NORMAL 1
235 /* When an EOF's been seen but there's still some text to process
236 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
237 * shouldn't try reading from the input source any more. We might
238 * still have a bunch of tokens to match, though, because of
239 * possible backing-up.
240 *
241 * When we actually see the EOF, we change the status to "new"
242 * (via yyrestart()), so that the user can continue scanning by
243 * just pointing yyin at a new input file.
244 */
245 #define YY_BUFFER_EOF_PENDING 2
246
247 };
248
249
250 /* We provide macros for accessing buffer states in case in the
251 * future we want to put the buffer states in a more general
252 * "scanner state".
253 */
254 #define YY_CURRENT_BUFFER yy_current_buffer
255
256
257
258 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
259 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
260 static void yy_flex_free YY_PROTO(( void * ));
261
262 #define yy_new_buffer yy_create_buffer
263
264 #define yy_set_interactive(is_interactive) \
265 { \
266 if ( ! yy_current_buffer ) \
267 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
268 yy_current_buffer->yy_is_interactive = is_interactive; \
269 }
270
271 #define yy_set_bol(at_bol) \
272 { \
273 if ( ! yy_current_buffer ) \
274 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
275 yy_current_buffer->yy_at_bol = at_bol; \
276 }
277
278 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
279
280
281 #define YY_USES_REJECT
282 typedef unsigned char YY_CHAR;
283 #define yytext_ptr yytext
284 #define YY_INTERACTIVE
285
286 /* Done after the current pattern has been matched and before the
287 * corresponding action - sets up yytext.
288 */
289 #define YY_DO_BEFORE_ACTION \
290 yytext_ptr = yy_bp; \
291 yyleng = (int) (yy_cp - yy_bp); \
292 yy_hold_char = *yy_cp; \
293 *yy_cp = '\0'; \
294 yy_c_buf_p = yy_cp;
295
296 #define YY_NUM_RULES 121
297 #define YY_END_OF_BUFFER 122
298 static yyconst short int yy_acclist[493] =
299 { 0,
300 122, 120, 121, 3, 120, 121, 5, 121, 4, 120,
301 121, 84, 120, 121, 120, 121, 72, 120, 121, 86,
302 120, 121, 79, 120, 121, 120, 121, 69, 120, 121,
303 70, 120, 121, 80, 120, 121, 81, 120, 121, 71,
304 120, 121, 82, 120, 121, 78, 120, 121, 85, 120,
305 121, 64, 120, 121, 63, 120, 121, 92, 120, 121,
306 93, 120, 121, 87, 120, 121, 94, 120, 121, 88,
307 120, 121, 91, 120, 121, 62, 120, 121, 62, 120,
308 121, 76, 120, 121, 77, 120, 121, 89, 120, 121,
309 62, 120, 121, 62, 120, 121, 62, 120, 121, 62,
310
311 120, 121, 62, 120, 121, 62, 120, 121, 62, 120,
312 121, 62, 120, 121, 62, 120, 121, 62, 120, 121,
313 62, 120, 121, 62, 120, 121, 62, 120, 121, 62,
314 120, 121, 62, 120, 121, 62, 120, 121, 62, 120,
315 121, 62, 120, 121, 74, 120, 121, 90, 120, 121,
316 75, 120, 121, 83, 120, 121, 3, 5, 4, 106,
317 68, 73, 111, 107, 116, 109, 99, 112, 100, 113,
318 97, 95, 66, 1, 2, 110, 66, 64, 64, 64,
319 63, 63, 63, 96, 101, 103, 105, 104, 102, 62,
320 117, 62, 62, 62, 62, 62, 62, 62, 15, 62,
321
322 62, 62, 62, 62, 62, 62, 62, 62, 26, 62,
323 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
324 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
325 118, 108, 67, 98, 119, 66, 66, 64, 65, 63,
326 114, 115, 62, 62, 62, 62, 62, 62, 62, 62,
327 62, 62, 62, 62, 62, 62, 62, 62, 24, 62,
328 62, 62, 62, 62, 62, 62, 30, 62, 62, 62,
329 62, 54, 62, 62, 62, 62, 62, 62, 62, 62,
330 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
331 62, 62, 62, 62, 62, 62, 66, 65, 65, 6,
332
333 62, 62, 8, 62, 9, 62, 62, 62, 62, 62,
334 62, 62, 62, 17, 62, 18, 62, 62, 20, 62,
335 62, 62, 62, 62, 25, 62, 62, 62, 62, 62,
336 31, 62, 32, 62, 62, 62, 62, 62, 62, 62,
337 62, 62, 62, 62, 62, 62, 62, 62, 62, 60,
338 62, 62, 62, 62, 62, 62, 46, 62, 62, 62,
339 65, 7, 62, 49, 62, 10, 62, 62, 62, 62,
340 62, 62, 19, 62, 21, 62, 62, 23, 62, 62,
341 27, 62, 62, 62, 62, 62, 62, 62, 62, 62,
342 62, 62, 62, 62, 36, 62, 62, 62, 62, 62,
343
344 62, 62, 43, 62, 44, 62, 62, 62, 62, 48,
345 62, 62, 62, 13, 62, 51, 62, 16, 62, 22,
346 62, 52, 62, 28, 62, 62, 53, 62, 62, 62,
347 62, 33, 62, 62, 62, 59, 62, 62, 35, 62,
348 37, 62, 38, 62, 39, 62, 40, 62, 41, 62,
349 62, 62, 62, 62, 62, 12, 62, 14, 62, 29,
350 62, 62, 62, 62, 58, 62, 62, 62, 42, 62,
351 62, 61, 62, 62, 11, 62, 62, 55, 62, 56,
352 62, 62, 34, 62, 45, 62, 47, 62, 50, 62,
353 57, 62
354
355 } ;
356
357 static yyconst short int yy_accept[365] =
358 { 0,
359 1, 1, 1, 2, 4, 7, 9, 12, 15, 17,
360 20, 23, 26, 28, 31, 34, 37, 40, 43, 46,
361 49, 52, 55, 58, 61, 64, 67, 70, 73, 76,
362 79, 82, 85, 88, 91, 94, 97, 100, 103, 106,
363 109, 112, 115, 118, 121, 124, 127, 130, 133, 136,
364 139, 142, 145, 148, 151, 154, 157, 158, 159, 159,
365 160, 161, 161, 162, 162, 163, 164, 165, 166, 166,
366 166, 167, 168, 169, 170, 171, 172, 173, 173, 174,
367 175, 176, 177, 178, 179, 179, 179, 180, 181, 181,
368 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
369
370 191, 191, 192, 193, 194, 195, 196, 197, 198, 199,
371 201, 202, 203, 204, 205, 206, 207, 208, 209, 211,
372 212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
373 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
374 232, 233, 233, 233, 234, 234, 234, 235, 236, 236,
375 237, 237, 238, 239, 240, 241, 242, 243, 244, 245,
376 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
377 256, 257, 258, 259, 261, 262, 263, 264, 265, 266,
378 267, 269, 270, 271, 272, 274, 275, 276, 277, 278,
379 279, 280, 281, 282, 283, 284, 285, 286, 287, 288,
380
381 289, 290, 291, 292, 293, 294, 295, 296, 297, 297,
382 297, 297, 297, 297, 298, 299, 300, 302, 303, 305,
383 307, 308, 309, 310, 311, 312, 313, 314, 316, 318,
384 319, 321, 322, 323, 324, 325, 327, 328, 329, 330,
385 331, 333, 335, 336, 337, 338, 339, 340, 341, 342,
386 343, 344, 345, 346, 347, 348, 349, 350, 352, 353,
387 354, 355, 356, 357, 359, 360, 361, 361, 361, 361,
388 361, 362, 364, 366, 368, 369, 370, 371, 372, 373,
389 375, 377, 378, 380, 381, 383, 384, 385, 386, 387,
390 388, 389, 390, 391, 392, 393, 394, 395, 397, 398,
391
392 399, 400, 401, 402, 403, 405, 407, 408, 409, 410,
393 412, 413, 414, 416, 418, 420, 422, 424, 426, 427,
394 429, 430, 431, 432, 434, 435, 436, 438, 439, 441,
395 443, 445, 447, 449, 451, 452, 453, 454, 455, 456,
396 458, 460, 462, 463, 464, 465, 467, 468, 469, 471,
397 472, 474, 475, 477, 478, 480, 482, 483, 485, 487,
398 489, 491, 493, 493
399 } ;
400
401 static yyconst int yy_ec[256] =
402 { 0,
403 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
404 4, 5, 6, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 7, 8, 9, 10, 1, 11, 12, 13, 14,
407 15, 16, 17, 18, 19, 20, 21, 22, 23, 23,
408 23, 23, 23, 23, 23, 24, 24, 25, 26, 27,
409 28, 29, 30, 1, 31, 31, 31, 31, 32, 33,
410 34, 34, 34, 34, 34, 35, 34, 34, 34, 34,
411 34, 34, 34, 34, 36, 34, 34, 37, 34, 34,
412 38, 39, 40, 41, 34, 1, 42, 43, 44, 45,
413
414 46, 47, 48, 49, 50, 34, 51, 52, 53, 54,
415 55, 56, 34, 57, 58, 59, 60, 61, 62, 63,
416 64, 65, 66, 67, 68, 69, 1, 1, 1, 1,
417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424
425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
427 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
430 1, 1, 1, 1, 1
431 } ;
432
433 static yyconst int yy_meta[70] =
434 { 0,
435 1, 1, 2, 1, 1, 1, 1, 1, 3, 1,
436 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
437 1, 5, 5, 6, 1, 1, 1, 1, 1, 3,
438 6, 6, 6, 7, 7, 7, 7, 1, 3, 1,
439 1, 5, 5, 6, 6, 6, 5, 7, 7, 7,
440 7, 7, 7, 8, 7, 7, 8, 7, 8, 7,
441 8, 7, 8, 7, 7, 1, 1, 1, 1
442 } ;
443
444 static yyconst short int yy_base[372] =
445 { 0,
446 0, 0, 570, 571, 68, 571, 74, 541, 73, 558,
447 539, 71, 527, 571, 571, 537, 67, 571, 68, 69,
448 82, 93, 100, 539, 571, 73, 535, 76, 571, 0,
449 77, 571, 571, 534, 501, 503, 85, 56, 105, 86,
450 504, 60, 71, 102, 86, 49, 512, 105, 69, 503,
451 108, 507, 571, 103, 571, 571, 169, 571, 175, 181,
452 571, 110, 571, 128, 571, 571, 571, 571, 153, 167,
453 571, 571, 571, 571, 571, 539, 571, 534, 171, 571,
454 571, 571, 175, 209, 192, 229, 160, 167, 0, 236,
455 165, 174, 571, 525, 571, 571, 571, 524, 0, 196,
456
457 512, 571, 491, 503, 490, 505, 504, 491, 187, 484,
458 111, 168, 486, 483, 486, 483, 489, 479, 195, 198,
459 483, 482, 482, 472, 487, 486, 212, 488, 152, 475,
460 199, 221, 479, 478, 471, 225, 469, 224, 475, 571,
461 571, 264, 0, 571, 267, 0, 571, 571, 275, 571,
462 278, 285, 571, 269, 571, 571, 571, 469, 481, 476,
463 464, 462, 178, 235, 473, 475, 470, 470, 465, 461,
464 458, 466, 469, 0, 464, 454, 462, 462, 454, 455,
465 0, 458, 455, 456, 0, 444, 443, 451, 437, 438,
466 444, 445, 434, 436, 438, 445, 431, 429, 429, 429,
467
468 440, 439, 429, 433, 423, 436, 438, 427, 301, 332,
469 303, 367, 289, 335, 255, 279, 0, 427, 0, 0,
470 419, 417, 425, 414, 419, 413, 419, 0, 0, 423,
471 0, 412, 411, 408, 412, 0, 418, 418, 403, 408,
472 0, 0, 403, 418, 407, 405, 415, 410, 405, 396,
473 396, 386, 398, 384, 388, 382, 380, 0, 371, 361,
474 353, 357, 344, 0, 344, 356, 256, 0, 280, 0,
475 571, 0, 0, 0, 347, 345, 350, 349, 348, 0,
476 0, 339, 0, 347, 0, 341, 341, 339, 328, 324,
477 326, 331, 313, 325, 323, 307, 308, 0, 316, 313,
478
479 309, 293, 302, 304, 0, 0, 295, 306, 297, 0,
480 286, 286, 299, 0, 0, 0, 0, 0, 297, 0,
481 297, 283, 294, 0, 289, 275, 0, 287, 0, 0,
482 0, 0, 0, 0, 283, 282, 275, 270, 271, 0,
483 0, 0, 240, 224, 234, 0, 220, 186, 0, 120,
484 0, 62, 0, 48, 0, 0, 43, 0, 0, 0,
485 0, 0, 571, 414, 422, 426, 432, 438, 442, 444,
486 446
487 } ;
488
489 static yyconst short int yy_def[372] =
490 { 0,
491 363, 1, 363, 363, 363, 363, 363, 363, 364, 363,
492 363, 363, 365, 363, 363, 363, 363, 363, 363, 363,
493 363, 363, 363, 363, 363, 363, 363, 363, 363, 366,
494 366, 363, 363, 363, 366, 366, 366, 366, 366, 366,
495 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
496 366, 366, 363, 363, 363, 363, 363, 363, 363, 363,
497 363, 364, 363, 367, 363, 363, 363, 363, 365, 368,
498 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
499 363, 363, 363, 363, 363, 363, 363, 363, 369, 363,
500 363, 363, 363, 363, 363, 363, 363, 363, 366, 364,
501
502 365, 363, 366, 366, 366, 366, 366, 366, 366, 366,
503 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
504 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
505 366, 366, 366, 366, 366, 366, 366, 366, 366, 363,
506 363, 364, 370, 363, 365, 371, 363, 363, 363, 363,
507 363, 363, 363, 369, 363, 363, 363, 366, 366, 366,
508 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
509 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
510 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
511 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
512
513 366, 366, 366, 366, 366, 366, 366, 366, 364, 364,
514 365, 365, 363, 363, 363, 363, 366, 366, 366, 366,
515 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
516 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
517 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
518 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
519 366, 366, 366, 366, 366, 366, 364, 210, 365, 212,
520 363, 366, 366, 366, 366, 366, 366, 366, 366, 366,
521 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
522 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
523
524 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
525 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
526 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
527 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
528 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
529 366, 366, 366, 366, 366, 366, 366, 366, 366, 366,
530 366, 366, 0, 363, 363, 363, 363, 363, 363, 363,
531 363
532 } ;
533
534 static yyconst short int yy_nxt[641] =
535 { 0,
536 4, 5, 6, 7, 7, 7, 5, 8, 9, 10,
537 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
538 21, 22, 23, 23, 24, 25, 26, 27, 28, 29,
539 30, 30, 30, 30, 31, 30, 30, 32, 4, 33,
540 34, 35, 36, 37, 38, 39, 40, 41, 30, 42,
541 30, 43, 30, 44, 45, 46, 47, 48, 49, 50,
542 51, 52, 30, 30, 30, 53, 54, 55, 56, 57,
543 58, 59, 59, 59, 57, 59, 58, 60, 60, 60,
544 59, 63, 67, 72, 77, 100, 74, 362, 78, 101,
545 79, 79, 79, 361, 73, 75, 76, 80, 68, 94,
546
547 95, 109, 81, 97, 98, 127, 119, 360, 128, 82,
548 110, 64, 83, 120, 84, 84, 85, 134, 63, 83,
549 121, 90, 90, 90, 86, 122, 105, 87, 88, 89,
550 140, 86, 135, 106, 91, 92, 107, 115, 86, 108,
551 116, 125, 117, 123, 87, 86, 126, 124, 64, 142,
552 142, 91, 88, 130, 131, 89, 111, 137, 112, 92,
553 167, 113, 138, 132, 359, 144, 133, 114, 168, 141,
554 57, 58, 59, 59, 59, 57, 59, 58, 59, 59,
555 59, 59, 59, 58, 60, 60, 60, 59, 145, 145,
556 143, 70, 79, 79, 79, 153, 79, 79, 79, 192,
557
558 155, 153, 149, 150, 63, 150, 149, 150, 155, 150,
559 193, 83, 169, 85, 85, 85, 149, 150, 153, 153,
560 149, 150, 150, 86, 155, 155, 150, 170, 83, 146,
561 84, 84, 85, 164, 64, 222, 223, 86, 165, 177,
562 86, 179, 358, 87, 88, 151, 195, 151, 178, 180,
563 152, 152, 152, 188, 86, 83, 181, 90, 90, 90,
564 87, 189, 197, 196, 63, 357, 190, 86, 88, 202,
565 91, 92, 63, 206, 203, 207, 224, 198, 356, 144,
566 355, 86, 204, 354, 225, 209, 209, 91, 211, 211,
567 271, 213, 144, 213, 64, 92, 214, 214, 214, 152,
568
569 152, 152, 64, 215, 216, 70, 152, 152, 152, 63,
570 214, 214, 214, 271, 271, 144, 353, 150, 70, 150,
571 215, 352, 267, 267, 269, 269, 351, 350, 216, 349,
572 271, 150, 348, 347, 346, 345, 150, 344, 343, 64,
573 63, 70, 342, 341, 340, 339, 338, 337, 336, 335,
574 334, 333, 332, 268, 268, 268, 214, 214, 214, 331,
575 330, 329, 268, 268, 268, 328, 327, 150, 326, 150,
576 64, 325, 324, 268, 268, 268, 268, 268, 268, 144,
577 323, 150, 322, 321, 320, 319, 150, 318, 270, 270,
578 270, 317, 316, 315, 314, 313, 312, 270, 270, 270,
579
580 311, 310, 309, 308, 307, 70, 306, 305, 270, 270,
581 270, 270, 270, 270, 62, 304, 62, 62, 62, 62,
582 62, 62, 69, 303, 69, 302, 69, 69, 69, 69,
583 99, 99, 99, 99, 62, 62, 62, 301, 300, 62,
584 69, 69, 69, 299, 298, 69, 154, 154, 210, 210,
585 212, 212, 297, 296, 295, 294, 293, 292, 291, 290,
586 289, 288, 287, 286, 285, 284, 283, 282, 281, 280,
587 279, 278, 277, 276, 275, 274, 273, 272, 266, 265,
588 264, 263, 262, 261, 260, 259, 258, 257, 256, 255,
589 254, 253, 252, 251, 250, 249, 248, 247, 246, 245,
590
591 244, 243, 242, 241, 240, 239, 238, 237, 236, 235,
592 234, 233, 232, 231, 230, 229, 228, 227, 226, 221,
593 220, 219, 218, 217, 208, 205, 201, 200, 199, 194,
594 191, 187, 186, 185, 184, 183, 182, 176, 175, 174,
595 173, 172, 171, 166, 163, 162, 161, 160, 159, 158,
596 70, 157, 156, 148, 147, 139, 136, 129, 118, 104,
597 103, 102, 96, 93, 71, 70, 66, 65, 61, 363,
598 3, 363, 363, 363, 363, 363, 363, 363, 363, 363,
599 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
600 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
601
602 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
603 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
604 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
605 363, 363, 363, 363, 363, 363, 363, 363, 363, 363
606 } ;
607
608 static yyconst short int yy_chk[641] =
609 { 0,
610 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
611 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
612 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
613 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
614 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
615 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
616 1, 1, 1, 1, 1, 1, 1, 1, 1, 5,
617 5, 5, 5, 5, 5, 7, 7, 7, 7, 7,
618 7, 9, 12, 17, 20, 31, 19, 357, 20, 31,
619 20, 20, 20, 354, 17, 19, 19, 21, 12, 26,
620
621 26, 38, 21, 28, 28, 46, 42, 352, 46, 21,
622 38, 9, 22, 42, 22, 22, 22, 49, 62, 23,
623 43, 23, 23, 23, 22, 43, 37, 22, 22, 22,
624 54, 23, 49, 37, 23, 23, 37, 40, 22, 37,
625 40, 45, 40, 44, 22, 23, 45, 44, 62, 64,
626 64, 23, 22, 48, 48, 22, 39, 51, 39, 23,
627 111, 39, 51, 48, 350, 69, 48, 39, 111, 54,
628 57, 57, 57, 57, 57, 57, 59, 59, 59, 59,
629 59, 59, 60, 60, 60, 60, 60, 60, 70, 70,
630 64, 69, 79, 79, 79, 87, 83, 83, 83, 129,
631
632 91, 88, 79, 79, 100, 79, 83, 83, 92, 83,
633 129, 85, 112, 85, 85, 85, 79, 79, 88, 87,
634 83, 83, 79, 85, 91, 92, 83, 112, 84, 70,
635 84, 84, 84, 109, 100, 163, 163, 85, 109, 119,
636 84, 120, 348, 84, 84, 86, 131, 86, 119, 120,
637 86, 86, 86, 127, 84, 90, 120, 90, 90, 90,
638 84, 127, 132, 131, 267, 347, 127, 90, 84, 136,
639 90, 90, 142, 138, 136, 138, 164, 132, 345, 145,
640 344, 90, 136, 343, 164, 142, 142, 90, 145, 145,
641 215, 149, 269, 149, 267, 90, 149, 149, 149, 151,
642
643 151, 151, 142, 154, 154, 145, 152, 152, 152, 209,
644 213, 213, 213, 216, 215, 211, 339, 152, 269, 152,
645 154, 338, 209, 209, 211, 211, 337, 336, 154, 335,
646 216, 152, 328, 326, 325, 323, 152, 322, 321, 209,
647 210, 211, 319, 313, 312, 311, 309, 308, 307, 304,
648 303, 302, 301, 210, 210, 210, 214, 214, 214, 300,
649 299, 297, 210, 210, 210, 296, 295, 214, 294, 214,
650 210, 293, 292, 210, 210, 210, 210, 210, 210, 212,
651 291, 214, 290, 289, 288, 287, 214, 286, 212, 212,
652 212, 284, 282, 279, 278, 277, 276, 212, 212, 212,
653
654 275, 266, 265, 263, 262, 212, 261, 260, 212, 212,
655 212, 212, 212, 212, 364, 259, 364, 364, 364, 364,
656 364, 364, 365, 257, 365, 256, 365, 365, 365, 365,
657 366, 366, 366, 366, 367, 367, 367, 255, 254, 367,
658 368, 368, 368, 253, 252, 368, 369, 369, 370, 370,
659 371, 371, 251, 250, 249, 248, 247, 246, 245, 244,
660 243, 240, 239, 238, 237, 235, 234, 233, 232, 230,
661 227, 226, 225, 224, 223, 222, 221, 218, 208, 207,
662 206, 205, 204, 203, 202, 201, 200, 199, 198, 197,
663 196, 195, 194, 193, 192, 191, 190, 189, 188, 187,
664
665 186, 184, 183, 182, 180, 179, 178, 177, 176, 175,
666 173, 172, 171, 170, 169, 168, 167, 166, 165, 162,
667 161, 160, 159, 158, 139, 137, 135, 134, 133, 130,
668 128, 126, 125, 124, 123, 122, 121, 118, 117, 116,
669 115, 114, 113, 110, 108, 107, 106, 105, 104, 103,
670 101, 98, 94, 78, 76, 52, 50, 47, 41, 36,
671 35, 34, 27, 24, 16, 13, 11, 10, 8, 3,
672 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
673 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
674 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
675
676 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
677 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
678 363, 363, 363, 363, 363, 363, 363, 363, 363, 363,
679 363, 363, 363, 363, 363, 363, 363, 363, 363, 363
680 } ;
681
682 #define REJECT \
683 { \
684 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
685 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
686 ++yy_lp; \
687 goto find_rule; \
688 }
689 #define yymore() yymore_used_but_not_detected
690 #define YY_MORE_ADJ 0
691 #define YY_RESTORE_YY_MORE_OFFSET
692 #define INITIAL 0
693
694 /* Copyright (C) 1989-1991 James A. Roskind, All rights reserved.
695 This lexer description was written by James A. Roskind. Copying
696 of this file, as a whole, is permitted providing this notice is
697 intact and applicable in all complete copies. Direct
698 translations as a whole to other lexer generator input languages
699 (or lexical description languages) is permitted provided that
700 this notice is intact and applicable in all such copies, along
701 with a disclaimer that the contents are a translation. The
702 reproduction of derived files or text, such as modified versions
703 of this file, or the output of scanner generators, is permitted,
704 provided the resulting work includes the copyright notice
705 "Portions Copyright (c) 1989, 1990 James A. Roskind". Derived
706 products must also provide the notice "Portions Copyright (c)
707 1989, 1990 James A. Roskind" in a manner appropriate to the
708 utility, and in keeping with copyright law (e.g.: EITHER
709 displayed when first invoked/executed; OR displayed continuously
710 on display terminal; OR via placement in the object code in form
711 readable in a printout, with or near the title of the work, or at
712 the end of the file). No royalties, licenses or commissions of
713 any kind are required to copy this file, its translations, or
714 derivative products, when the copies are made in compliance with
715 this notice. Persons or corporations that do make copies in
716 compliance with this notice may charge whatever price is
717 agreeable to a buyer, for such copies or derivative works. THIS
718 FILE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
719 WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
720 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
721
722 James A. Roskind
723 Independent Consultant
724 516 Latania Palm Drive
725 Indialantic FL, 32903
726 (407)729-4348
727 jar@hq.ileaf.com
728 or ...!uunet!leafusa!jar
729
730 ---end of copyright notice---
731
732
733 COMMENTS-
734
735 My goal is to see software developers adopt my C++ grammar as a
736 standard until such time as a better standard is accessible. The
737 only way to get it to become a standard, is to be sure that people
738 know that derivations are based on a specific work. The intent of
739 releasing this Flex input file is to facilitate experimentation with
740 my C++ grammar. The intent of the copyright notice is to allow
741 arbitrary commercial and non-commercial use of this file, as long as
742 reference is given to my standardization effort. Without reference
743 to a specific standard, many alternative grammars would develop. By
744 referring to the standard, the C++ grammar is given publicity, which
745 should lead to further use in compatible products and systems. The
746 benefits of such a standard to commercial products (browsers,
747 beautifiers, translators, compilers, ...) should be obvious to the
748 developers, in that other compatible products will emerge, and the
749 value of all conforming products will rise. Most developers are
750 aware of the value of acquiring a fairly complete grammar for a
751 language, and the copyright notice (and the resulting affiliation
752 with my work) should not be too high a price to pay. By copyrighting
753 my work, I have some minor control over what this standard is, and I
754 can (hopefully) keep it from degrading without my approval. I will
755 consistently attempt to provide upgraded grammars that are compliant
756 with the current art, and the ANSI C++ Committee recommendation in
757 particular. A developer is never prevented from modifying the
758 grammar or this file to improve it in whatever way is seen fit. There
759 is also no restriction on the sale of copies, or derivative works,
760 providing the request in the copyright notice are satisfied.
761
762 If you are not "copying" my work, but are rather only abstracting
763 some of my work, an acknowledgment with references to such a standard
764 would be appreciated. Specifically, agreements with my grammar and
765 its resolution of otherwise ambiguous constructs, should be noted.
766
767 Simply put: "make whatever use you would like of the grammar and this
768 file, but include the ``portions Copyright ...'' as a reference to
769 this standard."
770
771
772 */
773
774 /* Last modified 7/4/91, Version 2.0 */
775
776 /* File cpp5.l, becomes lex.yy.c after processing by FLEX */
777
778 /* This file is a dramatically cut down version of the FLEX input file
779 used in my ANSI C Preprocessor. The executable version of my
780 preprocessor is available on many platforms (shareware), but this is
781 the only source extract that is currently being distributed. If you
782 need a full ANSI C preprocessor, with extensive diagnostic
783 capabilities and customization facilities, please contact me at the
784 addresses given above. Current platforms include IBMPC (DOS/OS2), Sun
785 (SPARC and Motorola), and IBM R/6000. ... end of commercial
786 announcement.
787
788 This file is being distributed to facilitate experimentation and use
789 of my C and C++ grammar.
790
791
792 Comment removal must be done during the lexing, as context (such as
793 enclosure in string literals) must be observed. For this cut-down
794 lexer, we will assume that comments have been removed (don't assume
795 this if you are writing a compiler or browser!).
796
797
798 For each IDENTIFIER like string that is found, there are several
799 distinct interpretations that can be applied:
800
801 1) The preprocessor may interpret the string as a "keyword" in a
802 directive (eg: "pragma" or "include", "defined").
803
804 2) The parser may interpret the string as a keyword. (eg: "int").
805
806 3) Both parser and preprocessor may interpret the string as a keyword
807 (eg: "if").
808
809 Since this file is based on source that actually lexically analyses
810 text for both preprocessing and parsing, macro definitions were used
811 throughout. The macro definitions supplied here have been customized
812 to a C++ parse only, and all preprocessor keywords are passed as
813 IDENTIFIER or TYPEDEFname. Also, since there is no symbol table to
814 interrogate to decide whether a string is a TYPEDEFname, I simply
815 assume that any identifier beginning with an upper case letter is a
816 TYPEDEFname. This hack should allow you to check out how code
817 segments are parsed using my grammar. Unfortunately, if you really
818 want to parse major league code, you have to write a symbol table, and
819 maintain appropriate scoping information.
820
821
822
823 */
824
825
826 /* Included code before lex code */
827 /*************** Includes and Defines *****************************/
828
829
830 #include "flex-lexer-klass-tab.h" /* YACC generated definitions based on C++ grammar */
831
832 typedef char * YYSTYPE; /* interface with lexer: should be in header
833 file*/
834
835 extern char * yylval; /* We will always point at the text of the lexeme.
836 This makes it easy to print out nice trees when YYDEBUG is
837 enabled. (see C++ grammar file and its definition of
838 YYDEBUG_LEXER_TEXT to be "yylval" */
839
840 #include <stdlib.h>
841 #include <string.h>
842
843 /* Prototypes */
844
845
846 #define WHITE_RETURN(x) /* do nothing */
847
848 #define NEW_LINE_RETURN() WHITE_RETURN('\n')
849
850 #define PA_KEYWORD_RETURN(x) RETURN_VAL(x) /* standard C PArser Keyword */
851 #define CPP_KEYWORD_RETURN(x) PA_KEYWORD_RETURN(x) /* C++ keyword */
852 #define PPPA_KEYWORD_RETURN(x) RETURN_VAL(x) /* both PreProcessor and PArser keyword */
853 #define PP_KEYWORD_RETURN(x) IDENTIFIER_RETURN()
854
855 #define IDENTIFIER_RETURN() RETURN_VAL(IDENTIFIER)
856
857 #define PPOP_RETURN(x) RETURN_VAL((int)*yytext) /* PreProcess and Parser operator */
858 #define NAMED_PPOP_RETURN(x) RETURN_VAL(x)
859 #define ASCIIOP_RETURN(x) RETURN_VAL((int)*yytext) /* a single character operator */
860 #define NAMEDOP_RETURN(x) RETURN_VAL(x) /* a multichar operator, with a name */
861
862 #define NUMERICAL_RETURN(x) RETURN_VAL(x) /* some sort of constant */
863 #define LITERAL_RETURN(x) RETURN_VAL(x) /* a string literal */
864 #define C_COMMENT_RETURN(x) RETURN_VAL(x) /* C Style comment */
865 #define RETURN_VAL(x) return(x);
866 #define yywrap() 1
867
868
869
870
871 /* Macros after this point can all be overridden by user definitions in
872 * section 1.
873 */
874
875 #ifndef YY_SKIP_YYWRAP
876 #ifdef __cplusplus
877 extern "C" int yywrap YY_PROTO(( void ));
878 #else
879 extern int yywrap YY_PROTO(( void ));
880 #endif
881 #endif
882
883
884 #ifndef yytext_ptr
885 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
886 #endif
887
888 #ifdef YY_NEED_STRLEN
889 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
890 #endif
891
892 #ifndef YY_NO_INPUT
893 #endif
894
895 #if YY_STACK_USED
896 static int yy_start_stack_ptr = 0;
897 static int yy_start_stack_depth = 0;
898 static int *yy_start_stack = 0;
899 #ifndef YY_NO_PUSH_STATE
900 static void yy_push_state YY_PROTO(( int new_state ));
901 #endif
902 #ifndef YY_NO_POP_STATE
903 static void yy_pop_state YY_PROTO(( void ));
904 #endif
905 #ifndef YY_NO_TOP_STATE
906 static int yy_top_state YY_PROTO(( void ));
907 #endif
908
909 #else
910 #define YY_NO_PUSH_STATE 1
911 #define YY_NO_POP_STATE 1
912 #define YY_NO_TOP_STATE 1
913 #endif
914
915 #ifdef YY_MALLOC_DECL
916 YY_MALLOC_DECL
917 #else
918 #if __STDC__
919 #ifndef __cplusplus
920 #include <stdlib.h>
921 #endif
922 #else
923 /* Just try to get by without declaring the routines. This will fail
924 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
925 * or sizeof(void*) != sizeof(int).
926 */
927 #endif
928 #endif
929
930 /* Amount of stuff to slurp up with each read. */
931 #ifndef YY_READ_BUF_SIZE
932 #define YY_READ_BUF_SIZE 8192
933 #endif
934
935 /* Copy whatever the last rule matched to the standard output. */
936
937 #ifndef ECHO
938 #define ECHO LexerOutput( yytext, yyleng )
939 #endif
940
941 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
942 * is returned in "result".
943 */
944 #ifndef YY_INPUT
945 #define YY_INPUT(buf,result,max_size) \
946 if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
947 YY_FATAL_ERROR( "input in flex scanner failed" );
948 #endif
949
950 /* No semi-colon after return; correct usage is to write "yyterminate();" -
951 * we don't want an extra ';' after the "return" because that will cause
952 * some compilers to complain about unreachable statements.
953 */
954 #ifndef yyterminate
955 #define yyterminate() return YY_NULL
956 #endif
957
958 /* Number of entries by which start-condition stack grows. */
959 #ifndef YY_START_STACK_INCR
960 #define YY_START_STACK_INCR 25
961 #endif
962
963 /* Report a fatal error. */
964 #ifndef YY_FATAL_ERROR
965 #define YY_FATAL_ERROR(msg) LexerError( msg )
966 #endif
967
968 /* Default declaration of generated scanner - a define so the user can
969 * easily add parameters.
970 */
971 #ifndef YY_DECL
972 #define YY_DECL int yyFlexLexer::yylex()
973 #endif
974
975 /* Code executed at the beginning of each rule, after yytext and yyleng
976 * have been set up.
977 */
978 #ifndef YY_USER_ACTION
979 #define YY_USER_ACTION
980 #endif
981
982 /* Code executed at the end of each rule. */
983 #ifndef YY_BREAK
984 #define YY_BREAK break;
985 #endif
986
987 #define YY_RULE_SETUP \
988 YY_USER_ACTION
989
990 YY_DECL
991 {
992 register yy_state_type yy_current_state;
993 register char *yy_cp, *yy_bp;
994 register int yy_act;
995
996
997
998
999 if ( yy_init )
1000 {
1001 yy_init = 0;
1002
1003 #ifdef YY_USER_INIT
1004
1005 YY_USER_INIT;
1006 #endif
1007
1008 if ( ! yy_start )
1009 yy_start = 1; /* first start state */
1010
1011 if ( ! yyin )
1012 yyin = &std::cin;
1013
1014 if ( ! yyout )
1015 yyout = &std::cout;
1016
1017 if ( ! yy_current_buffer )
1018 yy_current_buffer =
1019 yy_create_buffer( yyin, YY_BUF_SIZE );
1020
1021 yy_load_buffer_state();
1022 }
1023
1024 while ( 1 ) /* loops until end-of-file is reached */
1025 {
1026 yy_cp = yy_c_buf_p;
1027
1028 /* Support of yytext. */
1029 *yy_cp = yy_hold_char;
1030
1031 /* yy_bp points to the position in yy_ch_buf of the start of
1032 * the current run.
1033 */
1034 yy_bp = yy_cp;
1035
1036 yy_current_state = yy_start;
1037 yy_state_ptr = yy_state_buf;
1038 *yy_state_ptr++ = yy_current_state;
1039 yy_match:
1040 do
1041 {
1042 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1043 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1044 {
1045 yy_current_state = (int) yy_def[yy_current_state];
1046 if ( yy_current_state >= 364 )
1047 yy_c = yy_meta[(unsigned int) yy_c];
1048 }
1049 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1050 *yy_state_ptr++ = yy_current_state;
1051 ++yy_cp;
1052 }
1053 while ( yy_base[yy_current_state] != 571 );
1054
1055 yy_find_action:
1056 yy_current_state = *--yy_state_ptr;
1057 yy_lp = yy_accept[yy_current_state];
1058 find_rule: /* we branch to this label when backing up */
1059 for ( ; ; ) /* until we find what rule we matched */
1060 {
1061 if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1062 {
1063 yy_act = yy_acclist[yy_lp];
1064 {
1065 yy_full_match = yy_cp;
1066 break;
1067 }
1068 }
1069 --yy_cp;
1070 yy_current_state = *--yy_state_ptr;
1071 yy_lp = yy_accept[yy_current_state];
1072 }
1073
1074 YY_DO_BEFORE_ACTION;
1075
1076 if ( yy_act != YY_END_OF_BUFFER )
1077 {
1078 int yyl;
1079 for ( yyl = 0; yyl < yyleng; ++yyl )
1080 if ( yytext[yyl] == '\n' )
1081 ++yylineno;
1082 }
1083
1084 do_action: /* This label is used only to access EOF actions. */
1085
1086
1087 switch ( yy_act )
1088 { /* beginning of action switch */
1089 case 1:
1090 YY_RULE_SETUP
1091 {
1092 /* Handle C-Style comment */
1093 register int c;
1094 if (m_keepComments)
1095 m_comment += yytext;
1096 for ( ; ; )
1097 {
1098 while ( (c = yyinput()) != '*' && c != EOF )
1099 {
1100 if (m_keepComments)
1101 m_comment += c;
1102
1103 ; /* eat up text of comment */
1104 }
1105 if (m_keepComments)
1106 m_comment += c;
1107 if ( c == '*' )
1108 {
1109 while ( (c = yyinput()) == '*' )
1110 {
1111 if (m_keepComments)
1112 m_comment += c;
1113 ;
1114 }
1115 if (m_keepComments)
1116 m_comment += c;
1117 if ( c == '/' )
1118 {
1119 break; /* found the end */
1120 }
1121 }
1122 if ( c == EOF )
1123 {
1124 break;
1125 }
1126 }
1127 if (m_keepComments )
1128 return CComment;
1129 }
1130 YY_BREAK
1131 case 2:
1132 YY_RULE_SETUP
1133 {
1134 /* Handle CPP style comment */
1135 /* Constume everything until the newline */
1136 register int c;
1137 if (m_keepComments)
1138 m_comment += yytext;
1139 while ((c = yyinput()) != '\n' && c != EOF)
1140 {
1141 if (m_keepComments)
1142 m_comment += c;
1143 }
1144 if (m_keepComments)
1145 m_comment += c;
1146 if (m_keepComments )
1147 return CPPComment;
1148 }
1149 YY_BREAK
1150 case 3:
1151 YY_RULE_SETUP
1152 {
1153 if (!m_returnWhite)
1154 WHITE_RETURN(' ');
1155 else
1156 return ' ';
1157
1158 }
1159 YY_BREAK
1160 case 4:
1161 YY_RULE_SETUP
1162 {
1163 if (!m_returnWhite)
1164 WHITE_RETURN(' ');
1165 else
1166 return ' ';
1167 }
1168 YY_BREAK
1169 case 5:
1170 YY_RULE_SETUP
1171 {
1172 if (!m_returnWhite)
1173 NEW_LINE_RETURN();
1174 else
1175 return '\n';
1176 }
1177 YY_BREAK
1178 case 6:
1179 YY_RULE_SETUP
1180 {PA_KEYWORD_RETURN(AUTO);
1181 }
1182 YY_BREAK
1183 case 7:
1184 YY_RULE_SETUP
1185 {PA_KEYWORD_RETURN(BREAK);
1186 }
1187 YY_BREAK
1188 case 8:
1189 YY_RULE_SETUP
1190 {PA_KEYWORD_RETURN(CASE);
1191 }
1192 YY_BREAK
1193 case 9:
1194 YY_RULE_SETUP
1195 {PA_KEYWORD_RETURN(lexCHAR);
1196 }
1197 YY_BREAK
1198 case 10:
1199 YY_RULE_SETUP
1200 {PA_KEYWORD_RETURN(lexCONST);
1201 }
1202 YY_BREAK
1203 case 11:
1204 YY_RULE_SETUP
1205 {PA_KEYWORD_RETURN(CONTINUE);
1206 }
1207 YY_BREAK
1208 case 12:
1209 YY_RULE_SETUP
1210 {PA_KEYWORD_RETURN(lexDEFAULT);
1211 }
1212 YY_BREAK
1213 case 13:
1214 YY_RULE_SETUP
1215 {PP_KEYWORD_RETURN(DEFINE);
1216 }
1217 YY_BREAK
1218 case 14:
1219 YY_RULE_SETUP
1220 {PP_KEYWORD_RETURN(OPDEFINED);
1221 }
1222 YY_BREAK
1223 case 15:
1224 YY_RULE_SETUP
1225 {PA_KEYWORD_RETURN(DO);
1226 }
1227 YY_BREAK
1228 case 16:
1229 YY_RULE_SETUP
1230 {PA_KEYWORD_RETURN(lexDOUBLE);
1231 }
1232 YY_BREAK
1233 case 17:
1234 YY_RULE_SETUP
1235 {PP_KEYWORD_RETURN(ELIF);
1236 }
1237 YY_BREAK
1238 case 18:
1239 YY_RULE_SETUP
1240 {PPPA_KEYWORD_RETURN(ELSE);
1241 }
1242 YY_BREAK
1243 case 19:
1244 YY_RULE_SETUP
1245 {PP_KEYWORD_RETURN(ENDIF);
1246 }
1247 YY_BREAK
1248 case 20:
1249 YY_RULE_SETUP
1250 {PA_KEYWORD_RETURN(lexENUM);
1251 }
1252 YY_BREAK
1253 case 21:
1254 YY_RULE_SETUP
1255 {PP_KEYWORD_RETURN(ERROR);
1256 }
1257 YY_BREAK
1258 case 22:
1259 YY_RULE_SETUP
1260 {PA_KEYWORD_RETURN(EXTERN);
1261 }
1262 YY_BREAK
1263 case 23:
1264 YY_RULE_SETUP
1265 {PA_KEYWORD_RETURN(lexFLOAT);
1266 }
1267 YY_BREAK
1268 case 24:
1269 YY_RULE_SETUP
1270 {PA_KEYWORD_RETURN(FOR);
1271 }
1272 YY_BREAK
1273 case 25:
1274 YY_RULE_SETUP
1275 {PA_KEYWORD_RETURN(GOTO);
1276 }
1277 YY_BREAK
1278 case 26:
1279 YY_RULE_SETUP
1280 {PPPA_KEYWORD_RETURN(IF);
1281 }
1282 YY_BREAK
1283 case 27:
1284 YY_RULE_SETUP
1285 {PP_KEYWORD_RETURN(IFDEF);
1286 }
1287 YY_BREAK
1288 case 28:
1289 YY_RULE_SETUP
1290 {PP_KEYWORD_RETURN(IFNDEF);
1291 }
1292 YY_BREAK
1293 case 29:
1294 YY_RULE_SETUP
1295 {PP_KEYWORD_RETURN(INCLUDE);
1296 }
1297 YY_BREAK
1298 case 30:
1299 YY_RULE_SETUP
1300 {PA_KEYWORD_RETURN(lexINT);
1301 }
1302 YY_BREAK
1303 case 31:
1304 YY_RULE_SETUP
1305 {PP_KEYWORD_RETURN(LINE);
1306 }
1307 YY_BREAK
1308 case 32:
1309 YY_RULE_SETUP
1310 {PA_KEYWORD_RETURN(lexLONG);
1311 }
1312 YY_BREAK
1313 case 33:
1314 YY_RULE_SETUP
1315 {PP_KEYWORD_RETURN(PRAGMA);
1316 }
1317 YY_BREAK
1318 case 34:
1319 YY_RULE_SETUP
1320 {PA_KEYWORD_RETURN(REGISTER);
1321 }
1322 YY_BREAK
1323 case 35:
1324 YY_RULE_SETUP
1325 {PA_KEYWORD_RETURN(RETURN);
1326 }
1327 YY_BREAK
1328 case 36:
1329 YY_RULE_SETUP
1330 {PA_KEYWORD_RETURN(lexSHORT);
1331 }
1332 YY_BREAK
1333 case 37:
1334 YY_RULE_SETUP
1335 {PA_KEYWORD_RETURN(SIGNED);
1336 }
1337 YY_BREAK
1338 case 38:
1339 YY_RULE_SETUP
1340 {PA_KEYWORD_RETURN(SIZEOF);
1341 }
1342 YY_BREAK
1343 case 39:
1344 YY_RULE_SETUP
1345 {PA_KEYWORD_RETURN(STATIC);
1346 }
1347 YY_BREAK
1348 case 40:
1349 YY_RULE_SETUP
1350 {PA_KEYWORD_RETURN(lexSTRUCT);
1351 }
1352 YY_BREAK
1353 case 41:
1354 YY_RULE_SETUP
1355 {PA_KEYWORD_RETURN(SWITCH);
1356 }
1357 YY_BREAK
1358 case 42:
1359 YY_RULE_SETUP
1360 {PA_KEYWORD_RETURN(TYPEDEF);
1361 }
1362 YY_BREAK
1363 case 43:
1364 YY_RULE_SETUP
1365 {PP_KEYWORD_RETURN(UNDEF);
1366 }
1367 YY_BREAK
1368 case 44:
1369 YY_RULE_SETUP
1370 {PA_KEYWORD_RETURN(UNION);
1371 }
1372 YY_BREAK
1373 case 45:
1374 YY_RULE_SETUP
1375 {PA_KEYWORD_RETURN(UNSIGNED);
1376 }
1377 YY_BREAK
1378 case 46:
1379 YY_RULE_SETUP
1380 {PA_KEYWORD_RETURN(lexVOID);
1381 }
1382 YY_BREAK
1383 case 47:
1384 YY_RULE_SETUP
1385 {PA_KEYWORD_RETURN(VOLATILE);
1386 }
1387 YY_BREAK
1388 case 48:
1389 YY_RULE_SETUP
1390 {PA_KEYWORD_RETURN(WHILE);
1391 }
1392 YY_BREAK
1393 case 49:
1394 YY_RULE_SETUP
1395 {CPP_KEYWORD_RETURN(lexCLASS);
1396 }
1397 YY_BREAK
1398 case 50:
1399 YY_RULE_SETUP
1400 {CPP_KEYWORD_RETURN(lexNAMESPACE);
1401 }
1402 YY_BREAK
1403 case 51:
1404 YY_RULE_SETUP
1405 {CPP_KEYWORD_RETURN(lexDELETE);
1406 }
1407 YY_BREAK
1408 case 52:
1409 YY_RULE_SETUP
1410 {CPP_KEYWORD_RETURN(FRIEND);
1411 }
1412 YY_BREAK
1413 case 53:
1414 YY_RULE_SETUP
1415 {CPP_KEYWORD_RETURN(INLINE);
1416 }
1417 YY_BREAK
1418 case 54:
1419 YY_RULE_SETUP
1420 {CPP_KEYWORD_RETURN(NEW);
1421 }
1422 YY_BREAK
1423 case 55:
1424 YY_RULE_SETUP
1425 {CPP_KEYWORD_RETURN(lexOPERATOR);
1426 }
1427 YY_BREAK
1428 case 56:
1429 YY_RULE_SETUP
1430 {CPP_KEYWORD_RETURN(OVERLOAD);
1431 }
1432 YY_BREAK
1433 case 57:
1434 YY_RULE_SETUP
1435 {CPP_KEYWORD_RETURN(lexPROTECTED);
1436 }
1437 YY_BREAK
1438 case 58:
1439 YY_RULE_SETUP
1440 {CPP_KEYWORD_RETURN(lexPRIVATE);
1441 }
1442 YY_BREAK
1443 case 59:
1444 YY_RULE_SETUP
1445 {CPP_KEYWORD_RETURN(lexPUBLIC);
1446 }
1447 YY_BREAK
1448 case 60:
1449 YY_RULE_SETUP
1450 {CPP_KEYWORD_RETURN(lexTHIS);
1451 }
1452 YY_BREAK
1453 case 61:
1454 YY_RULE_SETUP
1455 {CPP_KEYWORD_RETURN(VIRTUAL);
1456 }
1457 YY_BREAK
1458 case 62:
1459 YY_RULE_SETUP
1460 {IDENTIFIER_RETURN();
1461 }
1462 YY_BREAK
1463 case 63:
1464 YY_RULE_SETUP
1465 {NUMERICAL_RETURN(INTEGERconstant);
1466 }
1467 YY_BREAK
1468 case 64:
1469 YY_RULE_SETUP
1470 {NUMERICAL_RETURN(OCTALconstant);
1471 }
1472 YY_BREAK
1473 case 65:
1474 YY_RULE_SETUP
1475 {NUMERICAL_RETURN(HEXconstant);
1476 }
1477 YY_BREAK
1478 case 66:
1479 YY_RULE_SETUP
1480 {NUMERICAL_RETURN(FLOATINGconstant);
1481 }
1482 YY_BREAK
1483 case 67:
1484 YY_RULE_SETUP
1485 {
1486 NUMERICAL_RETURN(CHARACTERconstant);
1487 }
1488 YY_BREAK
1489 case 68:
1490 YY_RULE_SETUP
1491 {
1492 LITERAL_RETURN(STRINGliteral);
1493 }
1494 YY_BREAK
1495 case 69:
1496 YY_RULE_SETUP
1497 {PPOP_RETURN(LP);
1498 }
1499 YY_BREAK
1500 case 70:
1501 YY_RULE_SETUP
1502 {PPOP_RETURN(RP);
1503 }
1504 YY_BREAK
1505 case 71:
1506 YY_RULE_SETUP
1507 {PPOP_RETURN(COMMA);
1508 }
1509 YY_BREAK
1510 case 72:
1511 YY_RULE_SETUP
1512 {NAMED_PPOP_RETURN('#') ;
1513 }
1514 YY_BREAK
1515 case 73:
1516 YY_RULE_SETUP
1517 {NAMED_PPOP_RETURN(POUNDPOUND);
1518 }
1519 YY_BREAK
1520 case 74:
1521 YY_RULE_SETUP
1522 {ASCIIOP_RETURN(LC);
1523 }
1524 YY_BREAK
1525 case 75:
1526 YY_RULE_SETUP
1527 {ASCIIOP_RETURN(RC);
1528 }
1529 YY_BREAK
1530 case 76:
1531 YY_RULE_SETUP
1532 {ASCIIOP_RETURN(LB);
1533 }
1534 YY_BREAK
1535 case 77:
1536 YY_RULE_SETUP
1537 {ASCIIOP_RETURN(RB);
1538 }
1539 YY_BREAK
1540 case 78:
1541 YY_RULE_SETUP
1542 {ASCIIOP_RETURN(DOT);
1543 }
1544 YY_BREAK
1545 case 79:
1546 YY_RULE_SETUP
1547 {ASCIIOP_RETURN(AND);
1548 }
1549 YY_BREAK
1550 case 80:
1551 YY_RULE_SETUP
1552 {ASCIIOP_RETURN(STAR);
1553 }
1554 YY_BREAK
1555 case 81:
1556 YY_RULE_SETUP
1557 {ASCIIOP_RETURN(PLUS);
1558 }
1559 YY_BREAK
1560 case 82:
1561 YY_RULE_SETUP
1562 {ASCIIOP_RETURN(MINUS);
1563 }
1564 YY_BREAK
1565 case 83:
1566 YY_RULE_SETUP
1567 {ASCIIOP_RETURN(NEGATE);
1568 }
1569 YY_BREAK
1570 case 84:
1571 YY_RULE_SETUP
1572 {ASCIIOP_RETURN(NOT);
1573 }
1574 YY_BREAK
1575 case 85:
1576 YY_RULE_SETUP
1577 {ASCIIOP_RETURN(DIV);
1578 }
1579 YY_BREAK
1580 case 86:
1581 YY_RULE_SETUP
1582 {ASCIIOP_RETURN(MOD);
1583 }
1584 YY_BREAK
1585 case 87:
1586 YY_RULE_SETUP
1587 {ASCIIOP_RETURN(LT);
1588 }
1589 YY_BREAK
1590 case 88:
1591 YY_RULE_SETUP
1592 {ASCIIOP_RETURN(GT);
1593 }
1594 YY_BREAK
1595 case 89:
1596 YY_RULE_SETUP
1597 {ASCIIOP_RETURN(XOR);
1598 }
1599 YY_BREAK
1600 case 90:
1601 YY_RULE_SETUP
1602 {ASCIIOP_RETURN(PIPE);
1603 }
1604 YY_BREAK
1605 case 91:
1606 YY_RULE_SETUP
1607 {ASCIIOP_RETURN(QUESTION);
1608 }
1609 YY_BREAK
1610 case 92:
1611 YY_RULE_SETUP
1612 {ASCIIOP_RETURN(COLON);
1613 }
1614 YY_BREAK
1615 case 93:
1616 YY_RULE_SETUP
1617 {ASCIIOP_RETURN(SEMICOLON);
1618 }
1619 YY_BREAK
1620 case 94:
1621 YY_RULE_SETUP
1622 {ASCIIOP_RETURN(ASSIGN);
1623 }
1624 YY_BREAK
1625 case 95:
1626 YY_RULE_SETUP
1627 {NAMEDOP_RETURN(DOTstar);
1628 }
1629 YY_BREAK
1630 case 96:
1631 YY_RULE_SETUP
1632 {NAMEDOP_RETURN(CLCL);
1633 }
1634 YY_BREAK
1635 case 97:
1636 YY_RULE_SETUP
1637 {NAMEDOP_RETURN(lexARROW);
1638 }
1639 YY_BREAK
1640 case 98:
1641 YY_RULE_SETUP
1642 {NAMEDOP_RETURN(ARROWstar);
1643 }
1644 YY_BREAK
1645 case 99:
1646 YY_RULE_SETUP
1647 {NAMEDOP_RETURN(ICR);
1648 }
1649 YY_BREAK
1650 case 100:
1651 YY_RULE_SETUP
1652 {NAMEDOP_RETURN(DECR);
1653 }
1654 YY_BREAK
1655 case 101:
1656 YY_RULE_SETUP
1657 {NAMEDOP_RETURN(LS);
1658 }
1659 YY_BREAK
1660 case 102:
1661 YY_RULE_SETUP
1662 {NAMEDOP_RETURN(RS);
1663 }
1664 YY_BREAK
1665 case 103:
1666 YY_RULE_SETUP
1667 {NAMEDOP_RETURN(LE);
1668 }
1669 YY_BREAK
1670 case 104:
1671 YY_RULE_SETUP
1672 {NAMEDOP_RETURN(GE);
1673 }
1674 YY_BREAK
1675 case 105:
1676 YY_RULE_SETUP
1677 {NAMEDOP_RETURN(EQ);
1678 }
1679 YY_BREAK
1680 case 106:
1681 YY_RULE_SETUP
1682 {NAMEDOP_RETURN(NE);
1683 }
1684 YY_BREAK
1685 case 107:
1686 YY_RULE_SETUP
1687 {NAMEDOP_RETURN(ANDAND);
1688 }
1689 YY_BREAK
1690 case 108:
1691 YY_RULE_SETUP
1692 {NAMEDOP_RETURN(OROR);
1693 }
1694 YY_BREAK
1695 case 109:
1696 YY_RULE_SETUP
1697 {NAMEDOP_RETURN(MULTassign);
1698 }
1699 YY_BREAK
1700 case 110:
1701 YY_RULE_SETUP
1702 {NAMEDOP_RETURN(DIVassign);
1703 }
1704 YY_BREAK
1705 case 111:
1706 YY_RULE_SETUP
1707 {NAMEDOP_RETURN(MODassign);
1708 }
1709 YY_BREAK
1710 case 112:
1711 YY_RULE_SETUP
1712 {NAMEDOP_RETURN(PLUSassign);
1713 }
1714 YY_BREAK
1715 case 113:
1716 YY_RULE_SETUP
1717 {NAMEDOP_RETURN(MINUSassign);
1718 }
1719 YY_BREAK
1720 case 114:
1721 YY_RULE_SETUP
1722 {NAMEDOP_RETURN(LSassign);
1723 }
1724 YY_BREAK
1725 case 115:
1726 YY_RULE_SETUP
1727 {NAMEDOP_RETURN(RSassign);
1728 }
1729 YY_BREAK
1730 case 116:
1731 YY_RULE_SETUP
1732 {NAMEDOP_RETURN(ANDassign);
1733 }
1734 YY_BREAK
1735 case 117:
1736 YY_RULE_SETUP
1737 {NAMEDOP_RETURN(ERassign);
1738 }
1739 YY_BREAK
1740 case 118:
1741 YY_RULE_SETUP
1742 {NAMEDOP_RETURN(ORassign);
1743 }
1744 YY_BREAK
1745 case 119:
1746 YY_RULE_SETUP
1747 {NAMEDOP_RETURN(ELLIPSIS);
1748 }
1749 YY_BREAK
1750 case 120:
1751 YY_RULE_SETUP
1752 { return yytext[0];
1753 }
1754 YY_BREAK
1755 case 121:
1756 YY_RULE_SETUP
1757 ECHO;
1758 YY_BREAK
1759 case YY_STATE_EOF(INITIAL):
1760 yyterminate();
1761
1762 case YY_END_OF_BUFFER:
1763 {
1764 /* Amount of text matched not including the EOB char. */
1765 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1766
1767 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1768 *yy_cp = yy_hold_char;
1769 YY_RESTORE_YY_MORE_OFFSET
1770
1771 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1772 {
1773 /* We're scanning a new file or input source. It's
1774 * possible that this happened because the user
1775 * just pointed yyin at a new source and called
1776 * yylex(). If so, then we have to assure
1777 * consistency between yy_current_buffer and our
1778 * globals. Here is the right place to do so, because
1779 * this is the first action (other than possibly a
1780 * back-up) that will match for the new input source.
1781 */
1782 yy_n_chars = yy_current_buffer->yy_n_chars;
1783 yy_current_buffer->yy_input_file = yyin;
1784 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1785 }
1786
1787 /* Note that here we test for yy_c_buf_p "<=" to the position
1788 * of the first EOB in the buffer, since yy_c_buf_p will
1789 * already have been incremented past the NUL character
1790 * (since all states make transitions on EOB to the
1791 * end-of-buffer state). Contrast this with the test
1792 * in input().
1793 */
1794 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1795 { /* This was really a NUL. */
1796 yy_state_type yy_next_state;
1797
1798 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1799
1800 yy_current_state = yy_get_previous_state();
1801
1802 /* Okay, we're now positioned to make the NUL
1803 * transition. We couldn't have
1804 * yy_get_previous_state() go ahead and do it
1805 * for us because it doesn't know how to deal
1806 * with the possibility of jamming (and we don't
1807 * want to build jamming into it because then it
1808 * will run more slowly).
1809 */
1810
1811 yy_next_state = yy_try_NUL_trans( yy_current_state );
1812
1813 yy_bp = yytext_ptr + YY_MORE_ADJ;
1814
1815 if ( yy_next_state )
1816 {
1817 /* Consume the NUL. */
1818 yy_cp = ++yy_c_buf_p;
1819 yy_current_state = yy_next_state;
1820 goto yy_match;
1821 }
1822
1823 else
1824 {
1825 yy_cp = yy_c_buf_p;
1826 goto yy_find_action;
1827 }
1828 }
1829
1830 else
1831 switch ( yy_get_next_buffer() )
1832 {
1833 case EOB_ACT_END_OF_FILE:
1834 {
1835 yy_did_buffer_switch_on_eof = 0;
1836
1837 if ( yywrap() )
1838 {
1839 /* Note: because we've taken care in
1840 * yy_get_next_buffer() to have set up
1841 * yytext, we can now set up
1842 * yy_c_buf_p so that if some total
1843 * hoser (like flex itself) wants to
1844 * call the scanner after we return the
1845 * YY_NULL, it'll still work - another
1846 * YY_NULL will get returned.
1847 */
1848 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1849
1850 yy_act = YY_STATE_EOF(YY_START);
1851 goto do_action;
1852 }
1853
1854 else
1855 {
1856 if ( ! yy_did_buffer_switch_on_eof )
1857 YY_NEW_FILE;
1858 }
1859 break;
1860 }
1861
1862 case EOB_ACT_CONTINUE_SCAN:
1863 yy_c_buf_p =
1864 yytext_ptr + yy_amount_of_matched_text;
1865
1866 yy_current_state = yy_get_previous_state();
1867
1868 yy_cp = yy_c_buf_p;
1869 yy_bp = yytext_ptr + YY_MORE_ADJ;
1870 goto yy_match;
1871
1872 case EOB_ACT_LAST_MATCH:
1873 yy_c_buf_p =
1874 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1875
1876 yy_current_state = yy_get_previous_state();
1877
1878 yy_cp = yy_c_buf_p;
1879 yy_bp = yytext_ptr + YY_MORE_ADJ;
1880 goto yy_find_action;
1881 }
1882 break;
1883 }
1884
1885 default:
1886 YY_FATAL_ERROR(
1887 "fatal flex scanner internal error--no action found" );
1888 } /* end of action switch */
1889 } /* end of scanning one token */
1890 } /* end of yylex */
1891
1892 yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
1893 {
1894 yyin = arg_yyin;
1895 yyout = arg_yyout;
1896 yy_c_buf_p = 0;
1897 yy_init = 1;
1898 yy_start = 0;
1899 yy_flex_debug = 0;
1900 yylineno = 1; // this will only get updated if %option yylineno
1901
1902 yy_did_buffer_switch_on_eof = 0;
1903
1904 yy_looking_for_trail_begin = 0;
1905 yy_more_flag = 0;
1906 yy_more_len = 0;
1907 yy_more_offset = yy_prev_more_offset = 0;
1908
1909 yy_start_stack_ptr = yy_start_stack_depth = 0;
1910 yy_start_stack = 0;
1911
1912 yy_current_buffer = 0;
1913
1914 #ifdef YY_USES_REJECT
1915
1916 yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
1917 #else
1918
1919 yy_state_buf = 0;
1920 #endif
1921
1922 }
1923
~yyFlexLexer()1924 yyFlexLexer::~yyFlexLexer()
1925 {
1926 delete[] yy_state_buf;
1927 yy_delete_buffer( yy_current_buffer );
1928 }
1929
switch_streams(std::istream * new_in,std::ostream * new_out)1930 void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
1931 {
1932 if ( new_in )
1933 {
1934 yy_delete_buffer( yy_current_buffer );
1935 yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
1936 }
1937
1938 if ( new_out )
1939 yyout = new_out;
1940 }
1941
1942 #ifdef YY_INTERACTIVE
LexerInput(char * buf,int)1943 int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
1944 #else
1945 int yyFlexLexer::LexerInput( char* buf, int max_size )
1946 #endif
1947 {
1948 if ( yyin->eof() || yyin->fail() )
1949 return 0;
1950
1951 #ifdef YY_INTERACTIVE
1952
1953 yyin->get
1954 ( buf[0] );
1955
1956 if ( yyin->eof() )
1957 return 0;
1958
1959 if ( yyin->bad() )
1960 return -1;
1961
1962 return 1;
1963
1964 #else
1965
1966 (void) yyin->read( buf, max_size );
1967
1968 if ( yyin->bad() )
1969 return -1;
1970 else
1971 return yyin->gcount();
1972 #endif
1973
1974 }
1975
LexerOutput(const char * buf,int size)1976 void yyFlexLexer::LexerOutput( const char* buf, int size )
1977 {
1978 (void) yyout->write( buf, size );
1979 }
1980
1981 /* yy_get_next_buffer - try to read in a new buffer
1982 *
1983 * Returns a code representing an action:
1984 * EOB_ACT_LAST_MATCH -
1985 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1986 * EOB_ACT_END_OF_FILE - end of file
1987 */
1988
yy_get_next_buffer()1989 int yyFlexLexer::yy_get_next_buffer()
1990 {
1991 register char *dest = yy_current_buffer->yy_ch_buf;
1992 register char *source = yytext_ptr;
1993 register int number_to_move, i;
1994 int ret_val;
1995
1996 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1997 YY_FATAL_ERROR(
1998 "fatal flex scanner internal error--end of buffer missed" );
1999
2000 if ( yy_current_buffer->yy_fill_buffer == 0 )
2001 { /* Don't try to fill the buffer, so this is an EOF. */
2002 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2003 {
2004 /* We matched a single character, the EOB, so
2005 * treat this as a final EOF.
2006 */
2007 return EOB_ACT_END_OF_FILE;
2008 }
2009
2010 else
2011 {
2012 /* We matched some text prior to the EOB, first
2013 * process it.
2014 */
2015 return EOB_ACT_LAST_MATCH;
2016 }
2017 }
2018
2019 /* Try to read more data. */
2020
2021 /* First move last chars to start of buffer. */
2022 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2023
2024 for ( i = 0; i < number_to_move; ++i )
2025 *(dest++) = *(source++);
2026
2027 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2028 /* don't do the read, it's not guaranteed to return an EOF,
2029 * just force an EOF
2030 */
2031 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2032
2033 else
2034 {
2035 int num_to_read =
2036 yy_current_buffer->yy_buf_size - number_to_move - 1;
2037
2038 while ( num_to_read <= 0 )
2039 { /* Not enough room in the buffer - grow it. */
2040 #if 0
2041 YY_FATAL_ERROR(
2042 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2043 #else
2044
2045 /* just a shorter name for the current buffer */
2046 YY_BUFFER_STATE b = yy_current_buffer;
2047
2048 int yy_c_buf_p_offset =
2049 (int) (yy_c_buf_p - b->yy_ch_buf);
2050
2051 if ( b->yy_is_our_buffer )
2052 {
2053 int new_size = b->yy_buf_size * 2;
2054
2055 if ( new_size <= 0 )
2056 b->yy_buf_size += b->yy_buf_size / 8;
2057 else
2058 b->yy_buf_size *= 2;
2059
2060 b->yy_ch_buf = (char *)
2061 /* Include room in for 2 EOB chars. */
2062 yy_flex_realloc( (void *) b->yy_ch_buf,
2063 b->yy_buf_size + 2 );
2064 }
2065 else
2066 /* Can't grow it, we don't own it. */
2067 b->yy_ch_buf = 0;
2068
2069 if ( ! b->yy_ch_buf )
2070 YY_FATAL_ERROR(
2071 "fatal error - scanner input buffer overflow" );
2072
2073 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2074
2075 num_to_read = yy_current_buffer->yy_buf_size -
2076 number_to_move - 1;
2077 #endif
2078
2079 }
2080
2081 if ( num_to_read > YY_READ_BUF_SIZE )
2082 num_to_read = YY_READ_BUF_SIZE;
2083
2084 /* Read in more data. */
2085 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2086 yy_n_chars, num_to_read );
2087
2088 yy_current_buffer->yy_n_chars = yy_n_chars;
2089 }
2090
2091 if ( yy_n_chars == 0 )
2092 {
2093 if ( number_to_move == YY_MORE_ADJ )
2094 {
2095 ret_val = EOB_ACT_END_OF_FILE;
2096 yyrestart( yyin );
2097 }
2098
2099 else
2100 {
2101 ret_val = EOB_ACT_LAST_MATCH;
2102 yy_current_buffer->yy_buffer_status =
2103 YY_BUFFER_EOF_PENDING;
2104 }
2105 }
2106
2107 else
2108 ret_val = EOB_ACT_CONTINUE_SCAN;
2109
2110 yy_n_chars += number_to_move;
2111 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2112 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2113
2114 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2115
2116 return ret_val;
2117 }
2118
2119
2120 /* yy_get_previous_state - get the state just before the EOB char was reached */
2121
yy_get_previous_state()2122 yy_state_type yyFlexLexer::yy_get_previous_state()
2123 {
2124 register yy_state_type yy_current_state;
2125 register char *yy_cp;
2126
2127 yy_current_state = yy_start;
2128 yy_state_ptr = yy_state_buf;
2129 *yy_state_ptr++ = yy_current_state;
2130
2131 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2132 {
2133 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2134 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2135 {
2136 yy_current_state = (int) yy_def[yy_current_state];
2137 if ( yy_current_state >= 364 )
2138 yy_c = yy_meta[(unsigned int) yy_c];
2139 }
2140 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2141 *yy_state_ptr++ = yy_current_state;
2142 }
2143
2144 return yy_current_state;
2145 }
2146
2147
2148 /* yy_try_NUL_trans - try to make a transition on the NUL character
2149 *
2150 * synopsis
2151 * next_state = yy_try_NUL_trans( current_state );
2152 */
2153
yy_try_NUL_trans(yy_state_type yy_current_state)2154 yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
2155 {
2156 register int yy_is_jam;
2157
2158 register YY_CHAR yy_c = 1;
2159 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2160 {
2161 yy_current_state = (int) yy_def[yy_current_state];
2162 if ( yy_current_state >= 364 )
2163 yy_c = yy_meta[(unsigned int) yy_c];
2164 }
2165 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2166 yy_is_jam = (yy_current_state == 363);
2167 if ( ! yy_is_jam )
2168 *yy_state_ptr++ = yy_current_state;
2169
2170 return yy_is_jam ? 0 : yy_current_state;
2171 }
2172
2173
yyunput(int c,register char * yy_bp)2174 void yyFlexLexer::yyunput( int c, register char* yy_bp )
2175 {
2176 register char *yy_cp = yy_c_buf_p;
2177
2178 /* undo effects of setting up yytext */
2179 *yy_cp = yy_hold_char;
2180
2181 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2182 { /* need to shift things up to make room */
2183 /* +2 for EOB chars. */
2184 register int number_to_move = yy_n_chars + 2;
2185 register char *dest = &yy_current_buffer->yy_ch_buf[
2186 yy_current_buffer->yy_buf_size + 2];
2187 register char *source =
2188 &yy_current_buffer->yy_ch_buf[number_to_move];
2189
2190 while ( source > yy_current_buffer->yy_ch_buf )
2191 *--dest = *--source;
2192
2193 yy_cp += (int) (dest - source);
2194 yy_bp += (int) (dest - source);
2195 yy_current_buffer->yy_n_chars =
2196 yy_n_chars = yy_current_buffer->yy_buf_size;
2197
2198 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2199 YY_FATAL_ERROR( "flex scanner push-back overflow" );
2200 }
2201
2202 *--yy_cp = (char) c;
2203
2204 if ( c == '\n' )
2205 --yylineno;
2206
2207 yytext_ptr = yy_bp;
2208 yy_hold_char = *yy_cp;
2209 yy_c_buf_p = yy_cp;
2210 }
2211
2212
yyinput()2213 int yyFlexLexer::yyinput()
2214 {
2215 int c;
2216
2217 *yy_c_buf_p = yy_hold_char;
2218
2219 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2220 {
2221 /* yy_c_buf_p now points to the character we want to return.
2222 * If this occurs *before* the EOB characters, then it's a
2223 * valid NUL; if not, then we've hit the end of the buffer.
2224 */
2225 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2226 /* This was really a NUL. */
2227 *yy_c_buf_p = '\0';
2228
2229 else
2230 { /* need more input */
2231 int offset = yy_c_buf_p - yytext_ptr;
2232 ++yy_c_buf_p;
2233
2234 switch ( yy_get_next_buffer() )
2235 {
2236 case EOB_ACT_LAST_MATCH:
2237 /* This happens because yy_g_n_b()
2238 * sees that we've accumulated a
2239 * token and flags that we need to
2240 * try matching the token before
2241 * proceeding. But for input(),
2242 * there's no matching to consider.
2243 * So convert the EOB_ACT_LAST_MATCH
2244 * to EOB_ACT_END_OF_FILE.
2245 */
2246
2247 /* Reset buffer status. */
2248 yyrestart( yyin );
2249
2250 /* fall through */
2251
2252 case EOB_ACT_END_OF_FILE:
2253 {
2254 if ( yywrap() )
2255 return EOF;
2256
2257 if ( ! yy_did_buffer_switch_on_eof )
2258 YY_NEW_FILE;
2259 #ifdef __cplusplus
2260
2261 return yyinput();
2262 #else
2263
2264 return input();
2265 #endif
2266
2267 }
2268
2269 case EOB_ACT_CONTINUE_SCAN:
2270 yy_c_buf_p = yytext_ptr + offset;
2271 break;
2272 }
2273 }
2274 }
2275
2276 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
2277 *yy_c_buf_p = '\0'; /* preserve yytext */
2278 yy_hold_char = *++yy_c_buf_p;
2279
2280 if ( c == '\n' )
2281 ++yylineno;
2282
2283 return c;
2284 }
2285
2286
yyrestart(std::istream * input_file)2287 void yyFlexLexer::yyrestart( std::istream* input_file )
2288 {
2289 if ( ! yy_current_buffer )
2290 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2291
2292 yy_init_buffer( yy_current_buffer, input_file );
2293 yy_load_buffer_state();
2294 }
2295
2296
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)2297 void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2298 {
2299 if ( yy_current_buffer == new_buffer )
2300 return ;
2301
2302 if ( yy_current_buffer )
2303 {
2304 /* Flush out information for old buffer. */
2305 *yy_c_buf_p = yy_hold_char;
2306 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2307 yy_current_buffer->yy_n_chars = yy_n_chars;
2308 }
2309
2310 yy_current_buffer = new_buffer;
2311 yy_load_buffer_state();
2312
2313 /* We don't actually know whether we did this switch during
2314 * EOF (yywrap()) processing, but the only time this flag
2315 * is looked at is after yywrap() is called, so it's safe
2316 * to go ahead and always set it.
2317 */
2318 yy_did_buffer_switch_on_eof = 1;
2319 }
2320
2321
yy_load_buffer_state()2322 void yyFlexLexer::yy_load_buffer_state()
2323 {
2324 yy_n_chars = yy_current_buffer->yy_n_chars;
2325 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2326 yyin = yy_current_buffer->yy_input_file;
2327 yy_hold_char = *yy_c_buf_p;
2328 }
2329
2330
yy_create_buffer(std::istream * file,int size)2331 YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
2332 {
2333 YY_BUFFER_STATE b;
2334
2335 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2336 if ( ! b )
2337 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2338
2339 b->yy_buf_size = size;
2340
2341 /* yy_ch_buf has to be 2 characters longer than the size given because
2342 * we need to put in 2 end-of-buffer characters.
2343 */
2344 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2345 if ( ! b->yy_ch_buf )
2346 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2347
2348 b->yy_is_our_buffer = 1;
2349
2350 yy_init_buffer( b, file );
2351
2352 return b;
2353 }
2354
2355
yy_delete_buffer(YY_BUFFER_STATE b)2356 void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
2357 {
2358 if ( ! b )
2359 return ;
2360
2361 if ( b == yy_current_buffer )
2362 yy_current_buffer = (YY_BUFFER_STATE) 0;
2363
2364 if ( b->yy_is_our_buffer )
2365 yy_flex_free( (void *) b->yy_ch_buf );
2366
2367 yy_flex_free( (void *) b );
2368 }
2369
2370
2371 /*extern "C" int isatty YY_PROTO(( int ));*/
yy_init_buffer(YY_BUFFER_STATE b,std::istream * file)2372 void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
2373
2374 {
2375 yy_flush_buffer( b );
2376
2377 b->yy_input_file = file;
2378 b->yy_fill_buffer = 1;
2379
2380 b->yy_is_interactive = 0;
2381 }
2382
2383
yy_flush_buffer(YY_BUFFER_STATE b)2384 void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
2385 {
2386 if ( ! b )
2387 return ;
2388
2389 b->yy_n_chars = 0;
2390
2391 /* We always need two end-of-buffer characters. The first causes
2392 * a transition to the end-of-buffer state. The second causes
2393 * a jam in that state.
2394 */
2395 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2396 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2397
2398 b->yy_buf_pos = &b->yy_ch_buf[0];
2399
2400 b->yy_at_bol = 1;
2401 b->yy_buffer_status = YY_BUFFER_NEW;
2402
2403 if ( b == yy_current_buffer )
2404 yy_load_buffer_state();
2405 }
2406
2407
2408 #ifndef YY_NO_SCAN_BUFFER
2409 #endif
2410
2411
2412 #ifndef YY_NO_SCAN_STRING
2413 #endif
2414
2415
2416 #ifndef YY_NO_SCAN_BYTES
2417 #endif
2418
2419
2420 #ifndef YY_NO_PUSH_STATE
yy_push_state(int new_state)2421 void yyFlexLexer::yy_push_state( int new_state )
2422 {
2423 if ( yy_start_stack_ptr >= yy_start_stack_depth )
2424 {
2425 yy_size_t new_size;
2426
2427 yy_start_stack_depth += YY_START_STACK_INCR;
2428 new_size = yy_start_stack_depth * sizeof( int );
2429
2430 if ( ! yy_start_stack )
2431 yy_start_stack = (int *) yy_flex_alloc( new_size );
2432
2433 else
2434 yy_start_stack = (int *) yy_flex_realloc(
2435 (void *) yy_start_stack, new_size );
2436
2437 if ( ! yy_start_stack )
2438 YY_FATAL_ERROR(
2439 "out of memory expanding start-condition stack" );
2440 }
2441
2442 yy_start_stack[yy_start_stack_ptr++] = YY_START;
2443
2444 BEGIN(new_state);
2445 }
2446 #endif
2447
2448
2449 #ifndef YY_NO_POP_STATE
yy_pop_state()2450 void yyFlexLexer::yy_pop_state()
2451 {
2452 if ( --yy_start_stack_ptr < 0 )
2453 YY_FATAL_ERROR( "start-condition stack underflow" );
2454
2455 BEGIN(yy_start_stack[yy_start_stack_ptr]);
2456 }
2457 #endif
2458
2459
2460 #ifndef YY_NO_TOP_STATE
yy_top_state()2461 int yyFlexLexer::yy_top_state()
2462 {
2463 return yy_start_stack[yy_start_stack_ptr - 1];
2464 }
2465 #endif
2466
2467 #ifndef YY_EXIT_FAILURE
2468 #define YY_EXIT_FAILURE 2
2469 #endif
2470
2471
LexerError(yyconst char msg[])2472 void yyFlexLexer::LexerError( yyconst char msg[] )
2473 {
2474 std::cerr << msg << '\n';
2475 exit( YY_EXIT_FAILURE );
2476 }
2477
2478
2479 /* Redefine yyless() so it works in section 3 code. */
2480
2481 #undef yyless
2482 #define yyless(n) \
2483 do \
2484 { \
2485 /* Undo effects of setting up yytext. */ \
2486 yytext[yyleng] = yy_hold_char; \
2487 yy_c_buf_p = yytext + n; \
2488 yy_hold_char = *yy_c_buf_p; \
2489 *yy_c_buf_p = '\0'; \
2490 yyleng = n; \
2491 } \
2492 while ( 0 )
2493
2494
2495 /* Internal utility routines. */
2496
2497 #ifndef yytext_ptr
2498 #ifdef YY_USE_PROTOS
yy_flex_strncpy(char * s1,yyconst char * s2,int n)2499 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2500 #else
2501 static void yy_flex_strncpy( s1, s2, n )
2502 char *s1;
2503 yyconst char *s2;
2504 int n;
2505 #endif
2506
2507 {
2508 register int i;
2509 for ( i = 0; i < n; ++i )
2510 s1[i] = s2[i];
2511 }
2512 #endif
2513
2514 #ifdef YY_NEED_STRLEN
2515 #ifdef YY_USE_PROTOS
yy_flex_strlen(yyconst char * s)2516 static int yy_flex_strlen( yyconst char *s )
2517 #else
2518 static int yy_flex_strlen( s )
2519 yyconst char *s;
2520 #endif
2521
2522 {
2523 register int n;
2524 for ( n = 0; s[n]; ++n )
2525 ;
2526
2527 return n;
2528 }
2529 #endif
2530
2531
2532 #ifdef YY_USE_PROTOS
yy_flex_alloc(yy_size_t size)2533 static void *yy_flex_alloc( yy_size_t size )
2534 #else
2535 static void *yy_flex_alloc( size )
2536 yy_size_t size;
2537 #endif
2538
2539 {
2540 return (void *) malloc( size );
2541 }
2542
2543 #ifdef YY_USE_PROTOS
yy_flex_realloc(void * ptr,yy_size_t size)2544 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2545 #else
2546 static void *yy_flex_realloc( ptr, size )
2547 void *ptr;
2548 yy_size_t size;
2549 #endif
2550
2551 {
2552 /* The cast to (char *) in the following accommodates both
2553 * implementations that use char* generic pointers, and those
2554 * that use void* generic pointers. It works with the latter
2555 * because both ANSI C and C++ allow castless assignment from
2556 * any pointer type to void*, and deal with argument conversions
2557 * as though doing an assignment.
2558 */
2559 return (void *) realloc( (char *) ptr, size );
2560 }
2561
2562 #ifdef YY_USE_PROTOS
yy_flex_free(void * ptr)2563 static void yy_flex_free( void *ptr )
2564 #else
2565 static void yy_flex_free( ptr )
2566 void *ptr;
2567 #endif
2568
2569 {
2570 free( ptr );
2571 }
2572
2573 #if YY_MAIN
main()2574 int main()
2575 {
2576 yylex();
2577 return 0;
2578 }
2579 #endif
2580
2581
2582
2583 } // namespace flex
2584