1
#define yy_create_buffer csim__create_buffer
2
#define yy_delete_buffer csim__delete_buffer
3
#define yy_scan_buffer csim__scan_buffer
4
#define yy_scan_string csim__scan_string
5
#define yy_scan_bytes csim__scan_bytes
6
#define yy_flex_debug csim__flex_debug
7
#define yy_init_buffer csim__init_buffer
8
#define yy_flush_buffer csim__flush_buffer
9
#define yy_load_buffer_state csim__load_buffer_state
10
#define yy_switch_to_buffer csim__switch_to_buffer
12
#define yyleng csim_leng
13
#define yylex csim_lex
14
#define yyout csim_out
15
#define yyrestart csim_restart
16
#define yytext csim_text
18
/* A lexical scanner generated by flex */
20
/* Scanner skeleton version:
21
* $Header: /cvs/gnome/gimp/plug-ins/imagemap/imap_csim_lex.c,v 1.8 2003/12/26 20:30:36 neo Exp $
25
#define YY_FLEX_MAJOR_VERSION 2
26
#define YY_FLEX_MINOR_VERSION 5
34
#define isatty(h) _isatty(h)
37
/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
49
/* Use prototypes in function declarations. */
52
/* The "const" storage-class-modifier is valid. */
55
#else /* ! __cplusplus */
63
#endif /* ! __cplusplus */
82
#define YY_PROTO(proto) proto
84
#define YY_PROTO(proto) ()
87
/* Returned upon end-of-file. */
90
/* Promotes a possibly negative, possibly signed char to an unsigned
91
* integer for use as an array index. If the signed char is negative,
92
* we want to instead treat it as an 8-bit unsigned char, hence the
95
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
97
/* Enter a start condition. This macro really ought to take a parameter,
98
* but we do it the disgusting crufty way forced on us by the ()-less
99
* definition of BEGIN.
101
#define BEGIN yy_start = 1 + 2 *
103
/* Translate the current start state into a value that can be later handed
104
* to BEGIN to return to the state. The YYSTATE alias is for lex
107
#define YY_START ((yy_start - 1) / 2)
108
#define YYSTATE YY_START
110
/* Action number for EOF rule of a given start state. */
111
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
113
/* Special action meaning "start processing a new file". */
114
#define YY_NEW_FILE yyrestart( yyin )
116
#define YY_END_OF_BUFFER_CHAR 0
118
/* Size of default input buffer. */
119
#define YY_BUF_SIZE 16384
121
typedef struct yy_buffer_state *YY_BUFFER_STATE;
124
extern FILE *yyin, *yyout;
126
#define EOB_ACT_CONTINUE_SCAN 0
127
#define EOB_ACT_END_OF_FILE 1
128
#define EOB_ACT_LAST_MATCH 2
130
/* The funky do-while in the following #define is used to turn the definition
131
* int a single C statement (which needs a semi-colon terminator). This
132
* avoids problems with code like:
134
* if ( condition_holds )
137
* do_something_else();
139
* Prior to using the do-while the compiler would get upset at the
140
* "else" because it interpreted the "if" statement as being all
141
* done when it reached the ';' after the yyless() call.
144
/* Return all but the first 'n' matched characters back to the input stream. */
149
/* Undo effects of setting up yytext. */ \
150
*yy_cp = yy_hold_char; \
151
YY_RESTORE_YY_MORE_OFFSET \
152
yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
153
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
157
#define unput(c) yyunput( c, yytext_ptr )
159
/* The following is because we cannot portably get our hands on size_t
160
* (without autoconf's help, which isn't available because we want
161
* flex-generated scanners to compile on their own).
163
typedef unsigned int yy_size_t;
166
struct yy_buffer_state
170
char *yy_ch_buf; /* input buffer */
171
char *yy_buf_pos; /* current position in input buffer */
173
/* Size of input buffer in bytes, not including room for EOB
176
yy_size_t yy_buf_size;
178
/* Number of characters read into yy_ch_buf, not including EOB
183
/* Whether we "own" the buffer - i.e., we know we created it,
184
* and can realloc() it to grow it, and should free() it to
187
int yy_is_our_buffer;
189
/* Whether this is an "interactive" input source; if so, and
190
* if we're using stdio for input, then we want to use getc()
191
* instead of fread(), to make sure we stop fetching input after
194
int yy_is_interactive;
196
/* Whether we're considered to be at the beginning of a line.
197
* If so, '^' rules will be active on the next match, otherwise
202
/* Whether to try to fill the input buffer when we reach the
207
int yy_buffer_status;
208
#define YY_BUFFER_NEW 0
209
#define YY_BUFFER_NORMAL 1
210
/* When an EOF's been seen but there's still some text to process
211
* then we mark the buffer as YY_EOF_PENDING, to indicate that we
212
* shouldn't try reading from the input source any more. We might
213
* still have a bunch of tokens to match, though, because of
214
* possible backing-up.
216
* When we actually see the EOF, we change the status to "new"
217
* (via yyrestart()), so that the user can continue scanning by
218
* just pointing yyin at a new input file.
220
#define YY_BUFFER_EOF_PENDING 2
223
static YY_BUFFER_STATE yy_current_buffer = 0;
225
/* We provide macros for accessing buffer states in case in the
226
* future we want to put the buffer states in a more general
229
#define YY_CURRENT_BUFFER yy_current_buffer
232
/* yy_hold_char holds the character lost when yytext is formed. */
233
static char yy_hold_char;
235
static int yy_n_chars; /* number of characters read into yy_ch_buf */
240
/* Points to current character in buffer. */
241
static char *yy_c_buf_p = (char *) 0;
242
static int yy_init = 1; /* whether we need to initialize */
243
static int yy_start = 0; /* start state number */
245
/* Flag which is used to allow yywrap()'s to do buffer switches
246
* instead of setting up a fresh yyin. A bit of a hack ...
248
static int yy_did_buffer_switch_on_eof;
250
void yyrestart YY_PROTO(( FILE *input_file ));
252
void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
253
void yy_load_buffer_state YY_PROTO(( void ));
254
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
255
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
256
void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
257
void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
258
#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
260
YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
261
YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
262
YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
264
static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
265
static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
266
static void yy_flex_free YY_PROTO(( void * ));
268
#define yy_new_buffer yy_create_buffer
270
#define yy_set_interactive(is_interactive) \
272
if ( ! yy_current_buffer ) \
273
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
274
yy_current_buffer->yy_is_interactive = is_interactive; \
277
#define yy_set_bol(at_bol) \
279
if ( ! yy_current_buffer ) \
280
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
281
yy_current_buffer->yy_at_bol = at_bol; \
284
#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
288
#define YY_SKIP_YYWRAP
289
typedef unsigned char YY_CHAR;
290
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
291
typedef int yy_state_type;
293
#define yytext_ptr yytext
295
static yy_state_type yy_get_previous_state YY_PROTO(( void ));
296
static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
297
static int yy_get_next_buffer YY_PROTO(( void ));
298
static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
300
/* Done after the current pattern has been matched and before the
301
* corresponding action - sets up yytext.
303
#define YY_DO_BEFORE_ACTION \
304
yytext_ptr = yy_bp; \
305
yyleng = (int) (yy_cp - yy_bp); \
306
yy_hold_char = *yy_cp; \
310
#define YY_NUM_RULES 32
311
#define YY_END_OF_BUFFER 33
312
static yyconst short int yy_accept[154] =
314
29, 29, 28, 28, 0, 0, 33, 31, 30, 30,
315
26, 29, 29, 31, 29, 31, 31, 31, 31, 29,
316
31, 31, 31, 31, 31, 31, 31, 31, 31, 28,
317
27, 32, 32, 32, 30, 29, 29, 29, 29, 0,
318
0, 0, 0, 0, 0, 29, 29, 0, 0, 0,
319
0, 0, 0, 0, 0, 0, 0, 0, 0, 28,
320
0, 0, 0, 0, 0, 23, 0, 0, 0, 0,
321
0, 6, 12, 0, 0, 0, 0, 0, 0, 7,
322
0, 0, 0, 0, 4, 13, 3, 15, 0, 0,
323
0, 24, 14, 0, 0, 0, 0, 0, 0, 0,
325
0, 5, 0, 0, 0, 0, 0, 0, 0, 0,
326
16, 0, 0, 8, 0, 10, 17, 9, 25, 22,
327
0, 0, 18, 11, 0, 21, 0, 0, 0, 0,
328
0, 0, 0, 0, 0, 0, 20, 0, 0, 0,
329
19, 0, 0, 0, 0, 1, 0, 0, 0, 0,
333
static yyconst int yy_ec[256] =
335
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
336
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
337
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
338
1, 4, 5, 6, 7, 8, 1, 1, 1, 1,
339
1, 1, 9, 1, 10, 11, 12, 13, 13, 13,
340
13, 13, 13, 13, 13, 13, 13, 14, 1, 15,
341
1, 16, 1, 1, 17, 18, 19, 20, 21, 22,
342
23, 24, 25, 1, 1, 26, 27, 28, 29, 30,
343
1, 31, 32, 33, 34, 35, 36, 1, 1, 1,
344
1, 1, 1, 1, 1, 1, 17, 18, 19, 20,
346
21, 22, 23, 24, 25, 1, 1, 26, 27, 28,
347
29, 30, 1, 31, 32, 33, 34, 35, 36, 1,
348
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
349
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
350
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
351
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
352
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
353
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
354
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
355
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
357
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
358
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
359
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
360
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
361
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
365
static yyconst int yy_meta[37] =
367
1, 1, 2, 1, 1, 3, 1, 1, 1, 1,
368
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
369
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
373
static yyconst short int yy_base[158] =
375
0, 0, 193, 192, 34, 35, 197, 200, 37, 44,
376
200, 38, 29, 169, 41, 190, 27, 165, 164, 47,
377
34, 165, 174, 44, 162, 39, 172, 156, 162, 0,
378
200, 176, 200, 175, 64, 51, 58, 65, 63, 167,
379
173, 149, 160, 149, 150, 165, 164, 151, 154, 151,
380
143, 145, 147, 59, 153, 150, 137, 146, 146, 0,
381
155, 154, 72, 133, 152, 200, 144, 140, 128, 135,
382
135, 200, 200, 135, 124, 128, 124, 123, 121, 200,
383
127, 122, 115, 73, 137, 200, 142, 200, 124, 124,
384
119, 200, 200, 121, 107, 121, 105, 117, 116, 119,
386
111, 124, 126, 101, 99, 97, 107, 97, 93, 94,
387
200, 92, 94, 200, 115, 200, 200, 200, 200, 200,
388
90, 100, 200, 200, 70, 200, 91, 85, 97, 57,
389
84, 84, 82, 93, 89, 93, 200, 80, 81, 78,
390
200, 77, 82, 92, 75, 200, 71, 77, 56, 52,
391
29, 200, 200, 92, 95, 98, 100
394
static yyconst short int yy_def[158] =
396
153, 1, 154, 154, 155, 155, 153, 153, 153, 153,
397
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
398
153, 153, 153, 153, 153, 153, 153, 153, 153, 156,
399
153, 157, 153, 157, 153, 153, 153, 153, 153, 153,
400
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
401
153, 153, 153, 153, 153, 153, 153, 153, 153, 156,
402
157, 157, 157, 153, 153, 153, 153, 153, 153, 153,
403
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
404
153, 153, 153, 157, 157, 153, 153, 153, 153, 153,
405
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
407
153, 157, 153, 153, 153, 153, 153, 153, 153, 153,
408
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
409
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
410
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
411
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
412
153, 153, 0, 153, 153, 153, 153
415
static yyconst short int yy_nxt[237] =
417
8, 9, 10, 9, 8, 11, 8, 8, 8, 12,
418
13, 14, 15, 8, 16, 8, 17, 18, 19, 8,
419
20, 8, 8, 21, 22, 8, 23, 24, 25, 8,
420
8, 26, 27, 28, 8, 29, 33, 33, 35, 35,
421
35, 39, 152, 34, 34, 35, 35, 35, 36, 38,
422
37, 36, 42, 37, 48, 46, 46, 43, 38, 47,
423
52, 38, 55, 39, 49, 35, 35, 35, 36, 56,
424
37, 38, 53, 46, 46, 39, 76, 47, 38, 151,
425
77, 84, 84, 38, 150, 78, 128, 85, 102, 129,
426
133, 134, 30, 30, 30, 32, 32, 32, 60, 60,
428
61, 149, 61, 148, 147, 146, 145, 144, 143, 142,
429
141, 140, 139, 138, 137, 136, 135, 132, 131, 130,
430
127, 126, 125, 124, 123, 122, 121, 120, 119, 118,
431
117, 116, 115, 62, 114, 113, 112, 111, 110, 109,
432
108, 107, 106, 105, 104, 103, 62, 101, 100, 99,
433
98, 97, 96, 95, 94, 93, 92, 91, 90, 89,
434
88, 87, 86, 84, 62, 83, 82, 81, 80, 79,
435
75, 74, 73, 72, 71, 70, 47, 47, 69, 68,
436
67, 66, 65, 64, 63, 62, 59, 58, 57, 54,
437
51, 50, 45, 44, 41, 40, 153, 31, 31, 7,
439
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
440
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
441
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
442
153, 153, 153, 153, 153, 153
445
static yyconst short int yy_chk[237] =
447
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
450
1, 1, 1, 1, 1, 1, 5, 6, 9, 9,
451
9, 13, 151, 5, 6, 10, 10, 10, 12, 13,
452
12, 15, 17, 15, 21, 20, 20, 17, 12, 20,
453
24, 15, 26, 36, 21, 35, 35, 35, 37, 26,
454
37, 36, 24, 38, 38, 39, 54, 38, 37, 150,
455
54, 63, 84, 39, 149, 54, 125, 63, 84, 125,
456
130, 130, 154, 154, 154, 155, 155, 155, 156, 156,
458
157, 148, 157, 147, 145, 144, 143, 142, 140, 139,
459
138, 136, 135, 134, 133, 132, 131, 129, 128, 127,
460
122, 121, 115, 113, 112, 110, 109, 108, 107, 106,
461
105, 104, 103, 102, 101, 100, 99, 98, 97, 96,
462
95, 94, 91, 90, 89, 87, 85, 83, 82, 81,
463
79, 78, 77, 76, 75, 74, 71, 70, 69, 68,
464
67, 65, 64, 62, 61, 59, 58, 57, 56, 55,
465
53, 52, 51, 50, 49, 48, 47, 46, 45, 44,
466
43, 42, 41, 40, 34, 32, 29, 28, 27, 25,
467
23, 22, 19, 18, 16, 14, 7, 4, 3, 153,
469
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
470
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
471
153, 153, 153, 153, 153, 153, 153, 153, 153, 153,
472
153, 153, 153, 153, 153, 153
475
static yy_state_type yy_last_accepting_state;
476
static char *yy_last_accepting_cpos;
478
/* The intent behind this definition is that it'll catch
479
* any uses of REJECT which flex missed.
481
#define REJECT reject_used_but_not_detected
482
#define yymore() yymore_used_but_not_detected
483
#define YY_MORE_ADJ 0
484
#define YY_RESTORE_YY_MORE_OFFSET
486
#line 1 "imap_csim.l"
488
#line 2 "imap_csim.l"
490
* This is a plug-in for the GIMP.
492
* Generates clickable image maps.
494
* Copyright (C) 1998-2000 Maurits Rijk lpeek.mrijk@consunet.nl
496
* This program is free software; you can redistribute it and/or modify
497
* it under the terms of the GNU General Public License as published by
498
* the Free Software Foundation; either version 2 of the License, or
499
* (at your option) any later version.
501
* This program is distributed in the hope that it will be useful,
502
* but WITHOUT ANY WARRANTY; without even the implied warranty of
503
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
504
* GNU General Public License for more details.
506
* You should have received a copy of the GNU General Public License
507
* along with this program; if not, write to the Free Software
508
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
514
#include "imap_csim_parse.h"
518
#endif /* FLEX_SCANNER */
520
#define quoted_string 1
525
/* Macros after this point can all be overridden by user definitions in
529
#ifndef YY_SKIP_YYWRAP
531
extern "C" int yywrap YY_PROTO(( void ));
533
extern int yywrap YY_PROTO(( void ));
538
static void yyunput YY_PROTO(( int c, char *buf_ptr ));
542
static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
545
#ifdef YY_NEED_STRLEN
546
static int yy_flex_strlen YY_PROTO(( yyconst char * ));
551
static int yyinput YY_PROTO(( void ));
553
static int input YY_PROTO(( void ));
558
static int yy_start_stack_ptr = 0;
559
static int yy_start_stack_depth = 0;
560
static int *yy_start_stack = 0;
561
#ifndef YY_NO_PUSH_STATE
562
static void yy_push_state YY_PROTO(( int new_state ));
564
#ifndef YY_NO_POP_STATE
565
static void yy_pop_state YY_PROTO(( void ));
567
#ifndef YY_NO_TOP_STATE
568
static int yy_top_state YY_PROTO(( void ));
572
#define YY_NO_PUSH_STATE 1
573
#define YY_NO_POP_STATE 1
574
#define YY_NO_TOP_STATE 1
577
#ifdef YY_MALLOC_DECL
585
/* Just try to get by without declaring the routines. This will fail
586
* miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
587
* or sizeof(void*) != sizeof(int).
592
/* Amount of stuff to slurp up with each read. */
593
#ifndef YY_READ_BUF_SIZE
594
#define YY_READ_BUF_SIZE 8192
597
/* Copy whatever the last rule matched to the standard output. */
600
/* This used to be an fputs(), but since the string might contain NUL's,
601
* we now use fwrite().
603
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
606
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
607
* is returned in "result".
610
#define YY_INPUT(buf,result,max_size) \
611
if ( yy_current_buffer->yy_is_interactive ) \
614
for ( n = 0; n < max_size && \
615
(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
618
buf[n++] = (char) c; \
619
if ( c == EOF && ferror( yyin ) ) \
620
YY_FATAL_ERROR( "input in flex scanner failed" ); \
623
else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
624
&& ferror( yyin ) ) \
625
YY_FATAL_ERROR( "input in flex scanner failed" );
628
/* No semi-colon after return; correct usage is to write "yyterminate();" -
629
* we don't want an extra ';' after the "return" because that will cause
630
* some compilers to complain about unreachable statements.
633
#define yyterminate() return YY_NULL
636
/* Number of entries by which start-condition stack grows. */
637
#ifndef YY_START_STACK_INCR
638
#define YY_START_STACK_INCR 25
641
/* Report a fatal error. */
642
#ifndef YY_FATAL_ERROR
643
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
646
/* Default declaration of generated scanner - a define so the user can
647
* easily add parameters.
650
#define YY_DECL int yylex YY_PROTO(( void ))
653
/* Code executed at the beginning of each rule, after yytext and yyleng
656
#ifndef YY_USER_ACTION
657
#define YY_USER_ACTION
660
/* Code executed at the end of each rule. */
662
#define YY_BREAK break;
665
#define YY_RULE_SETUP \
670
register yy_state_type yy_current_state;
671
register char *yy_cp, *yy_bp;
674
#line 44 "imap_csim.l"
687
yy_start = 1; /* first start state */
695
if ( ! yy_current_buffer )
697
yy_create_buffer( yyin, YY_BUF_SIZE );
699
yy_load_buffer_state();
702
while ( 1 ) /* loops until end-of-file is reached */
706
/* Support of yytext. */
707
*yy_cp = yy_hold_char;
709
/* yy_bp points to the position in yy_ch_buf of the start of
714
yy_current_state = yy_start;
718
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
719
if ( yy_accept[yy_current_state] )
721
yy_last_accepting_state = yy_current_state;
722
yy_last_accepting_cpos = yy_cp;
724
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
726
yy_current_state = (int) yy_def[yy_current_state];
727
if ( yy_current_state >= 154 )
728
yy_c = yy_meta[(unsigned int) yy_c];
730
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
733
while ( yy_base[yy_current_state] != 200 );
736
yy_act = yy_accept[yy_current_state];
738
{ /* have to back up */
739
yy_cp = yy_last_accepting_cpos;
740
yy_current_state = yy_last_accepting_state;
741
yy_act = yy_accept[yy_current_state];
747
do_action: /* This label is used only to access EOF actions. */
751
{ /* beginning of action switch */
752
case 0: /* must back up */
753
/* undo the effects of YY_DO_BEFORE_ACTION */
754
*yy_cp = yy_hold_char;
755
yy_cp = yy_last_accepting_cpos;
756
yy_current_state = yy_last_accepting_state;
761
#line 46 "imap_csim.l"
769
#line 51 "imap_csim.l"
777
#line 56 "imap_csim.l"
780
return BEGIN_COMMENT;
785
#line 61 "imap_csim.l"
792
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
793
yy_c_buf_p = yy_cp -= 3;
794
YY_DO_BEFORE_ACTION; /* set up yytext again */
796
#line 66 "imap_csim.l"
798
strcpy(csim_lval.id, yytext);
799
csim_lval.id[yyleng - 1] = '\0';
805
#line 72 "imap_csim.l"
810
#line 74 "imap_csim.l"
815
#line 76 "imap_csim.l"
820
#line 78 "imap_csim.l"
825
#line 80 "imap_csim.l"
830
#line 82 "imap_csim.l"
835
#line 84 "imap_csim.l"
840
#line 86 "imap_csim.l"
845
#line 88 "imap_csim.l"
850
#line 90 "imap_csim.l"
855
#line 92 "imap_csim.l"
860
#line 94 "imap_csim.l"
865
#line 96 "imap_csim.l"
870
#line 98 "imap_csim.l"
875
#line 100 "imap_csim.l"
880
#line 102 "imap_csim.l"
885
#line 104 "imap_csim.l"
890
#line 106 "imap_csim.l"
895
#line 108 "imap_csim.l"
900
#line 110 "imap_csim.l"
905
#line 112 "imap_csim.l"
907
BEGIN(quoted_string);
913
#line 117 "imap_csim.l"
921
#line 122 "imap_csim.l"
922
strcpy(csim_lval.id, yytext);
926
#line 124 "imap_csim.l"
928
csim_lval.value = atof(yytext);
934
#line 129 "imap_csim.l"
935
; /* Eat white space */
939
#line 131 "imap_csim.l"
944
#line 133 "imap_csim.l"
947
case YY_STATE_EOF(INITIAL):
948
case YY_STATE_EOF(quoted_string):
949
case YY_STATE_EOF(comment):
952
case YY_END_OF_BUFFER:
954
/* Amount of text matched not including the EOB char. */
955
int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
957
/* Undo the effects of YY_DO_BEFORE_ACTION. */
958
*yy_cp = yy_hold_char;
959
YY_RESTORE_YY_MORE_OFFSET
961
if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
963
/* We're scanning a new file or input source. It's
964
* possible that this happened because the user
965
* just pointed yyin at a new source and called
966
* yylex(). If so, then we have to assure
967
* consistency between yy_current_buffer and our
968
* globals. Here is the right place to do so, because
969
* this is the first action (other than possibly a
970
* back-up) that will match for the new input source.
972
yy_n_chars = yy_current_buffer->yy_n_chars;
973
yy_current_buffer->yy_input_file = yyin;
974
yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
977
/* Note that here we test for yy_c_buf_p "<=" to the position
978
* of the first EOB in the buffer, since yy_c_buf_p will
979
* already have been incremented past the NUL character
980
* (since all states make transitions on EOB to the
981
* end-of-buffer state). Contrast this with the test
984
if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
985
{ /* This was really a NUL. */
986
yy_state_type yy_next_state;
988
yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
990
yy_current_state = yy_get_previous_state();
992
/* Okay, we're now positioned to make the NUL
993
* transition. We couldn't have
994
* yy_get_previous_state() go ahead and do it
995
* for us because it doesn't know how to deal
996
* with the possibility of jamming (and we don't
997
* want to build jamming into it because then it
998
* will run more slowly).
1001
yy_next_state = yy_try_NUL_trans( yy_current_state );
1003
yy_bp = yytext_ptr + YY_MORE_ADJ;
1005
if ( yy_next_state )
1007
/* Consume the NUL. */
1008
yy_cp = ++yy_c_buf_p;
1009
yy_current_state = yy_next_state;
1016
goto yy_find_action;
1020
else switch ( yy_get_next_buffer() )
1022
case EOB_ACT_END_OF_FILE:
1024
yy_did_buffer_switch_on_eof = 0;
1028
/* Note: because we've taken care in
1029
* yy_get_next_buffer() to have set up
1030
* yytext, we can now set up
1031
* yy_c_buf_p so that if some total
1032
* hoser (like flex itself) wants to
1033
* call the scanner after we return the
1034
* YY_NULL, it'll still work - another
1035
* YY_NULL will get returned.
1037
yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1039
yy_act = YY_STATE_EOF(YY_START);
1045
if ( ! yy_did_buffer_switch_on_eof )
1051
case EOB_ACT_CONTINUE_SCAN:
1053
yytext_ptr + yy_amount_of_matched_text;
1055
yy_current_state = yy_get_previous_state();
1058
yy_bp = yytext_ptr + YY_MORE_ADJ;
1061
case EOB_ACT_LAST_MATCH:
1063
&yy_current_buffer->yy_ch_buf[yy_n_chars];
1065
yy_current_state = yy_get_previous_state();
1068
yy_bp = yytext_ptr + YY_MORE_ADJ;
1069
goto yy_find_action;
1076
"fatal flex scanner internal error--no action found" );
1077
} /* end of action switch */
1078
} /* end of scanning one token */
1079
} /* end of yylex */
1082
/* yy_get_next_buffer - try to read in a new buffer
1084
* Returns a code representing an action:
1085
* EOB_ACT_LAST_MATCH -
1086
* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1087
* EOB_ACT_END_OF_FILE - end of file
1090
static int yy_get_next_buffer()
1092
register char *dest = yy_current_buffer->yy_ch_buf;
1093
register char *source = yytext_ptr;
1094
register int number_to_move, i;
1097
if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1099
"fatal flex scanner internal error--end of buffer missed" );
1101
if ( yy_current_buffer->yy_fill_buffer == 0 )
1102
{ /* Don't try to fill the buffer, so this is an EOF. */
1103
if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1105
/* We matched a single character, the EOB, so
1106
* treat this as a final EOF.
1108
return EOB_ACT_END_OF_FILE;
1113
/* We matched some text prior to the EOB, first
1116
return EOB_ACT_LAST_MATCH;
1120
/* Try to read more data. */
1122
/* First move last chars to start of buffer. */
1123
number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1125
for ( i = 0; i < number_to_move; ++i )
1126
*(dest++) = *(source++);
1128
if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1129
/* don't do the read, it's not guaranteed to return an EOF,
1132
yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1137
yy_current_buffer->yy_buf_size - number_to_move - 1;
1139
while ( num_to_read <= 0 )
1140
{ /* Not enough room in the buffer - grow it. */
1141
#ifdef YY_USES_REJECT
1143
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1146
/* just a shorter name for the current buffer */
1147
YY_BUFFER_STATE b = yy_current_buffer;
1149
int yy_c_buf_p_offset =
1150
(int) (yy_c_buf_p - b->yy_ch_buf);
1152
if ( b->yy_is_our_buffer )
1154
int new_size = b->yy_buf_size * 2;
1156
if ( new_size <= 0 )
1157
b->yy_buf_size += b->yy_buf_size / 8;
1159
b->yy_buf_size *= 2;
1161
b->yy_ch_buf = (char *)
1162
/* Include room in for 2 EOB chars. */
1163
yy_flex_realloc( (void *) b->yy_ch_buf,
1164
b->yy_buf_size + 2 );
1167
/* Can't grow it, we don't own it. */
1170
if ( ! b->yy_ch_buf )
1172
"fatal error - scanner input buffer overflow" );
1174
yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1176
num_to_read = yy_current_buffer->yy_buf_size -
1181
if ( num_to_read > YY_READ_BUF_SIZE )
1182
num_to_read = YY_READ_BUF_SIZE;
1184
/* Read in more data. */
1185
YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1186
yy_n_chars, num_to_read );
1188
yy_current_buffer->yy_n_chars = yy_n_chars;
1191
if ( yy_n_chars == 0 )
1193
if ( number_to_move == YY_MORE_ADJ )
1195
ret_val = EOB_ACT_END_OF_FILE;
1201
ret_val = EOB_ACT_LAST_MATCH;
1202
yy_current_buffer->yy_buffer_status =
1203
YY_BUFFER_EOF_PENDING;
1208
ret_val = EOB_ACT_CONTINUE_SCAN;
1210
yy_n_chars += number_to_move;
1211
yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1212
yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1214
yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1220
/* yy_get_previous_state - get the state just before the EOB char was reached */
1222
static yy_state_type yy_get_previous_state()
1224
register yy_state_type yy_current_state;
1225
register char *yy_cp;
1227
yy_current_state = yy_start;
1229
for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1231
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1232
if ( yy_accept[yy_current_state] )
1234
yy_last_accepting_state = yy_current_state;
1235
yy_last_accepting_cpos = yy_cp;
1237
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1239
yy_current_state = (int) yy_def[yy_current_state];
1240
if ( yy_current_state >= 154 )
1241
yy_c = yy_meta[(unsigned int) yy_c];
1243
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1246
return yy_current_state;
1250
/* yy_try_NUL_trans - try to make a transition on the NUL character
1253
* next_state = yy_try_NUL_trans( current_state );
1256
#ifdef YY_USE_PROTOS
1257
static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1259
static yy_state_type yy_try_NUL_trans( yy_current_state )
1260
yy_state_type yy_current_state;
1263
register int yy_is_jam;
1264
register char *yy_cp = yy_c_buf_p;
1266
register YY_CHAR yy_c = 1;
1267
if ( yy_accept[yy_current_state] )
1269
yy_last_accepting_state = yy_current_state;
1270
yy_last_accepting_cpos = yy_cp;
1272
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1274
yy_current_state = (int) yy_def[yy_current_state];
1275
if ( yy_current_state >= 154 )
1276
yy_c = yy_meta[(unsigned int) yy_c];
1278
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1279
yy_is_jam = (yy_current_state == 153);
1281
return yy_is_jam ? 0 : yy_current_state;
1286
#ifdef YY_USE_PROTOS
1287
static void yyunput( int c, register char *yy_bp )
1289
static void yyunput( c, yy_bp )
1291
register char *yy_bp;
1294
register char *yy_cp = yy_c_buf_p;
1296
/* undo effects of setting up yytext */
1297
*yy_cp = yy_hold_char;
1299
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1300
{ /* need to shift things up to make room */
1301
/* +2 for EOB chars. */
1302
register int number_to_move = yy_n_chars + 2;
1303
register char *dest = &yy_current_buffer->yy_ch_buf[
1304
yy_current_buffer->yy_buf_size + 2];
1305
register char *source =
1306
&yy_current_buffer->yy_ch_buf[number_to_move];
1308
while ( source > yy_current_buffer->yy_ch_buf )
1309
*--dest = *--source;
1311
yy_cp += (int) (dest - source);
1312
yy_bp += (int) (dest - source);
1313
yy_current_buffer->yy_n_chars =
1314
yy_n_chars = yy_current_buffer->yy_buf_size;
1316
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1317
YY_FATAL_ERROR( "flex scanner push-back overflow" );
1320
*--yy_cp = (char) c;
1324
yy_hold_char = *yy_cp;
1327
#endif /* ifndef YY_NO_UNPUT */
1331
static int yyinput()
1338
*yy_c_buf_p = yy_hold_char;
1340
if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1342
/* yy_c_buf_p now points to the character we want to return.
1343
* If this occurs *before* the EOB characters, then it's a
1344
* valid NUL; if not, then we've hit the end of the buffer.
1346
if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1347
/* This was really a NUL. */
1351
{ /* need more input */
1352
int offset = yy_c_buf_p - yytext_ptr;
1355
switch ( yy_get_next_buffer() )
1357
case EOB_ACT_LAST_MATCH:
1358
/* This happens because yy_g_n_b()
1359
* sees that we've accumulated a
1360
* token and flags that we need to
1361
* try matching the token before
1362
* proceeding. But for input(),
1363
* there's no matching to consider.
1364
* So convert the EOB_ACT_LAST_MATCH
1365
* to EOB_ACT_END_OF_FILE.
1368
/* Reset buffer status. */
1373
case EOB_ACT_END_OF_FILE:
1378
if ( ! yy_did_buffer_switch_on_eof )
1387
case EOB_ACT_CONTINUE_SCAN:
1388
yy_c_buf_p = yytext_ptr + offset;
1394
c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1395
*yy_c_buf_p = '\0'; /* preserve yytext */
1396
yy_hold_char = *++yy_c_buf_p;
1403
#ifdef YY_USE_PROTOS
1404
void yyrestart( FILE *input_file )
1406
void yyrestart( input_file )
1410
if ( ! yy_current_buffer )
1411
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1413
yy_init_buffer( yy_current_buffer, input_file );
1414
yy_load_buffer_state();
1418
#ifdef YY_USE_PROTOS
1419
void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1421
void yy_switch_to_buffer( new_buffer )
1422
YY_BUFFER_STATE new_buffer;
1425
if ( yy_current_buffer == new_buffer )
1428
if ( yy_current_buffer )
1430
/* Flush out information for old buffer. */
1431
*yy_c_buf_p = yy_hold_char;
1432
yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1433
yy_current_buffer->yy_n_chars = yy_n_chars;
1436
yy_current_buffer = new_buffer;
1437
yy_load_buffer_state();
1439
/* We don't actually know whether we did this switch during
1440
* EOF (yywrap()) processing, but the only time this flag
1441
* is looked at is after yywrap() is called, so it's safe
1442
* to go ahead and always set it.
1444
yy_did_buffer_switch_on_eof = 1;
1448
#ifdef YY_USE_PROTOS
1449
void yy_load_buffer_state( void )
1451
void yy_load_buffer_state()
1454
yy_n_chars = yy_current_buffer->yy_n_chars;
1455
yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1456
yyin = yy_current_buffer->yy_input_file;
1457
yy_hold_char = *yy_c_buf_p;
1461
#ifdef YY_USE_PROTOS
1462
YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1464
YY_BUFFER_STATE yy_create_buffer( file, size )
1471
b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1473
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1475
b->yy_buf_size = size;
1477
/* yy_ch_buf has to be 2 characters longer than the size given because
1478
* we need to put in 2 end-of-buffer characters.
1480
b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1481
if ( ! b->yy_ch_buf )
1482
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1484
b->yy_is_our_buffer = 1;
1486
yy_init_buffer( b, file );
1492
#ifdef YY_USE_PROTOS
1493
void yy_delete_buffer( YY_BUFFER_STATE b )
1495
void yy_delete_buffer( b )
1502
if ( b == yy_current_buffer )
1503
yy_current_buffer = (YY_BUFFER_STATE) 0;
1505
if ( b->yy_is_our_buffer )
1506
yy_flex_free( (void *) b->yy_ch_buf );
1508
yy_flex_free( (void *) b );
1513
#ifdef YY_USE_PROTOS
1514
void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1516
void yy_init_buffer( b, file )
1523
yy_flush_buffer( b );
1525
b->yy_input_file = file;
1526
b->yy_fill_buffer = 1;
1528
#if YY_ALWAYS_INTERACTIVE
1529
b->yy_is_interactive = 1;
1531
#if YY_NEVER_INTERACTIVE
1532
b->yy_is_interactive = 0;
1534
b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1540
#ifdef YY_USE_PROTOS
1541
void yy_flush_buffer( YY_BUFFER_STATE b )
1543
void yy_flush_buffer( b )
1553
/* We always need two end-of-buffer characters. The first causes
1554
* a transition to the end-of-buffer state. The second causes
1555
* a jam in that state.
1557
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1558
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1560
b->yy_buf_pos = &b->yy_ch_buf[0];
1563
b->yy_buffer_status = YY_BUFFER_NEW;
1565
if ( b == yy_current_buffer )
1566
yy_load_buffer_state();
1570
#ifndef YY_NO_SCAN_BUFFER
1571
#ifdef YY_USE_PROTOS
1572
YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1574
YY_BUFFER_STATE yy_scan_buffer( base, size )
1582
base[size-2] != YY_END_OF_BUFFER_CHAR ||
1583
base[size-1] != YY_END_OF_BUFFER_CHAR )
1584
/* They forgot to leave room for the EOB's. */
1587
b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1589
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1591
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1592
b->yy_buf_pos = b->yy_ch_buf = base;
1593
b->yy_is_our_buffer = 0;
1594
b->yy_input_file = 0;
1595
b->yy_n_chars = b->yy_buf_size;
1596
b->yy_is_interactive = 0;
1598
b->yy_fill_buffer = 0;
1599
b->yy_buffer_status = YY_BUFFER_NEW;
1601
yy_switch_to_buffer( b );
1608
#ifndef YY_NO_SCAN_STRING
1609
#ifdef YY_USE_PROTOS
1610
YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1612
YY_BUFFER_STATE yy_scan_string( yy_str )
1613
yyconst char *yy_str;
1617
for ( len = 0; yy_str[len]; ++len )
1620
return yy_scan_bytes( yy_str, len );
1625
#ifndef YY_NO_SCAN_BYTES
1626
#ifdef YY_USE_PROTOS
1627
YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1629
YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1630
yyconst char *bytes;
1639
/* Get memory for full buffer, including space for trailing EOB's. */
1641
buf = (char *) yy_flex_alloc( n );
1643
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1645
for ( i = 0; i < len; ++i )
1648
buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1650
b = yy_scan_buffer( buf, n );
1652
YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1654
/* It's okay to grow etc. this buffer, and we should throw it
1655
* away when we're done.
1657
b->yy_is_our_buffer = 1;
1664
#ifndef YY_NO_PUSH_STATE
1665
#ifdef YY_USE_PROTOS
1666
static void yy_push_state( int new_state )
1668
static void yy_push_state( new_state )
1672
if ( yy_start_stack_ptr >= yy_start_stack_depth )
1676
yy_start_stack_depth += YY_START_STACK_INCR;
1677
new_size = yy_start_stack_depth * sizeof( int );
1679
if ( ! yy_start_stack )
1680
yy_start_stack = (int *) yy_flex_alloc( new_size );
1683
yy_start_stack = (int *) yy_flex_realloc(
1684
(void *) yy_start_stack, new_size );
1686
if ( ! yy_start_stack )
1688
"out of memory expanding start-condition stack" );
1691
yy_start_stack[yy_start_stack_ptr++] = YY_START;
1698
#ifndef YY_NO_POP_STATE
1699
static void yy_pop_state()
1701
if ( --yy_start_stack_ptr < 0 )
1702
YY_FATAL_ERROR( "start-condition stack underflow" );
1704
BEGIN(yy_start_stack[yy_start_stack_ptr]);
1709
#ifndef YY_NO_TOP_STATE
1710
static int yy_top_state()
1712
return yy_start_stack[yy_start_stack_ptr - 1];
1716
#ifndef YY_EXIT_FAILURE
1717
#define YY_EXIT_FAILURE 2
1720
#ifdef YY_USE_PROTOS
1721
static void yy_fatal_error( yyconst char msg[] )
1723
static void yy_fatal_error( msg )
1727
(void) fprintf( stderr, "%s\n", msg );
1728
exit( YY_EXIT_FAILURE );
1733
/* Redefine yyless() so it works in section 3 code. */
1739
/* Undo effects of setting up yytext. */ \
1740
yytext[yyleng] = yy_hold_char; \
1741
yy_c_buf_p = yytext + n; \
1742
yy_hold_char = *yy_c_buf_p; \
1743
*yy_c_buf_p = '\0'; \
1749
/* Internal utility routines. */
1752
#ifdef YY_USE_PROTOS
1753
static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1755
static void yy_flex_strncpy( s1, s2, n )
1762
for ( i = 0; i < n; ++i )
1767
#ifdef YY_NEED_STRLEN
1768
#ifdef YY_USE_PROTOS
1769
static int yy_flex_strlen( yyconst char *s )
1771
static int yy_flex_strlen( s )
1776
for ( n = 0; s[n]; ++n )
1784
#ifdef YY_USE_PROTOS
1785
static void *yy_flex_alloc( yy_size_t size )
1787
static void *yy_flex_alloc( size )
1791
return (void *) malloc( size );
1794
#ifdef YY_USE_PROTOS
1795
static void *yy_flex_realloc( void *ptr, yy_size_t size )
1797
static void *yy_flex_realloc( ptr, size )
1802
/* The cast to (char *) in the following accommodates both
1803
* implementations that use char* generic pointers, and those
1804
* that use void* generic pointers. It works with the latter
1805
* because both ANSI C and C++ allow castless assignment from
1806
* any pointer type to void*, and deal with argument conversions
1807
* as though doing an assignment.
1809
return (void *) realloc( (char *) ptr, size );
1812
#ifdef YY_USE_PROTOS
1813
static void yy_flex_free( void *ptr )
1815
static void yy_flex_free( ptr )
1829
#line 133 "imap_csim.l"
added
removed
plug-ins/imagemap/imap_csim_lex.c
