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