summaryrefslogtreecommitdiffabout
path: root/libical/src/libicalss/icalsslexer.c
Unidiff
Diffstat (limited to 'libical/src/libicalss/icalsslexer.c') (more/less context) (show whitespace changes)
-rw-r--r--libical/src/libicalss/icalsslexer.c1624
1 files changed, 1198 insertions, 426 deletions
diff --git a/libical/src/libicalss/icalsslexer.c b/libical/src/libicalss/icalsslexer.c
index e10bcd3..28d1b66 100644
--- a/libical/src/libicalss/icalsslexer.c
+++ b/libical/src/libicalss/icalsslexer.c
@@ -1,56 +1,69 @@
1#define YY_REENTRANT 1
2#define YY_TEXT_IS_ARRAY
3#define YY_REENTRANT_BISON_PURE 1
4#ifndef YY_REENTRANT
5#define yytext sstext
6#define yyleng ssleng
7#define yyin ssin
8#define yyout ssout
9#endif
1#define yy_create_buffer ss_create_buffer 10#define yy_create_buffer ss_create_buffer
2#define yy_delete_buffer ss_delete_buffer 11#define yy_delete_buffer ss_delete_buffer
3#define yy_scan_buffer ss_scan_buffer 12#define yy_scan_buffer ss_scan_buffer
4#define yy_scan_string ss_scan_string 13#define yy_scan_string ss_scan_string
5#define yy_scan_bytes ss_scan_bytes 14#define yy_scan_bytes ss_scan_bytes
6#define yy_flex_debug ss_flex_debug 15#define yy_flex_debug ss_flex_debug
7#define yy_init_buffer ss_init_buffer 16#define yy_init_buffer ss_init_buffer
8#define yy_flush_buffer ss_flush_buffer 17#define yy_flush_buffer ss_flush_buffer
9#define yy_load_buffer_state ss_load_buffer_state 18#define yy_load_buffer_state ss_load_buffer_state
10#define yy_switch_to_buffer ss_switch_to_buffer 19#define yy_switch_to_buffer ss_switch_to_buffer
11#define yyin ssin
12#define yyleng ssleng
13#define yylex sslex 20#define yylex sslex
14#define yyout ssout
15#define yyrestart ssrestart 21#define yyrestart ssrestart
16#define yytext sstext 22#define yylex_init sslex_init
23#define yylex_destroy sslex_destroy
24#define yyget_extra ssget_extra
25#define yyset_extra ssset_extra
26#define yyget_in ssget_in
27#define yyset_in ssset_in
28#define yyget_out ssget_out
29#define yyset_out ssset_out
30#define yyget_leng ssget_leng
31#define yyget_text ssget_text
32#define yyget_lineno ssget_lineno
33#define yyset_lineno ssset_lineno
34#ifdef YY_REENTRANT_BISON_PURE
35#define yyget_lval ssget_lval
36#define yyset_lval ssset_lval
37#ifdef YYLTYPE
38#define yyget_lloc ssget_lloc
39#define yyset_lloc ssset_lloc
40#endif
41#endif
17#define yywrap sswrap 42#define yywrap sswrap
18 43
44/* -*-C-*- */
19/* A lexical scanner generated by flex */ 45/* A lexical scanner generated by flex */
20 46
21/* Scanner skeleton version:
22 * $Header$
23 */
24
25#define FLEX_SCANNER 47#define FLEX_SCANNER
26#define YY_FLEX_MAJOR_VERSION 2 48#define YY_FLEX_MAJOR_VERSION 2
27#define YY_FLEX_MINOR_VERSION 5 49#define YY_FLEX_MINOR_VERSION 5
28 50
51/* %- */
52/* begin standard C headers. */
29#include <stdio.h> 53#include <stdio.h>
30// Eugen C. <eug@thekompany.com> 54#include <errno.h>
31#include <defines.h> 55#include <stdlib.h>
32#ifndef _QTWIN_ 56/* end standard C headers. */
33#include <unistd.h> 57/* %+ */
34#else 58/* %* */
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 59
48#ifdef __cplusplus 60#ifdef __cplusplus
49 61
50#include <stdlib.h> 62/* %+ */
63/* %* */
51 64
52/* Use prototypes in function declarations. */ 65/* Use prototypes in function declarations. */
53#define YY_USE_PROTOS 66#define YY_USE_PROTOS
54 67
55/* The "const" storage-class-modifier is valid. */ 68/* The "const" storage-class-modifier is valid. */
56#define YY_USE_CONST 69#define YY_USE_CONST
@@ -62,21 +75,12 @@
62#define YY_USE_PROTOS 75#define YY_USE_PROTOS
63#define YY_USE_CONST 76#define YY_USE_CONST
64 77
65 #endif/* __STDC__ */ 78 #endif/* __STDC__ */
66 #endif/* ! __cplusplus */ 79 #endif/* ! __cplusplus */
67 80
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 81#ifdef YY_USE_CONST
78#define yyconst const 82#define yyconst const
79#else 83#else
80#define yyconst 84#define yyconst
81#endif 85#endif
82 86
@@ -94,40 +98,100 @@
94 * integer for use as an array index. If the signed char is negative, 98 * 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 99 * we want to instead treat it as an 8-bit unsigned char, hence the
96 * double cast. 100 * double cast.
97 */ 101 */
98#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 102#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
99 103
104
105#ifdef YY_REENTRANT
106
107/* An opaque pointer. */
108#ifndef YY_TYPEDEF_YY_SCANNER_T
109#define YY_TYPEDEF_YY_SCANNER_T
110typedef void* yyscan_t;
111#endif
112
113/* For use wherever a Global is accessed or assigned. */
114#define YY_G(var) (((struct yy_globals_t*)yy_globals)->var)
115
116/* For use in function prototypes to append the additional argument. */
117#ifdef YY_USE_PROTOS
118#define YY_LAST_ARG , yyscan_t yy_globals
119#define YY_ONLY_ARG yyscan_t yy_globals
120#else
121#define YY_LAST_ARG , yy_globals
122#define YY_ONLY_ARG yy_globals
123#define YY_DECL_LAST_ARG yyscan_t yy_globals;
124#endif
125
126/* For use in function calls to pass the additional argument. */
127#define YY_CALL_LAST_ARG , yy_globals
128#define YY_CALL_ONLY_ARG yy_globals
129
130/* For convenience, these vars (plus the bison vars far below)
131 are macros in the reentrant scanner. */
132#define yyin YY_G(yyin_r)
133#define yyout YY_G(yyout_r)
134#define yyextra YY_G(yyextra_r)
135#define yyleng YY_G(yyleng_r)
136#define yytext YY_G(yytext_r)
137#define yylineno YY_G(yylineno_r)
138
139int yylex_init YY_PROTO((yyscan_t* scanner));
140int yylex_destroy YY_PROTO((yyscan_t scanner));
141
142#else /* not YY_REENTRANT */
143
144 /* Define these macros to be no-ops. */
145#define YY_G(var) (var)
146#define YY_LAST_ARG
147#define YY_ONLY_ARG void
148#define YY_CALL_LAST_ARG
149#define YY_CALL_ONLY_ARG
150#define YY_DECL_LAST_ARG
151#endif
152
100/* Enter a start condition. This macro really ought to take a parameter, 153/* 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 154 * but we do it the disgusting crufty way forced on us by the ()-less
102 * definition of BEGIN. 155 * definition of BEGIN.
103 */ 156 */
104#define BEGIN yy_start = 1 + 2 * 157#define BEGIN YY_G(yy_start) = 1 + 2 *
105 158
106/* Translate the current start state into a value that can be later handed 159/* 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 160 * to BEGIN to return to the state. The YYSTATE alias is for lex
108 * compatibility. 161 * compatibility.
109 */ 162 */
110#define YY_START ((yy_start - 1) / 2) 163#define YY_START ((YY_G(yy_start) - 1) / 2)
111#define YYSTATE YY_START 164#define YYSTATE YY_START
112 165
113/* Action number for EOF rule of a given start state. */ 166/* Action number for EOF rule of a given start state. */
114#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 167#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
115 168
116/* Special action meaning "start processing a new file". */ 169/* Special action meaning "start processing a new file". */
117#define YY_NEW_FILE yyrestart( yyin ) 170#define YY_NEW_FILE yyrestart( yyin YY_CALL_LAST_ARG )
118 171
119#define YY_END_OF_BUFFER_CHAR 0 172#define YY_END_OF_BUFFER_CHAR 0
120 173
121/* Size of default input buffer. */ 174/* Size of default input buffer. */
122#define YY_BUF_SIZE 16384 175#define YY_BUF_SIZE 16384
123 176
177
178#ifndef YY_TYPEDEF_YY_BUFFER_STATE
179#define YY_TYPEDEF_YY_BUFFER_STATE
124typedef struct yy_buffer_state *YY_BUFFER_STATE; 180typedef struct yy_buffer_state *YY_BUFFER_STATE;
181#endif
125 182
126extern int yyleng; 183#ifndef YY_REENTRANT
184extern size_t yyleng;
185#endif
186
187/* %- */
188#ifndef YY_REENTRANT
127extern FILE *yyin, *yyout; 189extern FILE *yyin, *yyout;
190#endif
191/* %* */
128 192
129#define EOB_ACT_CONTINUE_SCAN 0 193#define EOB_ACT_CONTINUE_SCAN 0
130#define EOB_ACT_END_OF_FILE 1 194#define EOB_ACT_END_OF_FILE 1
131#define EOB_ACT_LAST_MATCH 2 195#define EOB_ACT_LAST_MATCH 2
132 196
133/* The funky do-while in the following #define is used to turn the definition 197/* The funky do-while in the following #define is used to turn the definition
@@ -147,31 +211,39 @@ extern FILE *yyin, *yyout;
147/* Return all but the first 'n' matched characters back to the input stream. */ 211/* Return all but the first 'n' matched characters back to the input stream. */
148 212
149#define yyless(n) \ 213#define yyless(n) \
150 do \ 214 do \
151 { \ 215 { \
152 /* Undo effects of setting up yytext. */ \ 216 /* Undo effects of setting up yytext. */ \
153 *yy_cp = yy_hold_char; \ 217 *yy_cp = YY_G(yy_hold_char); \
154 YY_RESTORE_YY_MORE_OFFSET \ 218 YY_RESTORE_YY_MORE_OFFSET \
155 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 219 YY_G(yy_c_buf_p) = yy_cp = yy_bp + n - YY_MORE_ADJ; \
156 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 220 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
157 } \ 221 } \
158 while ( 0 ) 222 while ( 0 )
159 223
160#define unput(c) yyunput( c, yytext_ptr ) 224#define unput(c) yyunput( c, YY_G(yytext_ptr) YY_CALL_LAST_ARG )
161 225
162/* The following is because we cannot portably get our hands on size_t 226/* 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 227 * (without autoconf's help, which isn't available because we want
164 * flex-generated scanners to compile on their own). 228 * flex-generated scanners to compile on their own).
165 */ 229 */
166typedef unsigned int yy_size_t;
167 230
231#ifndef YY_TYPEDEF_YY_SIZE_T
232#define YY_TYPEDEF_YY_SIZE_T
233typedef unsigned int yy_size_t;
234#endif
168 235
236#ifndef YY_STRUCT_YY_BUFFER_STATE
237#define YY_STRUCT_YY_BUFFER_STATE
169struct yy_buffer_state 238struct yy_buffer_state
170 { 239 {
240/* %- */
171 FILE *yy_input_file; 241 FILE *yy_input_file;
242/* %+ */
243/* %* */
172 244
173 char *yy_ch_buf; /* input buffer */ 245 char *yy_ch_buf; /* input buffer */
174 char *yy_buf_pos; /* current position in input buffer */ 246 char *yy_buf_pos; /* current position in input buffer */
175 247
176 /* Size of input buffer in bytes, not including room for EOB 248 /* Size of input buffer in bytes, not including room for EOB
177 * characters. 249 * characters.
@@ -219,127 +291,176 @@ struct yy_buffer_state
219 * When we actually see the EOF, we change the status to "new" 291 * When we actually see the EOF, we change the status to "new"
220 * (via yyrestart()), so that the user can continue scanning by 292 * (via yyrestart()), so that the user can continue scanning by
221 * just pointing yyin at a new input file. 293 * just pointing yyin at a new input file.
222 */ 294 */
223#define YY_BUFFER_EOF_PENDING 2 295#define YY_BUFFER_EOF_PENDING 2
224 }; 296 };
297#endif /* !YY_STRUCT_YY_BUFFER_STATE */
225 298
299/* %- Standard (non-C++) definition */
300/* %c */
301#ifndef ssIN_HEADER
302#ifndef YY_REENTRANT
226static YY_BUFFER_STATE yy_current_buffer = 0; 303static YY_BUFFER_STATE yy_current_buffer = 0;
304#endif
305/* %e */
306#endif /* !ssIN_HEADER */
307/* %* */
227 308
228/* We provide macros for accessing buffer states in case in the 309/* We provide macros for accessing buffer states in case in the
229 * future we want to put the buffer states in a more general 310 * future we want to put the buffer states in a more general
230 * "scanner state". 311 * "scanner state".
231 */ 312 */
232#define YY_CURRENT_BUFFER yy_current_buffer 313#define YY_CURRENT_BUFFER yy_current_buffer
233 314
234 315
316/* %- Standard (non-C++) definition */
317
318#ifndef YY_REENTRANT
319/* %c */
320#ifndef ssIN_HEADER
235/* yy_hold_char holds the character lost when yytext is formed. */ 321/* yy_hold_char holds the character lost when yytext is formed. */
236static char yy_hold_char; 322static char yy_hold_char;
237 323
238 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 324 static int yy_n_chars; /* number of characters read into yy_ch_buf */
239 325
240 326
241int yyleng; 327size_t yyleng;
242 328
243/* Points to current character in buffer. */ 329/* Points to current character in buffer. */
244static char *yy_c_buf_p = (char *) 0; 330static char *yy_c_buf_p = (char *) 0;
245 static int yy_init = 1; /* whether we need to initialize */ 331 static int yy_init = 1; /* whether we need to initialize */
246 static int yy_start = 0;/* start state number */ 332 static int yy_start = 0;/* start state number */
247 333
248/* Flag which is used to allow yywrap()'s to do buffer switches 334/* 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 ... 335 * instead of setting up a fresh yyin. A bit of a hack ...
250 */ 336 */
251static int yy_did_buffer_switch_on_eof; 337static int yy_did_buffer_switch_on_eof;
338/* %e */
339#endif /* !ssIN_HEADER */
340#endif /* end !YY_REENTRANT */
341
342void yyrestart YY_PROTO(( FILE *input_file YY_LAST_ARG ));
252 343
253void yyrestart YY_PROTO(( FILE *input_file ));
254 344
255void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 345void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer YY_LAST_ARG ));
256void yy_load_buffer_state YY_PROTO(( void )); 346void yy_load_buffer_state YY_PROTO(( YY_ONLY_ARG ));
257YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 347YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size YY_LAST_ARG ));
258void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 348void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b YY_LAST_ARG ));
259void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 349void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file YY_LAST_ARG ));
260void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 350void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b YY_LAST_ARG ));
261#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
262 351
263YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 352#define YY_FLUSH_BUFFER yy_flush_buffer( YY_G(yy_current_buffer) YY_CALL_LAST_ARG)
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 353
267static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 354YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size YY_LAST_ARG ));
268static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 355YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str YY_LAST_ARG ));
269static void yy_flex_free YY_PROTO(( void * )); 356YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len YY_LAST_ARG ));
357
358/* %* */
359
360/* %c */
361#ifndef ssIN_HEADER
362static void *yy_flex_alloc YY_PROTO(( yy_size_t YY_LAST_ARG ));
363static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t YY_LAST_ARG ));
364static void yy_flex_free YY_PROTO(( void * YY_LAST_ARG ));
365/* %e */
366#endif /* !ssIN_HEADER */
270 367
271#define yy_new_buffer yy_create_buffer 368#define yy_new_buffer yy_create_buffer
272 369
273#define yy_set_interactive(is_interactive) \ 370#define yy_set_interactive(is_interactive) \
274 { \ 371 { \
275 if ( ! yy_current_buffer ) \ 372 if ( ! YY_G(yy_current_buffer) ) \
276 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 373 YY_G(yy_current_buffer) = \
277 yy_current_buffer->yy_is_interactive = is_interactive; \ 374 yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
375 YY_G(yy_current_buffer)->yy_is_interactive = is_interactive; \
278 } 376 }
279 377
280#define yy_set_bol(at_bol) \ 378#define yy_set_bol(at_bol) \
281 { \ 379 { \
282 if ( ! yy_current_buffer ) \ 380 if ( ! YY_G(yy_current_buffer) ) \
283 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 381 YY_G(yy_current_buffer) = \
284 yy_current_buffer->yy_at_bol = at_bol; \ 382 yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
383 YY_G(yy_current_buffer)->yy_at_bol = at_bol; \
285 } 384 }
286 385
287#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 386#define YY_AT_BOL() (YY_G(yy_current_buffer)->yy_at_bol)
288 387
388/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */
389/* Begin user sect3 */
390#ifndef ssIN_HEADER
289typedef unsigned char YY_CHAR; 391typedef unsigned char YY_CHAR;
392#endif /* !ssIN_HEADER */
393#ifndef ssIN_HEADER
394#ifndef YY_REENTRANT
290FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 395FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
396#endif
397#endif /* !ssIN_HEADER */
398#ifndef ssIN_HEADER
291typedef int yy_state_type; 399typedef int yy_state_type;
292extern char yytext[]; 400#endif /* !ssIN_HEADER */
293 401
294 402/* %- Standard (non-C++) definition */
295static yy_state_type yy_get_previous_state YY_PROTO(( void )); 403/* %c */
296static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 404#ifndef ssIN_HEADER
297static int yy_get_next_buffer YY_PROTO(( void )); 405static yy_state_type yy_get_previous_state YY_PROTO(( YY_ONLY_ARG ));
406static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state YY_LAST_ARG));
407static int yy_get_next_buffer YY_PROTO(( YY_ONLY_ARG ));
298static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 408static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
409/* %e */
410#endif /* !ssIN_HEADER */
411/* %* */
299 412
300/* Done after the current pattern has been matched and before the 413/* Done after the current pattern has been matched and before the
301 * corresponding action - sets up yytext. 414 * corresponding action - sets up yytext.
302 */ 415 */
303#define YY_DO_BEFORE_ACTION \ 416#define YY_DO_BEFORE_ACTION \
304 yytext_ptr = yy_bp; \ 417 YY_G(yytext_ptr) = yy_bp; \
305 yyleng = (int) (yy_cp - yy_bp); \ 418/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
306 yy_hold_char = *yy_cp; \ 419 yyleng = (size_t) (yy_cp - yy_bp); \
420 YY_G(yy_hold_char) = *yy_cp; \
307 *yy_cp = '\0'; \ 421 *yy_cp = '\0'; \
422/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
308 if ( yyleng >= YYLMAX ) \ 423 if ( yyleng >= YYLMAX ) \
309 YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \ 424 YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
310 yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \ 425 yy_flex_strncpy( yytext, YY_G(yytext_ptr), yyleng + 1 YY_CALL_LAST_ARG); \
311 yy_c_buf_p = yy_cp; 426 YY_G(yy_c_buf_p) = yy_cp;
427
428/* %* */
312 429
313#define YY_NUM_RULES 19 430/* %c */
314#define YY_END_OF_BUFFER 20 431#ifndef ssIN_HEADER
315static yyconst short int yy_accept[47] = 432/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
433#define YY_NUM_RULES 23
434#define YY_END_OF_BUFFER 24
435static yyconst short int yy_accept[56] =
316 { 0, 436 { 0,
317 0, 0, 0, 0, 0, 0, 20, 18, 14, 14, 437 0, 0, 0, 0, 0, 0, 24, 22, 18, 18,
318 18, 13, 17, 4, 15, 7, 5, 8, 17, 17, 438 22, 17, 21, 4, 19, 8, 5, 9, 21, 21,
319 17, 17, 17, 14, 6, 0, 17, 9, 10, 17, 439 21, 21, 21, 21, 21, 18, 7, 0, 21, 10,
320 17, 12, 17, 17, 16, 11, 17, 17, 17, 2, 440 6, 11, 21, 21, 14, 21, 21, 13, 21, 21,
321 17, 17, 17, 3, 1, 0 441 20, 12, 21, 15, 21, 21, 21, 2, 16, 21,
442 21, 21, 3, 1, 0
322 } ; 443 } ;
323 444
324static yyconst int yy_ec[256] = 445static yyconst int yy_ec[256] =
325 { 0, 446 { 0,
326 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 447 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
327 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 448 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
328 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 449 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
329 1, 2, 4, 1, 1, 1, 1, 1, 5, 1, 450 1, 4, 5, 1, 1, 1, 1, 1, 6, 1,
330 1, 6, 1, 7, 6, 6, 1, 6, 6, 6, 451 1, 7, 1, 8, 7, 7, 1, 7, 7, 7,
331 6, 6, 6, 6, 6, 6, 6, 1, 8, 9, 452 7, 7, 7, 7, 7, 7, 7, 9, 10, 11,
332 10, 11, 1, 1, 12, 6, 13, 14, 15, 16, 453 12, 13, 1, 7, 14, 7, 15, 16, 17, 18,
333 6, 17, 6, 6, 6, 18, 19, 20, 21, 6, 454 7, 19, 20, 7, 7, 21, 22, 23, 24, 7,
334 6, 22, 23, 24, 6, 6, 25, 6, 6, 6, 455 7, 25, 26, 27, 28, 7, 29, 7, 7, 7,
335 1, 1, 1, 1, 1, 1, 12, 6, 13, 14, 456 1, 1, 1, 1, 1, 1, 14, 7, 15, 16,
336 457
337 15, 16, 6, 17, 6, 6, 6, 18, 19, 20, 458 17, 18, 7, 19, 20, 7, 7, 21, 22, 23,
338 21, 6, 6, 22, 23, 24, 6, 6, 25, 6, 459 24, 7, 7, 25, 26, 27, 28, 7, 29, 7,
339 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 460 7, 7, 1, 1, 1, 1, 1, 1, 1, 1,
340 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 461 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
341 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 462 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
342 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 463 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
343 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 464 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
344 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 465 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
345 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 466 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -350,77 +471,84 @@ static yyconst int yy_ec[256] =
350 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 471 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
351 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 472 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
352 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 473 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
353 1, 1, 1, 1, 1 474 1, 1, 1, 1, 1
354 } ; 475 } ;
355 476
356static yyconst int yy_meta[26] = 477static yyconst int yy_meta[30] =
357 { 0, 478 { 0,
358 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 479 1, 1, 1, 2, 1, 1, 3, 1, 2, 1,
359 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 480 1, 1, 1, 3, 3, 3, 3, 3, 3, 3,
360 2, 2, 2, 2, 2 481 3, 3, 3, 3, 3, 3, 3, 3, 3
361 } ; 482 } ;
362 483
363static yyconst short int yy_base[49] = 484static yyconst short int yy_base[58] =
364 { 0, 485 { 0,
365 0, 0, 0, 0, 0, 0, 53, 54, 24, 26, 486 0, 0, 0, 0, 0, 0, 68, 69, 28, 31,
366 42, 0, 0, 54, 54, 41, 54, 40, 29, 26, 487 55, 0, 0, 69, 69, 54, 53, 52, 40, 37,
367 25, 31, 28, 28, 54, 39, 0, 54, 54, 29, 488 35, 12, 35, 42, 39, 35, 69, 51, 0, 69,
368 21, 0, 23, 25, 54, 0, 20, 23, 15, 0, 489 69, 69, 40, 31, 0, 27, 32, 0, 31, 34,
369 23, 20, 10, 0, 0, 54, 31, 30 490 69, 0, 28, 0, 28, 31, 22, 0, 0, 31,
491 28, 17, 0, 0, 69, 39, 40
370 } ; 492 } ;
371 493
372static yyconst short int yy_def[49] = 494static yyconst short int yy_def[58] =
373 { 0, 495 { 0,
374 46, 1, 1, 1, 1, 1, 46, 46, 46, 46, 496 55, 1, 1, 1, 1, 1, 55, 55, 55, 55,
375 46, 47, 48, 46, 46, 46, 46, 46, 48, 48, 497 55, 56, 57, 55, 55, 55, 55, 55, 57, 57,
376 48, 48, 48, 46, 46, 47, 48, 46, 46, 48, 498 57, 57, 57, 57, 57, 55, 55, 56, 57, 55,
377 48, 48, 48, 48, 46, 48, 48, 48, 48, 48, 499 55, 55, 57, 57, 57, 57, 57, 57, 57, 57,
378 48, 48, 48, 48, 48, 0, 46, 46 500 55, 57, 57, 57, 57, 57, 57, 57, 57, 57,
501 57, 57, 57, 57, 0, 55, 55
379 } ; 502 } ;
380 503
381static yyconst short int yy_nxt[80] = 504static yyconst short int yy_nxt[99] =
382 { 0, 505 { 0,
383 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 506 8, 9, 10, 9, 11, 12, 13, 14, 8, 15,
384 18, 19, 13, 13, 13, 20, 13, 13, 13, 13, 507 16, 17, 18, 19, 13, 13, 13, 20, 13, 21,
385 21, 13, 22, 13, 23, 24, 24, 24, 24, 24, 508 13, 13, 22, 23, 13, 24, 13, 13, 25, 26,
386 24, 27, 26, 45, 44, 43, 42, 41, 40, 39, 509 26, 26, 26, 26, 26, 36, 26, 26, 26, 37,
387 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 510 28, 28, 29, 54, 53, 52, 51, 50, 49, 48,
388 28, 25, 46, 7, 46, 46, 46, 46, 46, 46, 511 47, 46, 45, 44, 43, 42, 41, 40, 39, 38,
389 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 512 35, 34, 33, 32, 31, 30, 27, 55, 7, 55,
390 46, 46, 46, 46, 46, 46, 46, 46, 46 513 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
514 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
515 55, 55, 55, 55, 55, 55, 55, 55
516
391 } ; 517 } ;
392 518
393static yyconst short int yy_chk[80] = 519static yyconst short int yy_chk[99] =
394 { 0, 520 { 0,
395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 521 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 522 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
397 1, 1, 1, 1, 1, 9, 9, 10, 10, 24, 523 1, 1, 1, 1, 1, 1, 1, 1, 1, 9,
398 24, 48, 47, 43, 42, 41, 39, 38, 37, 34, 524 9, 9, 10, 10, 10, 22, 26, 26, 26, 22,
399 33, 31, 30, 26, 23, 22, 21, 20, 19, 18, 525 56, 56, 57, 52, 51, 50, 47, 46, 45, 43,
400 16, 11, 7, 46, 46, 46, 46, 46, 46, 46, 526 40, 39, 37, 36, 34, 33, 28, 25, 24, 23,
401 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 527 21, 20, 19, 18, 17, 16, 11, 7, 55, 55,
402 46, 46, 46, 46, 46, 46, 46, 46, 46 528 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
403 } ; 529 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
530 55, 55, 55, 55, 55, 55, 55, 55
404 531
405static yy_state_type yy_last_accepting_state; 532 } ;
406static char *yy_last_accepting_cpos;
407 533
408/* The intent behind this definition is that it'll catch 534/* The intent behind this definition is that it'll catch
409 * any uses of REJECT which flex missed. 535 * any uses of REJECT which flex missed.
410 */ 536 */
411#define REJECT reject_used_but_not_detected 537#define REJECT reject_used_but_not_detected
412#define yymore() yymore_used_but_not_detected 538#define yymore() yymore_used_but_not_detected
413#define YY_MORE_ADJ 0 539#define YY_MORE_ADJ 0
414#define YY_RESTORE_YY_MORE_OFFSET 540#define YY_RESTORE_YY_MORE_OFFSET
415#ifndef YYLMAX 541#ifndef YYLMAX
416#define YYLMAX 8192 542#define YYLMAX 8192
417#endif 543#endif
418 544
545#ifndef YY_REENTRANT
419char yytext[YYLMAX]; 546char yytext[YYLMAX];
420char *yytext_ptr; 547char *yytext_ptr;
548#endif
421#line 1 "icalsslexer.l" 549#line 1 "icalsslexer.l"
422#define INITIAL 0 550#define INITIAL 0
423#line 2 "icalsslexer.l" 551#line 2 "icalsslexer.l"
424/* -*- Mode: C -*- 552/* -*- Mode: C -*-
425 ====================================================================== 553 ======================================================================
426 FILE: icalsslexer.l 554 FILE: icalsslexer.l
@@ -452,128 +580,288 @@ char *yytext_ptr;
452#include "icalssyacc.h" 580#include "icalssyacc.h"
453#include "icalgaugeimpl.h" 581#include "icalgaugeimpl.h"
454#include "assert.h" 582#include "assert.h"
455 583
456#include <string.h> /* For strdup() */ 584#include <string.h> /* For strdup() */
457 585
458int icalparser_flex_input(char* buf, int max_size); 586#undef YYPURE
459void icalparser_clear_flex_input(); 587#define YYPURE
460
461#undef YY_INPUT
462#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
463 588
464#undef SS_FATAL_ERROR 589#undef SS_FATAL_ERROR
465#define SS_FATAL_ERROR(msg) sserror(msg) 590#define SS_FATAL_ERROR(msg) sserror(msg)
466 591
467
468#define sql 1 592#define sql 1
469#define string_value 2 593#define string_value 2
470 594
471#line 465 "icalsslexer.c" 595#line 596 "lex.ss.c"
596/* %e */
597#endif /* !ssIN_HEADER */
598
599/* Special case for "unistd.h", since it is non-ANSI. We include it way
600 * down here because we want the user's section 1 to have been scanned first.
601 * The user has a chance to override it with an option.
602 */
603#ifndef YY_NO_UNISTD_H
604/* %- */
605#include <unistd.h>
606/* %+ */
607/* %* */
608#endif /* !YY_NO_UNISTD_H */
609
610
611#ifndef YY_EXTRA_TYPE
612#define YY_EXTRA_TYPE void *
613#endif
614
615/* %- Reentrant structure and macros (non-C++). */
616#ifdef YY_REENTRANT
617
618/* %c */
619#ifndef ssIN_HEADER
620struct yy_globals_t
621 {
622
623 /* User-defined. Not touched by flex. */
624 YY_EXTRA_TYPE yyextra_r;
625
626 /* The rest are the same as the globals declared in the non-reentrant scanner. */
627 FILE *yyin_r, *yyout_r;
628 YY_BUFFER_STATE yy_current_buffer;
629 char yy_hold_char;
630 int yy_n_chars;
631 int yyleng_r;
632 char *yy_c_buf_p;
633 int yy_init;
634 int yy_start;
635 int yy_did_buffer_switch_on_eof;
636 int yy_start_stack_ptr;
637 int yy_start_stack_depth;
638 int *yy_start_stack;
639 yy_state_type yy_last_accepting_state;
640 char* yy_last_accepting_cpos;
641
642 int yylineno_r;
643
644#ifdef YY_TEXT_IS_ARRAY
645 char yytext_r[YYLMAX];
646 char *yytext_ptr;
647 int yy_more_offset;
648 int yy_prev_more_offset;
649#else
650 char *yytext_r;
651 int yy_more_flag;
652 int yy_more_len;
653#endif
654
655#ifdef YY_REENTRANT_BISON_PURE
656 YYSTYPE * yylval_r;
657#ifdef YYLTYPE
658 YYLTYPE * yylloc_r;
659#endif
660#endif
661
662 };
663/* %e */
664#endif /* !ssIN_HEADER */
665
666/* %c */
667#ifndef ssIN_HEADER
668static int yy_init_globals YY_PROTO(( yyscan_t ));
669/* %e */
670#endif /* !ssIN_HEADER */
671
672/* This must go here because YYSTYPE and YYLSTYPE are included
673 * from bison output in section 1.*/
674#ifdef YY_REENTRANT_BISON_PURE
675# define yylval YY_G(yylval_r)
676# ifdef YYLTYPE
677# define yylloc YY_G(yylloc_r)
678# endif
679#endif /* YY_REENTRANT_BISON_PURE */
680
681#endif /* end if YY_REENTRANT */
682
683/* Accessor methods to globals.
684 These are made visible to non-reentrant scanners for convenience. */
685#ifndef YY_NO_GET_EXTRA
686YY_EXTRA_TYPE yyget_extra YY_PROTO(( YY_ONLY_ARG ));
687#endif
688
689#ifndef YY_NO_SET_EXTRA
690void yyset_extra YY_PROTO(( YY_EXTRA_TYPE user_defined YY_LAST_ARG ));
691#endif
692
693#ifndef YY_NO_GET_IN
694FILE *yyget_in YY_PROTO(( YY_ONLY_ARG ));
695#endif
696
697#ifndef YY_NO_SET_IN
698void yyset_in YY_PROTO(( FILE * in_str YY_LAST_ARG ));
699#endif
700
701#ifndef YY_NO_GET_OUT
702FILE *yyget_out YY_PROTO(( YY_ONLY_ARG ));
703#endif
704
705#ifndef YY_NO_SET_OUT
706void yyset_out YY_PROTO(( FILE * out_str YY_LAST_ARG ));
707#endif
708
709#ifndef YY_NO_GET_LENG
710int yyget_leng YY_PROTO(( YY_ONLY_ARG ));
711#endif
712
713#ifndef YY_NO_GET_TEXT
714char *yyget_text YY_PROTO(( YY_ONLY_ARG ));
715#endif
716
717#ifndef YY_NO_GET_LINENO
718int yyget_lineno YY_PROTO(( YY_ONLY_ARG ));
719#endif
720
721#ifndef YY_NO_SET_LINENO
722void yyset_lineno YY_PROTO(( int line_number YY_LAST_ARG ));
723#endif
724
725#ifdef YY_REENTRANT_BISON_PURE
726#ifndef YY_NO_GET_LVAL
727YYSTYPE * yyget_lval YY_PROTO(( YY_ONLY_ARG ));
728#endif
729void yyset_lval YY_PROTO(( YYSTYPE * yylvalp YY_LAST_ARG ));
730#ifdef YYLTYPE
731#ifndef YY_NO_GET_LLOC
732 YYLTYPE *yyget_lloc YY_PROTO(( YY_ONLY_ARG ));
733#endif
734#ifndef YY_NO_SET_LLOC
735 void yyset_lloc YY_PROTO(( YYLTYPE * yyllocp YY_LAST_ARG ));
736#endif
737#endif /* YYLTYPE */
738#endif /* YY_REENTRANT_BISON_PURE */
472 739
473/* Macros after this point can all be overridden by user definitions in 740/* Macros after this point can all be overridden by user definitions in
474 * section 1. 741 * section 1.
475 */ 742 */
476 743
477#ifndef YY_SKIP_YYWRAP 744#ifndef YY_SKIP_YYWRAP
478#ifdef __cplusplus 745#ifdef __cplusplus
479extern "C" int yywrap YY_PROTO(( void )); 746extern "C" int yywrap YY_PROTO(( YY_ONLY_ARG ));
480#else 747#else
481extern int yywrap YY_PROTO(( void )); 748extern int yywrap YY_PROTO(( YY_ONLY_ARG ));
482#endif 749#endif
483#endif 750#endif
484 751
752/* %- */
753/* %c */
754#ifndef ssIN_HEADER
485#ifndef YY_NO_UNPUT 755#ifndef YY_NO_UNPUT
486static void yyunput YY_PROTO(( int c, char *buf_ptr )); 756static void yyunput YY_PROTO(( int c, char *buf_ptr YY_LAST_ARG));
487#endif 757#endif
758/* %e */
759#endif /* !ssIN_HEADER */
760/* %* */
488 761
489#ifndef yytext_ptr 762#ifndef yytext_ptr
490static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 763static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int YY_LAST_ARG));
491#endif 764#endif
492 765
493#ifdef YY_NEED_STRLEN 766#ifdef YY_NEED_STRLEN
494static int yy_flex_strlen YY_PROTO(( yyconst char * )); 767static int yy_flex_strlen YY_PROTO(( yyconst char * YY_LAST_ARG));
495#endif 768#endif
496 769
497#ifndef YY_NO_INPUT 770#ifndef YY_NO_INPUT
771/* %- Standard (non-C++) definition */
772/* %c */
773#ifndef ssIN_HEADER
498#ifdef __cplusplus 774#ifdef __cplusplus
499static int yyinput YY_PROTO(( void )); 775static int yyinput YY_PROTO(( YY_ONLY_ARG ));
500#else 776#else
501static int input YY_PROTO(( void )); 777static int input YY_PROTO(( YY_ONLY_ARG ));
502#endif 778#endif
779/* %e */
780#endif /* !ssIN_HEADER */
781/* %* */
503#endif 782#endif
504 783
505#if YY_STACK_USED 784#if YY_STACK_USED
785#ifndef YY_REENTRANT
786/* %c */
787#ifndef ssIN_HEADER
506static int yy_start_stack_ptr = 0; 788static int yy_start_stack_ptr = 0;
507static int yy_start_stack_depth = 0; 789static int yy_start_stack_depth = 0;
508static int *yy_start_stack = 0; 790static int *yy_start_stack = 0;
791/* %e */
792#endif /* !ssIN_HEADER */
793#endif
509#ifndef YY_NO_PUSH_STATE 794#ifndef YY_NO_PUSH_STATE
510static void yy_push_state YY_PROTO(( int new_state )); 795static void yy_push_state YY_PROTO(( int new_state YY_LAST_ARG));
511#endif 796#endif
512#ifndef YY_NO_POP_STATE 797#ifndef YY_NO_POP_STATE
513static void yy_pop_state YY_PROTO(( void )); 798static void yy_pop_state YY_PROTO(( YY_ONLY_ARG ));
514#endif 799#endif
515#ifndef YY_NO_TOP_STATE 800#ifndef YY_NO_TOP_STATE
516static int yy_top_state YY_PROTO(( void )); 801static int yy_top_state YY_PROTO(( YY_ONLY_ARG ));
517#endif 802#endif
518 803
519#else 804#else
520#define YY_NO_PUSH_STATE 1 805#define YY_NO_PUSH_STATE 1
521#define YY_NO_POP_STATE 1 806#define YY_NO_POP_STATE 1
522#define YY_NO_TOP_STATE 1 807#define YY_NO_TOP_STATE 1
523#endif 808#endif
524 809
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. */ 810/* Amount of stuff to slurp up with each read. */
541#ifndef YY_READ_BUF_SIZE 811#ifndef YY_READ_BUF_SIZE
542#define YY_READ_BUF_SIZE 8192 812#define YY_READ_BUF_SIZE 8192
543#endif 813#endif
544 814
545/* Copy whatever the last rule matched to the standard output. */ 815/* Copy whatever the last rule matched to the standard output. */
546 816
547#ifndef ECHO 817#ifndef ECHO
818/* %- Standard (non-C++) definition */
548/* This used to be an fputs(), but since the string might contain NUL's, 819/* This used to be an fputs(), but since the string might contain NUL's,
549 * we now use fwrite(). 820 * we now use fwrite().
550 */ 821 */
551#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 822#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
823/* %+ C++ definition */
824/* %* */
552#endif 825#endif
553 826
554/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 827/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
555 * is returned in "result". 828 * is returned in "result".
556 */ 829 */
557#ifndef YY_INPUT 830#ifndef YY_INPUT
558#define YY_INPUT(buf,result,max_size) \ 831#define YY_INPUT(buf,result,max_size) \
559 if ( yy_current_buffer->yy_is_interactive ) \ 832/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
833 if ( YY_G(yy_current_buffer)->yy_is_interactive ) \
560 { \ 834 { \
561 int c = '*', n; \ 835 int c = '*'; \
836 size_t n; \
562 for ( n = 0; n < max_size && \ 837 for ( n = 0; n < max_size && \
563 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 838 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
564 buf[n] = (char) c; \ 839 buf[n] = (char) c; \
565 if ( c == '\n' ) \ 840 if ( c == '\n' ) \
566 buf[n++] = (char) c; \ 841 buf[n++] = (char) c; \
567 if ( c == EOF && ferror( yyin ) ) \ 842 if ( c == EOF && ferror( yyin ) ) \
568 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 843 YY_FATAL_ERROR( "input in flex scanner failed" ); \
569 result = n; \ 844 result = n; \
570 } \ 845 } \
571 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 846 else \
572 && ferror( yyin ) ) \ 847 { \
573 YY_FATAL_ERROR( "input in flex scanner failed" ); 848 errno=0; \
849 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
850 { \
851 if( errno != EINTR) \
852 { \
853 YY_FATAL_ERROR( "input in flex scanner failed" ); \
854 break; \
855 } \
856 errno=0; \
857 clearerr(yyin); \
858 } \
859 }
860/* %+ C++ definition \ */\
861/* %* */
574#endif 862#endif
575 863
576/* No semi-colon after return; correct usage is to write "yyterminate();" - 864/* 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 865 * we don't want an extra ';' after the "return" because that will cause
578 * some compilers to complain about unreachable statements. 866 * some compilers to complain about unreachable statements.
579 */ 867 */
@@ -585,20 +873,57 @@ YY_MALLOC_DECL
585#ifndef YY_START_STACK_INCR 873#ifndef YY_START_STACK_INCR
586#define YY_START_STACK_INCR 25 874#define YY_START_STACK_INCR 25
587#endif 875#endif
588 876
589/* Report a fatal error. */ 877/* Report a fatal error. */
590#ifndef YY_FATAL_ERROR 878#ifndef YY_FATAL_ERROR
879/* %- */
591#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 880#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
881/* %+ */
882/* %* */
592#endif 883#endif
593 884
594/* Default declaration of generated scanner - a define so the user can 885/* Default declaration of generated scanner - a define so the user can
595 * easily add parameters. 886 * easily add parameters.
596 */ 887 */
597#ifndef YY_DECL 888#ifndef YY_DECL
598#define YY_DECL int yylex YY_PROTO(( void )) 889/* %- Standard (non-C++) definition */
890
891/* If the bison pure parser is used, then bison will provide
892 one or two additional arguments. */
893
894#ifdef YY_REENTRANT_BISON_PURE
895# ifdef YYLTYPE
896# ifdef YY_USE_PROTOS
897# define YY_LEX_ARGS (YYSTYPE * yylvalp, YYLTYPE * yyllocp YY_LAST_ARG)
898# else
899# define YY_LEX_ARGS (yylvalp, yyllocp YY_LAST_ARG) \
900 YYSTYPE * yylvalp; YYLTYPE * yyllocp; YY_DECL_LAST_ARG
901# endif
902# else
903# ifdef YY_USE_PROTOS
904# define YY_LEX_ARGS (YYSTYPE * yylvalp YY_LAST_ARG)
905# else
906# define YY_LEX_ARGS (yylvalp YY_LAST_ARG) \
907 YYSTYPE * yylvalp; YY_DECL_LAST_ARG
908# endif
909# endif
910#else
911# ifdef YY_USE_PROTOS
912# define YY_LEX_ARGS (YY_ONLY_ARG)
913# else
914# define YY_LEX_ARGS (YY_ONLY_ARG) YY_DECL_LAST_ARG
915# endif
916#endif
917
918
919extern int yylex YY_PROTO( YY_LEX_ARGS );
920
921#define YY_DECL int yylex YY_LEX_ARGS
922/* %+ C++ definition */
923/* %* */
599#endif 924#endif
600 925
601/* Code executed at the beginning of each rule, after yytext and yyleng 926/* Code executed at the beginning of each rule, after yytext and yyleng
602 * have been set up. 927 * have been set up.
603 */ 928 */
604#ifndef YY_USER_ACTION 929#ifndef YY_USER_ACTION
@@ -607,374 +932,437 @@ YY_MALLOC_DECL
607 932
608/* Code executed at the end of each rule. */ 933/* Code executed at the end of each rule. */
609#ifndef YY_BREAK 934#ifndef YY_BREAK
610#define YY_BREAK break; 935#define YY_BREAK break;
611#endif 936#endif
612 937
938/* %% [6.0] YY_RULE_SETUP definition goes here */
613#define YY_RULE_SETUP \ 939#define YY_RULE_SETUP \
614 YY_USER_ACTION 940 YY_USER_ACTION
615 941
942/* %c */
943#ifndef ssIN_HEADER
616YY_DECL 944YY_DECL
617 { 945 {
618 register yy_state_type yy_current_state; 946 register yy_state_type yy_current_state;
619 register char *yy_cp = NULL, *yy_bp = NULL; 947 register char *yy_cp, *yy_bp;
620 register int yy_act; 948 register int yy_act;
621 949
622#line 69 "icalsslexer.l" 950/* %% [7.0] user's declarations go here */
951#line 66 "icalsslexer.l"
952
623 953
624 954
625 955
626 956
627 957
958#line 959 "lex.ss.c"
628 959
629#line 623 "icalsslexer.c" 960#ifdef YY_REENTRANT_BISON_PURE
961 yylval = yylvalp;
962#ifdef YYLTYPE
963 yylloc = yyllocp;
964#endif
965#endif
630 966
631 if ( yy_init ) 967 if ( YY_G(yy_init) )
632 { 968 {
633 yy_init = 0; 969 YY_G(yy_init) = 0;
634 970
635#ifdef YY_USER_INIT 971#ifdef YY_USER_INIT
636 YY_USER_INIT; 972 YY_USER_INIT;
637#endif 973#endif
638 974
639 if ( ! yy_start ) 975 if ( ! YY_G(yy_start) )
640 yy_start = 1;/* first start state */ 976 YY_G(yy_start) = 1;/* first start state */
641 977
642 if ( ! yyin ) 978 if ( ! yyin )
979/* %- */
643 yyin = stdin; 980 yyin = stdin;
981/* %+ */
982/* %* */
644 983
645 if ( ! yyout ) 984 if ( ! yyout )
985/* %- */
646 yyout = stdout; 986 yyout = stdout;
987/* %+ */
988/* %* */
647 989
648 if ( ! yy_current_buffer ) 990 if ( ! YY_G(yy_current_buffer) )
649 yy_current_buffer = 991 YY_G(yy_current_buffer) =
650 yy_create_buffer( yyin, YY_BUF_SIZE ); 992 yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG);
651 993
652 yy_load_buffer_state(); 994 yy_load_buffer_state( YY_CALL_ONLY_ARG );
653 } 995 }
654 996
655 while ( 1 ) /* loops until end-of-file is reached */ 997 while ( 1 ) /* loops until end-of-file is reached */
656 { 998 {
657 yy_cp = yy_c_buf_p; 999/* %% [8.0] yymore()-related code goes here */
1000 yy_cp = YY_G(yy_c_buf_p);
658 1001
659 /* Support of yytext. */ 1002 /* Support of yytext. */
660 *yy_cp = yy_hold_char; 1003 *yy_cp = YY_G(yy_hold_char);
661 1004
662 /* yy_bp points to the position in yy_ch_buf of the start of 1005 /* yy_bp points to the position in yy_ch_buf of the start of
663 * the current run. 1006 * the current run.
664 */ 1007 */
665 yy_bp = yy_cp; 1008 yy_bp = yy_cp;
666 1009
667 yy_current_state = yy_start; 1010/* %% [9.0] code to set up and find next match goes here */
1011 yy_current_state = YY_G(yy_start);
668yy_match: 1012yy_match:
669 do 1013 do
670 { 1014 {
671 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 1015 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
672 if ( yy_accept[yy_current_state] ) 1016 if ( yy_accept[yy_current_state] )
673 { 1017 {
674 yy_last_accepting_state = yy_current_state; 1018 YY_G(yy_last_accepting_state) = yy_current_state;
675 yy_last_accepting_cpos = yy_cp; 1019 YY_G(yy_last_accepting_cpos) = yy_cp;
676 } 1020 }
677 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1021 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
678 { 1022 {
679 yy_current_state = (int) yy_def[yy_current_state]; 1023 yy_current_state = (int) yy_def[yy_current_state];
680 if ( yy_current_state >= 47 ) 1024 if ( yy_current_state >= 56 )
681 yy_c = yy_meta[(unsigned int) yy_c]; 1025 yy_c = yy_meta[(unsigned int) yy_c];
682 } 1026 }
683 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1027 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
684 ++yy_cp; 1028 ++yy_cp;
685 } 1029 }
686 while ( yy_base[yy_current_state] != 54 ); 1030 while ( yy_base[yy_current_state] != 69 );
687 1031
688yy_find_action: 1032yy_find_action:
1033/* %% [10.0] code to find the action number goes here */
689 yy_act = yy_accept[yy_current_state]; 1034 yy_act = yy_accept[yy_current_state];
690 if ( yy_act == 0 ) 1035 if ( yy_act == 0 )
691 { /* have to back up */ 1036 { /* have to back up */
692 yy_cp = yy_last_accepting_cpos; 1037 yy_cp = YY_G(yy_last_accepting_cpos);
693 yy_current_state = yy_last_accepting_state; 1038 yy_current_state = YY_G(yy_last_accepting_state);
694 yy_act = yy_accept[yy_current_state]; 1039 yy_act = yy_accept[yy_current_state];
695 } 1040 }
696 1041
697 YY_DO_BEFORE_ACTION; 1042 YY_DO_BEFORE_ACTION;
698 1043
1044/* %% [11.0] code for yylineno update goes here */
699 1045
700 do_action:/* This label is used only to access EOF actions. */ 1046 do_action:/* This label is used only to access EOF actions. */
701 1047
1048/* %% [12.0] debug code goes here */
702 1049
703 switch ( yy_act ) 1050 switch ( yy_act )
704 { /* beginning of action switch */ 1051 { /* beginning of action switch */
1052/* %% [13.0] actions go here */
705 case 0: /* must back up */ 1053 case 0: /* must back up */
706 /* undo the effects of YY_DO_BEFORE_ACTION */ 1054 /* undo the effects of YY_DO_BEFORE_ACTION */
707 *yy_cp = yy_hold_char; 1055 *yy_cp = YY_G(yy_hold_char);
708 yy_cp = yy_last_accepting_cpos; 1056 yy_cp = YY_G(yy_last_accepting_cpos);
709 yy_current_state = yy_last_accepting_state; 1057 yy_current_state = YY_G(yy_last_accepting_state);
710 goto yy_find_action; 1058 goto yy_find_action;
711 1059
712case 1: 1060case 1:
713YY_RULE_SETUP 1061YY_RULE_SETUP
714#line 75 "icalsslexer.l" 1062#line 72 "icalsslexer.l"
715{ return SELECT; } 1063{ return SELECT; }
716 YY_BREAK 1064 YY_BREAK
717case 2: 1065case 2:
718YY_RULE_SETUP 1066YY_RULE_SETUP
719#line 76 "icalsslexer.l" 1067#line 73 "icalsslexer.l"
720{ return FROM; } 1068{ return FROM; }
721 YY_BREAK 1069 YY_BREAK
722case 3: 1070case 3:
723YY_RULE_SETUP 1071YY_RULE_SETUP
724#line 77 "icalsslexer.l" 1072#line 74 "icalsslexer.l"
725{ return WHERE; } 1073{ return WHERE; }
726 YY_BREAK 1074 YY_BREAK
727case 4: 1075case 4:
728YY_RULE_SETUP 1076YY_RULE_SETUP
729#line 78 "icalsslexer.l" 1077#line 75 "icalsslexer.l"
730{ return COMMA; } 1078{ return COMMA; }
731 YY_BREAK 1079 YY_BREAK
732case 5: 1080case 5:
733YY_RULE_SETUP 1081YY_RULE_SETUP
734#line 79 "icalsslexer.l" 1082#line 76 "icalsslexer.l"
735{ return EQUALS; } 1083{ return EQUALS; }
736 YY_BREAK 1084 YY_BREAK
737case 6: 1085case 6:
738YY_RULE_SETUP 1086YY_RULE_SETUP
739#line 80 "icalsslexer.l" 1087#line 77 "icalsslexer.l"
740{ return NOTEQUALS; } 1088{ return EQUALS; }
741 YY_BREAK 1089 YY_BREAK
742case 7: 1090case 7:
743YY_RULE_SETUP 1091YY_RULE_SETUP
744#line 81 "icalsslexer.l" 1092#line 78 "icalsslexer.l"
745{ return LESS; } 1093{ return NOTEQUALS; }
746 YY_BREAK 1094 YY_BREAK
747case 8: 1095case 8:
748YY_RULE_SETUP 1096YY_RULE_SETUP
749#line 82 "icalsslexer.l" 1097#line 79 "icalsslexer.l"
750{ return GREATER; } 1098{ return LESS; }
751 YY_BREAK 1099 YY_BREAK
752case 9: 1100case 9:
753YY_RULE_SETUP 1101YY_RULE_SETUP
754#line 83 "icalsslexer.l" 1102#line 80 "icalsslexer.l"
755{ return LESSEQUALS; } 1103{ return GREATER; }
756 YY_BREAK 1104 YY_BREAK
757case 10: 1105case 10:
758YY_RULE_SETUP 1106YY_RULE_SETUP
759#line 84 "icalsslexer.l" 1107#line 81 "icalsslexer.l"
760{ return GREATEREQUALS; } 1108{ return LESSEQUALS; }
761 YY_BREAK 1109 YY_BREAK
762case 11: 1110case 11:
763YY_RULE_SETUP 1111YY_RULE_SETUP
764#line 85 "icalsslexer.l" 1112#line 82 "icalsslexer.l"
765{ return AND; } 1113{ return GREATEREQUALS; }
766 YY_BREAK 1114 YY_BREAK
767case 12: 1115case 12:
768YY_RULE_SETUP 1116YY_RULE_SETUP
769#line 86 "icalsslexer.l" 1117#line 83 "icalsslexer.l"
770{ return OR; } 1118{ return AND; }
771 YY_BREAK 1119 YY_BREAK
772case 13: 1120case 13:
773YY_RULE_SETUP 1121YY_RULE_SETUP
774#line 87 "icalsslexer.l" 1122#line 84 "icalsslexer.l"
775{ return QUOTE; } 1123{ return OR; }
776 YY_BREAK 1124 YY_BREAK
777case 14: 1125case 14:
778YY_RULE_SETUP 1126YY_RULE_SETUP
779#line 88 "icalsslexer.l" 1127#line 85 "icalsslexer.l"
780 ; 1128{ return IS; }
781 YY_BREAK 1129 YY_BREAK
782case 15: 1130case 15:
783YY_RULE_SETUP 1131YY_RULE_SETUP
784#line 89 "icalsslexer.l" 1132#line 86 "icalsslexer.l"
785{ return EOL; } 1133{ return NOT; }
786 YY_BREAK 1134 YY_BREAK
787case 16: 1135case 16:
788YY_RULE_SETUP 1136YY_RULE_SETUP
1137#line 87 "icalsslexer.l"
1138{ return SQLNULL; }
1139 YY_BREAK
1140case 17:
1141YY_RULE_SETUP
1142#line 88 "icalsslexer.l"
1143{ return QUOTE; }
1144 YY_BREAK
1145case 18:
1146YY_RULE_SETUP
1147#line 89 "icalsslexer.l"
1148 ;
1149 YY_BREAK
1150case 19:
1151YY_RULE_SETUP
789#line 90 "icalsslexer.l" 1152#line 90 "icalsslexer.l"
1153{ return EOL; }
1154 YY_BREAK
1155case 20:
1156YY_RULE_SETUP
1157#line 92 "icalsslexer.l"
790{ 1158{
791 int c = input(); 1159 int c = input(yy_globals);
792 unput(c); 1160 unput(c);
793 if(c!='\''){ 1161 if(c!='\''){
794 sslval.v_string= icalmemory_tmp_copy(sstext); 1162 yylvalp->v_string= icalmemory_tmp_copy(yytext);
795 return STRING; 1163 return STRING;
796 } else { 1164 } else {
797 /*ssmore();*/ 1165 /*ssmore();*/
798 } 1166 }
799} 1167}
800 YY_BREAK 1168 YY_BREAK
801case 17: 1169case 21:
802YY_RULE_SETUP 1170YY_RULE_SETUP
803#line 101 "icalsslexer.l" 1171#line 103 "icalsslexer.l"
804{ sslval.v_string= icalmemory_tmp_copy(sstext); 1172{
805 return STRING; } 1173 yylval->v_string= icalmemory_tmp_copy(yytext);
1174 return STRING;
1175}
806 YY_BREAK 1176 YY_BREAK
807case 18: 1177case 22:
808YY_RULE_SETUP 1178YY_RULE_SETUP
809#line 105 "icalsslexer.l" 1179#line 109 "icalsslexer.l"
810{ return yytext[0]; } 1180{ return yytext[0]; }
811 YY_BREAK 1181 YY_BREAK
812case 19: 1182case 23:
813YY_RULE_SETUP 1183YY_RULE_SETUP
814#line 107 "icalsslexer.l" 1184#line 111 "icalsslexer.l"
815ECHO; 1185ECHO;
816 YY_BREAK 1186 YY_BREAK
817#line 811 "icalsslexer.c" 1187#line 1188 "lex.ss.c"
818case YY_STATE_EOF(INITIAL): 1188case YY_STATE_EOF(INITIAL):
819case YY_STATE_EOF(sql): 1189case YY_STATE_EOF(sql):
820case YY_STATE_EOF(string_value): 1190case YY_STATE_EOF(string_value):
821 yyterminate(); 1191 yyterminate();
822 1192
823 case YY_END_OF_BUFFER: 1193 case YY_END_OF_BUFFER:
824 { 1194 {
825 /* Amount of text matched not including the EOB char. */ 1195 /* Amount of text matched not including the EOB char. */
826 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 1196 int yy_amount_of_matched_text = (int) (yy_cp - YY_G(yytext_ptr)) - 1;
827 1197
828 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1198 /* Undo the effects of YY_DO_BEFORE_ACTION. */
829 *yy_cp = yy_hold_char; 1199 *yy_cp = YY_G(yy_hold_char);
830 YY_RESTORE_YY_MORE_OFFSET 1200 YY_RESTORE_YY_MORE_OFFSET
831 1201
832 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 1202 if ( YY_G(yy_current_buffer)->yy_buffer_status == YY_BUFFER_NEW )
833 { 1203 {
834 /* We're scanning a new file or input source. It's 1204 /* We're scanning a new file or input source. It's
835 * possible that this happened because the user 1205 * possible that this happened because the user
836 * just pointed yyin at a new source and called 1206 * just pointed yyin at a new source and called
837 * yylex(). If so, then we have to assure 1207 * yylex(). If so, then we have to assure
838 * consistency between yy_current_buffer and our 1208 * consistency between yy_current_buffer and our
839 * globals. Here is the right place to do so, because 1209 * globals. Here is the right place to do so, because
840 * this is the first action (other than possibly a 1210 * this is the first action (other than possibly a
841 * back-up) that will match for the new input source. 1211 * back-up) that will match for the new input source.
842 */ 1212 */
843 yy_n_chars = yy_current_buffer->yy_n_chars; 1213 YY_G(yy_n_chars) = YY_G(yy_current_buffer)->yy_n_chars;
844 yy_current_buffer->yy_input_file = yyin; 1214 YY_G(yy_current_buffer)->yy_input_file = yyin;
845 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1215 YY_G(yy_current_buffer)->yy_buffer_status = YY_BUFFER_NORMAL;
846 } 1216 }
847 1217
848 /* Note that here we test for yy_c_buf_p "<=" to the position 1218 /* 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 1219 * of the first EOB in the buffer, since yy_c_buf_p will
850 * already have been incremented past the NUL character 1220 * already have been incremented past the NUL character
851 * (since all states make transitions on EOB to the 1221 * (since all states make transitions on EOB to the
852 * end-of-buffer state). Contrast this with the test 1222 * end-of-buffer state). Contrast this with the test
853 * in input(). 1223 * in input().
854 */ 1224 */
855 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1225 if ( YY_G(yy_c_buf_p) <= &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] )
856 { /* This was really a NUL. */ 1226 { /* This was really a NUL. */
857 yy_state_type yy_next_state; 1227 yy_state_type yy_next_state;
858 1228
859 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1229 YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + yy_amount_of_matched_text;
860 1230
861 yy_current_state = yy_get_previous_state(); 1231 yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );
862 1232
863 /* Okay, we're now positioned to make the NUL 1233 /* Okay, we're now positioned to make the NUL
864 * transition. We couldn't have 1234 * transition. We couldn't have
865 * yy_get_previous_state() go ahead and do it 1235 * yy_get_previous_state() go ahead and do it
866 * for us because it doesn't know how to deal 1236 * for us because it doesn't know how to deal
867 * with the possibility of jamming (and we don't 1237 * with the possibility of jamming (and we don't
868 * want to build jamming into it because then it 1238 * want to build jamming into it because then it
869 * will run more slowly). 1239 * will run more slowly).
870 */ 1240 */
871 1241
872 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1242 yy_next_state = yy_try_NUL_trans( yy_current_state YY_CALL_LAST_ARG);
873 1243
874 yy_bp = yytext_ptr + YY_MORE_ADJ; 1244 yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
875 1245
876 if ( yy_next_state ) 1246 if ( yy_next_state )
877 { 1247 {
878 /* Consume the NUL. */ 1248 /* Consume the NUL. */
879 yy_cp = ++yy_c_buf_p; 1249 yy_cp = ++YY_G(yy_c_buf_p);
880 yy_current_state = yy_next_state; 1250 yy_current_state = yy_next_state;
881 goto yy_match; 1251 goto yy_match;
882 } 1252 }
883 1253
884 else 1254 else
885 { 1255 {
886 yy_cp = yy_c_buf_p; 1256/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
1257 yy_cp = YY_G(yy_c_buf_p);
887 goto yy_find_action; 1258 goto yy_find_action;
888 } 1259 }
889 } 1260 }
890 1261
891 else switch ( yy_get_next_buffer() ) 1262 else switch ( yy_get_next_buffer( YY_CALL_ONLY_ARG ) )
892 { 1263 {
893 case EOB_ACT_END_OF_FILE: 1264 case EOB_ACT_END_OF_FILE:
894 { 1265 {
895 yy_did_buffer_switch_on_eof = 0; 1266 YY_G(yy_did_buffer_switch_on_eof) = 0;
896 1267
897 if ( yywrap() ) 1268 if ( yywrap( YY_CALL_ONLY_ARG ) )
898 { 1269 {
899 /* Note: because we've taken care in 1270 /* Note: because we've taken care in
900 * yy_get_next_buffer() to have set up 1271 * yy_get_next_buffer() to have set up
901 * yytext, we can now set up 1272 * yytext, we can now set up
902 * yy_c_buf_p so that if some total 1273 * yy_c_buf_p so that if some total
903 * hoser (like flex itself) wants to 1274 * hoser (like flex itself) wants to
904 * call the scanner after we return the 1275 * call the scanner after we return the
905 * YY_NULL, it'll still work - another 1276 * YY_NULL, it'll still work - another
906 * YY_NULL will get returned. 1277 * YY_NULL will get returned.
907 */ 1278 */
908 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1279 YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + YY_MORE_ADJ;
909 1280
910 yy_act = YY_STATE_EOF(YY_START); 1281 yy_act = YY_STATE_EOF(YY_START);
911 goto do_action; 1282 goto do_action;
912 } 1283 }
913 1284
914 else 1285 else
915 { 1286 {
916 if ( ! yy_did_buffer_switch_on_eof ) 1287 if ( ! YY_G(yy_did_buffer_switch_on_eof) )
917 YY_NEW_FILE; 1288 YY_NEW_FILE;
918 } 1289 }
919 break; 1290 break;
920 } 1291 }
921 1292
922 case EOB_ACT_CONTINUE_SCAN: 1293 case EOB_ACT_CONTINUE_SCAN:
923 yy_c_buf_p = 1294 YY_G(yy_c_buf_p) =
924 yytext_ptr + yy_amount_of_matched_text; 1295 YY_G(yytext_ptr) + yy_amount_of_matched_text;
925 1296
926 yy_current_state = yy_get_previous_state(); 1297 yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );
927 1298
928 yy_cp = yy_c_buf_p; 1299 yy_cp = YY_G(yy_c_buf_p);
929 yy_bp = yytext_ptr + YY_MORE_ADJ; 1300 yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
930 goto yy_match; 1301 goto yy_match;
931 1302
932 case EOB_ACT_LAST_MATCH: 1303 case EOB_ACT_LAST_MATCH:
933 yy_c_buf_p = 1304 YY_G(yy_c_buf_p) =
934 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1305 &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)];
935 1306
936 yy_current_state = yy_get_previous_state(); 1307 yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );
937 1308
938 yy_cp = yy_c_buf_p; 1309 yy_cp = YY_G(yy_c_buf_p);
939 yy_bp = yytext_ptr + YY_MORE_ADJ; 1310 yy_bp = YY_G(yytext_ptr) + YY_MORE_ADJ;
940 goto yy_find_action; 1311 goto yy_find_action;
941 } 1312 }
942 break; 1313 break;
943 } 1314 }
944 1315
945 default: 1316 default:
946 YY_FATAL_ERROR( 1317 YY_FATAL_ERROR(
947 "fatal flex scanner internal error--no action found" ); 1318 "fatal flex scanner internal error--no action found" );
948 } /* end of action switch */ 1319 } /* end of action switch */
949 } /* end of scanning one token */ 1320 } /* end of scanning one token */
950 } /* end of yylex */ 1321 } /* end of yylex */
951 1322/* %e */
1323#endif /* !ssIN_HEADER */
1324/* %+ */
1325/* %c */
1326#ifndef ssIN_HEADER
1327/* %e */
1328#endif /* !ssIN_HEADER */
1329/* %* */
952 1330
953/* yy_get_next_buffer - try to read in a new buffer 1331/* yy_get_next_buffer - try to read in a new buffer
954 * 1332 *
955 * Returns a code representing an action: 1333 * Returns a code representing an action:
956 *EOB_ACT_LAST_MATCH - 1334 *EOB_ACT_LAST_MATCH -
957 *EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1335 *EOB_ACT_CONTINUE_SCAN - continue scanning from current position
958 *EOB_ACT_END_OF_FILE - end of file 1336 *EOB_ACT_END_OF_FILE - end of file
959 */ 1337 */
960 1338
961static int yy_get_next_buffer() 1339/* %- */
1340/* %c */
1341#ifndef ssIN_HEADER
1342#ifdef YY_USE_PROTOS
1343static int yy_get_next_buffer(YY_ONLY_ARG)
1344#else
1345static int yy_get_next_buffer(YY_ONLY_ARG)
1346YY_DECL_LAST_ARG
1347#endif
1348/* %+ */
1349/* %* */
962 { 1350 {
963 register char *dest = yy_current_buffer->yy_ch_buf; 1351 register char *dest = YY_G(yy_current_buffer)->yy_ch_buf;
964 register char *source = yytext_ptr; 1352 register char *source = YY_G(yytext_ptr);
965 register int number_to_move, i; 1353 register int number_to_move, i;
966 int ret_val; 1354 int ret_val;
967 1355
968 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1356 if ( YY_G(yy_c_buf_p) > &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars) + 1] )
969 YY_FATAL_ERROR( 1357 YY_FATAL_ERROR(
970 "fatal flex scanner internal error--end of buffer missed" ); 1358 "fatal flex scanner internal error--end of buffer missed" );
971 1359
972 if ( yy_current_buffer->yy_fill_buffer == 0 ) 1360 if ( YY_G(yy_current_buffer)->yy_fill_buffer == 0 )
973 { /* Don't try to fill the buffer, so this is an EOF. */ 1361 { /* Don't try to fill the buffer, so this is an EOF. */
974 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1362 if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 )
975 { 1363 {
976 /* We matched a single character, the EOB, so 1364 /* We matched a single character, the EOB, so
977 * treat this as a final EOF. 1365 * treat this as a final EOF.
978 */ 1366 */
979 return EOB_ACT_END_OF_FILE; 1367 return EOB_ACT_END_OF_FILE;
980 } 1368 }
@@ -988,40 +1376,40 @@ static int yy_get_next_buffer()
988 } 1376 }
989 } 1377 }
990 1378
991 /* Try to read more data. */ 1379 /* Try to read more data. */
992 1380
993 /* First move last chars to start of buffer. */ 1381 /* First move last chars to start of buffer. */
994 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1382 number_to_move = (int) (YY_G(yy_c_buf_p) - YY_G(yytext_ptr)) - 1;
995 1383
996 for ( i = 0; i < number_to_move; ++i ) 1384 for ( i = 0; i < number_to_move; ++i )
997 *(dest++) = *(source++); 1385 *(dest++) = *(source++);
998 1386
999 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1387 if ( YY_G(yy_current_buffer)->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1000 /* don't do the read, it's not guaranteed to return an EOF, 1388 /* don't do the read, it's not guaranteed to return an EOF,
1001 * just force an EOF 1389 * just force an EOF
1002 */ 1390 */
1003 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1391 YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars) = 0;
1004 1392
1005 else 1393 else
1006 { 1394 {
1007 int num_to_read = 1395 size_t num_to_read =
1008 yy_current_buffer->yy_buf_size - number_to_move - 1; 1396 YY_G(yy_current_buffer)->yy_buf_size - number_to_move - 1;
1009 1397
1010 while ( num_to_read <= 0 ) 1398 while ( num_to_read <= 0 )
1011 { /* Not enough room in the buffer - grow it. */ 1399 { /* Not enough room in the buffer - grow it. */
1012#ifdef YY_USES_REJECT 1400#ifdef YY_USES_REJECT
1013 YY_FATAL_ERROR( 1401 YY_FATAL_ERROR(
1014"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1402"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1015#else 1403#else
1016 1404
1017 /* just a shorter name for the current buffer */ 1405 /* just a shorter name for the current buffer */
1018 YY_BUFFER_STATE b = yy_current_buffer; 1406 YY_BUFFER_STATE b = YY_G(yy_current_buffer);
1019 1407
1020 int yy_c_buf_p_offset = 1408 int yy_c_buf_p_offset =
1021 (int) (yy_c_buf_p - b->yy_ch_buf); 1409 (int) (YY_G(yy_c_buf_p) - b->yy_ch_buf);
1022 1410
1023 if ( b->yy_is_our_buffer ) 1411 if ( b->yy_is_our_buffer )
1024 { 1412 {
1025 int new_size = b->yy_buf_size * 2; 1413 int new_size = b->yy_buf_size * 2;
1026 1414
1027 if ( new_size <= 0 ) 1415 if ( new_size <= 0 )
@@ -1029,89 +1417,102 @@ static int yy_get_next_buffer()
1029 else 1417 else
1030 b->yy_buf_size *= 2; 1418 b->yy_buf_size *= 2;
1031 1419
1032 b->yy_ch_buf = (char *) 1420 b->yy_ch_buf = (char *)
1033 /* Include room in for 2 EOB chars. */ 1421 /* Include room in for 2 EOB chars. */
1034 yy_flex_realloc( (void *) b->yy_ch_buf, 1422 yy_flex_realloc( (void *) b->yy_ch_buf,
1035 b->yy_buf_size + 2 ); 1423 b->yy_buf_size + 2 YY_CALL_LAST_ARG );
1036 } 1424 }
1037 else 1425 else
1038 /* Can't grow it, we don't own it. */ 1426 /* Can't grow it, we don't own it. */
1039 b->yy_ch_buf = 0; 1427 b->yy_ch_buf = 0;
1040 1428
1041 if ( ! b->yy_ch_buf ) 1429 if ( ! b->yy_ch_buf )
1042 YY_FATAL_ERROR( 1430 YY_FATAL_ERROR(
1043 "fatal error - scanner input buffer overflow" ); 1431 "fatal error - scanner input buffer overflow" );
1044 1432
1045 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1433 YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1046 1434
1047 num_to_read = yy_current_buffer->yy_buf_size - 1435 num_to_read = YY_G(yy_current_buffer)->yy_buf_size -
1048 number_to_move - 1; 1436 number_to_move - 1;
1049#endif 1437#endif
1050 } 1438 }
1051 1439
1052 if ( num_to_read > YY_READ_BUF_SIZE ) 1440 if ( num_to_read > YY_READ_BUF_SIZE )
1053 num_to_read = YY_READ_BUF_SIZE; 1441 num_to_read = YY_READ_BUF_SIZE;
1054 1442
1055 /* Read in more data. */ 1443 /* Read in more data. */
1056 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1444 YY_INPUT( (&YY_G(yy_current_buffer)->yy_ch_buf[number_to_move]),
1057 yy_n_chars, num_to_read ); 1445 YY_G(yy_n_chars), num_to_read );
1058 1446
1059 yy_current_buffer->yy_n_chars = yy_n_chars; 1447 YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars);
1060 } 1448 }
1061 1449
1062 if ( yy_n_chars == 0 ) 1450 if ( YY_G(yy_n_chars) == 0 )
1063 { 1451 {
1064 if ( number_to_move == YY_MORE_ADJ ) 1452 if ( number_to_move == YY_MORE_ADJ )
1065 { 1453 {
1066 ret_val = EOB_ACT_END_OF_FILE; 1454 ret_val = EOB_ACT_END_OF_FILE;
1067 yyrestart( yyin ); 1455 yyrestart( yyin YY_CALL_LAST_ARG);
1068 } 1456 }
1069 1457
1070 else 1458 else
1071 { 1459 {
1072 ret_val = EOB_ACT_LAST_MATCH; 1460 ret_val = EOB_ACT_LAST_MATCH;
1073 yy_current_buffer->yy_buffer_status = 1461 YY_G(yy_current_buffer)->yy_buffer_status =
1074 YY_BUFFER_EOF_PENDING; 1462 YY_BUFFER_EOF_PENDING;
1075 } 1463 }
1076 } 1464 }
1077 1465
1078 else 1466 else
1079 ret_val = EOB_ACT_CONTINUE_SCAN; 1467 ret_val = EOB_ACT_CONTINUE_SCAN;
1080 1468
1081 yy_n_chars += number_to_move; 1469 YY_G(yy_n_chars) += number_to_move;
1082 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1470 YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1083 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1471 YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1084 1472
1085 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1473 YY_G(yytext_ptr) = &YY_G(yy_current_buffer)->yy_ch_buf[0];
1086 1474
1087 return ret_val; 1475 return ret_val;
1088 } 1476 }
1089 1477/* %e */
1478#endif /* !ssIN_HEADER */
1090 1479
1091/* yy_get_previous_state - get the state just before the EOB char was reached */ 1480/* yy_get_previous_state - get the state just before the EOB char was reached */
1092 1481
1093static yy_state_type yy_get_previous_state() 1482/* %- */
1483/* %c */
1484#ifndef ssIN_HEADER
1485#ifdef YY_USE_PROTOS
1486static yy_state_type yy_get_previous_state(YY_ONLY_ARG)
1487#else
1488static yy_state_type yy_get_previous_state(YY_ONLY_ARG)
1489YY_DECL_LAST_ARG
1490#endif
1491/* %+ */
1492/* %* */
1094 { 1493 {
1095 register yy_state_type yy_current_state; 1494 register yy_state_type yy_current_state;
1096 register char *yy_cp; 1495 register char *yy_cp;
1097 1496
1098 yy_current_state = yy_start; 1497/* %% [15.0] code to get the start state into yy_current_state goes here */
1498 yy_current_state = YY_G(yy_start);
1099 1499
1100 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1500 for ( yy_cp = YY_G(yytext_ptr) + YY_MORE_ADJ; yy_cp < YY_G(yy_c_buf_p); ++yy_cp )
1101 { 1501 {
1502/* %% [16.0] code to find the next state goes here */
1102 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1503 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1103 if ( yy_accept[yy_current_state] ) 1504 if ( yy_accept[yy_current_state] )
1104 { 1505 {
1105 yy_last_accepting_state = yy_current_state; 1506 YY_G(yy_last_accepting_state) = yy_current_state;
1106 yy_last_accepting_cpos = yy_cp; 1507 YY_G(yy_last_accepting_cpos) = yy_cp;
1107 } 1508 }
1108 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1509 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1109 { 1510 {
1110 yy_current_state = (int) yy_def[yy_current_state]; 1511 yy_current_state = (int) yy_def[yy_current_state];
1111 if ( yy_current_state >= 47 ) 1512 if ( yy_current_state >= 56 )
1112 yy_c = yy_meta[(unsigned int) yy_c]; 1513 yy_c = yy_meta[(unsigned int) yy_c];
1113 } 1514 }
1114 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1515 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1115 } 1516 }
1116 1517
1117 return yy_current_state; 1518 return yy_current_state;
@@ -1121,112 +1522,133 @@ static yy_state_type yy_get_previous_state()
1121/* yy_try_NUL_trans - try to make a transition on the NUL character 1522/* yy_try_NUL_trans - try to make a transition on the NUL character
1122 * 1523 *
1123 * synopsis 1524 * synopsis
1124 *next_state = yy_try_NUL_trans( current_state ); 1525 *next_state = yy_try_NUL_trans( current_state );
1125 */ 1526 */
1126 1527
1528/* %- */
1127#ifdef YY_USE_PROTOS 1529#ifdef YY_USE_PROTOS
1128static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1530static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state YY_LAST_ARG )
1129#else 1531#else
1130static yy_state_type yy_try_NUL_trans( yy_current_state ) 1532static yy_state_type yy_try_NUL_trans( yy_current_state YY_LAST_ARG )
1131yy_state_type yy_current_state; 1533yy_state_type yy_current_state;
1534YY_DECL_LAST_ARG
1132#endif 1535#endif
1536/* %+ */
1537/* %* */
1133 { 1538 {
1134 register int yy_is_jam; 1539 register int yy_is_jam;
1135 register char *yy_cp = yy_c_buf_p; 1540/* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
1541 register char *yy_cp = YY_G(yy_c_buf_p);
1136 1542
1137 register YY_CHAR yy_c = 1; 1543 register YY_CHAR yy_c = 1;
1138 if ( yy_accept[yy_current_state] ) 1544 if ( yy_accept[yy_current_state] )
1139 { 1545 {
1140 yy_last_accepting_state = yy_current_state; 1546 YY_G(yy_last_accepting_state) = yy_current_state;
1141 yy_last_accepting_cpos = yy_cp; 1547 YY_G(yy_last_accepting_cpos) = yy_cp;
1142 } 1548 }
1143 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1549 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1144 { 1550 {
1145 yy_current_state = (int) yy_def[yy_current_state]; 1551 yy_current_state = (int) yy_def[yy_current_state];
1146 if ( yy_current_state >= 47 ) 1552 if ( yy_current_state >= 56 )
1147 yy_c = yy_meta[(unsigned int) yy_c]; 1553 yy_c = yy_meta[(unsigned int) yy_c];
1148 } 1554 }
1149 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1555 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1150 yy_is_jam = (yy_current_state == 46); 1556 yy_is_jam = (yy_current_state == 55);
1151 1557
1152 return yy_is_jam ? 0 : yy_current_state; 1558 return yy_is_jam ? 0 : yy_current_state;
1153 } 1559 }
1154 1560
1155 1561
1562/* %- */
1156#ifndef YY_NO_UNPUT 1563#ifndef YY_NO_UNPUT
1157#ifdef YY_USE_PROTOS 1564#ifdef YY_USE_PROTOS
1158static void yyunput( int c, register char *yy_bp ) 1565static void yyunput( int c, register char *yy_bp YY_LAST_ARG )
1159#else 1566#else
1160static void yyunput( c, yy_bp ) 1567static void yyunput( c, yy_bp YY_LAST_ARG)
1161int c; 1568int c;
1162register char *yy_bp; 1569register char *yy_bp;
1570YY_DECL_LAST_ARG
1163#endif 1571#endif
1572/* %+ */
1573/* %* */
1164 { 1574 {
1165 register char *yy_cp = yy_c_buf_p; 1575 register char *yy_cp = YY_G(yy_c_buf_p);
1166 1576
1167 /* undo effects of setting up yytext */ 1577 /* undo effects of setting up yytext */
1168 *yy_cp = yy_hold_char; 1578 *yy_cp = YY_G(yy_hold_char);
1169 1579
1170 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1580 if ( yy_cp < YY_G(yy_current_buffer)->yy_ch_buf + 2 )
1171 { /* need to shift things up to make room */ 1581 { /* need to shift things up to make room */
1172 /* +2 for EOB chars. */ 1582 /* +2 for EOB chars. */
1173 register int number_to_move = yy_n_chars + 2; 1583 register int number_to_move = YY_G(yy_n_chars) + 2;
1174 register char *dest = &yy_current_buffer->yy_ch_buf[ 1584 register char *dest = &YY_G(yy_current_buffer)->yy_ch_buf[
1175 yy_current_buffer->yy_buf_size + 2]; 1585 YY_G(yy_current_buffer)->yy_buf_size + 2];
1176 register char *source = 1586 register char *source =
1177 &yy_current_buffer->yy_ch_buf[number_to_move]; 1587 &YY_G(yy_current_buffer)->yy_ch_buf[number_to_move];
1178 1588
1179 while ( source > yy_current_buffer->yy_ch_buf ) 1589 while ( source > YY_G(yy_current_buffer)->yy_ch_buf )
1180 *--dest = *--source; 1590 *--dest = *--source;
1181 1591
1182 yy_cp += (int) (dest - source); 1592 yy_cp += (int) (dest - source);
1183 yy_bp += (int) (dest - source); 1593 yy_bp += (int) (dest - source);
1184 yy_current_buffer->yy_n_chars = 1594 YY_G(yy_current_buffer)->yy_n_chars =
1185 yy_n_chars = yy_current_buffer->yy_buf_size; 1595 YY_G(yy_n_chars) = YY_G(yy_current_buffer)->yy_buf_size;
1186 1596
1187 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1597 if ( yy_cp < YY_G(yy_current_buffer)->yy_ch_buf + 2 )
1188 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1598 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1189 } 1599 }
1190 1600
1191 *--yy_cp = (char) c; 1601 *--yy_cp = (char) c;
1192 1602
1603/* %% [18.0] update yylineno here */
1193 1604
1194 yytext_ptr = yy_bp; 1605 YY_G(yytext_ptr) = yy_bp;
1195 yy_hold_char = *yy_cp; 1606 YY_G(yy_hold_char) = *yy_cp;
1196 yy_c_buf_p = yy_cp; 1607 YY_G(yy_c_buf_p) = yy_cp;
1197 } 1608 }
1609/* %- */
1198 #endif/* ifndef YY_NO_UNPUT */ 1610 #endif/* ifndef YY_NO_UNPUT */
1611/* %* */
1199 1612
1200 1613
1614/* %- */
1615#ifndef YY_NO_INPUT
1201#ifdef __cplusplus 1616#ifdef __cplusplus
1202static int yyinput() 1617static int yyinput(YY_ONLY_ARG)
1618#else
1619#ifdef YY_USE_PROTOS
1620static int input(YY_ONLY_ARG)
1203#else 1621#else
1204static int input() 1622static int input(YY_ONLY_ARG)
1623 YY_DECL_LAST_ARG
1205#endif 1624#endif
1625#endif
1626/* %+ */
1627/* %* */
1206 { 1628 {
1207 int c; 1629 int c;
1208 1630
1209 *yy_c_buf_p = yy_hold_char; 1631 *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
1210 1632
1211 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1633 if ( *YY_G(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1212 { 1634 {
1213 /* yy_c_buf_p now points to the character we want to return. 1635 /* 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 1636 * 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. 1637 * valid NUL; if not, then we've hit the end of the buffer.
1216 */ 1638 */
1217 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1639 if ( YY_G(yy_c_buf_p) < &YY_G(yy_current_buffer)->yy_ch_buf[YY_G(yy_n_chars)] )
1218 /* This was really a NUL. */ 1640 /* This was really a NUL. */
1219 *yy_c_buf_p = '\0'; 1641 *YY_G(yy_c_buf_p) = '\0';
1220 1642
1221 else 1643 else
1222 { /* need more input */ 1644 { /* need more input */
1223 int offset = yy_c_buf_p - yytext_ptr; 1645 int offset = YY_G(yy_c_buf_p) - YY_G(yytext_ptr);
1224 ++yy_c_buf_p; 1646 ++YY_G(yy_c_buf_p);
1225 1647
1226 switch ( yy_get_next_buffer() ) 1648 switch ( yy_get_next_buffer( YY_CALL_ONLY_ARG ) )
1227 { 1649 {
1228 case EOB_ACT_LAST_MATCH: 1650 case EOB_ACT_LAST_MATCH:
1229 /* This happens because yy_g_n_b() 1651 /* This happens because yy_g_n_b()
1230 * sees that we've accumulated a 1652 * sees that we've accumulated a
1231 * token and flags that we need to 1653 * token and flags that we need to
1232 * try matching the token before 1654 * try matching the token before
@@ -1234,196 +1656,237 @@ static int input()
1234 * there's no matching to consider. 1656 * there's no matching to consider.
1235 * So convert the EOB_ACT_LAST_MATCH 1657 * So convert the EOB_ACT_LAST_MATCH
1236 * to EOB_ACT_END_OF_FILE. 1658 * to EOB_ACT_END_OF_FILE.
1237 */ 1659 */
1238 1660
1239 /* Reset buffer status. */ 1661 /* Reset buffer status. */
1240 yyrestart( yyin ); 1662 yyrestart( yyin YY_CALL_LAST_ARG);
1241 1663
1242 /* fall through */ 1664 /* fall through */
1243 1665
1244 case EOB_ACT_END_OF_FILE: 1666 case EOB_ACT_END_OF_FILE:
1245 { 1667 {
1246 if ( yywrap() ) 1668 if ( yywrap( YY_CALL_ONLY_ARG ) )
1247 return EOF; 1669 return EOF;
1248 1670
1249 if ( ! yy_did_buffer_switch_on_eof ) 1671 if ( ! YY_G(yy_did_buffer_switch_on_eof) )
1250 YY_NEW_FILE; 1672 YY_NEW_FILE;
1251#ifdef __cplusplus 1673#ifdef __cplusplus
1252 return yyinput(); 1674 return yyinput(YY_CALL_ONLY_ARG);
1253#else 1675#else
1254 return input(); 1676 return input(YY_CALL_ONLY_ARG);
1255#endif 1677#endif
1256 } 1678 }
1257 1679
1258 case EOB_ACT_CONTINUE_SCAN: 1680 case EOB_ACT_CONTINUE_SCAN:
1259 yy_c_buf_p = yytext_ptr + offset; 1681 YY_G(yy_c_buf_p) = YY_G(yytext_ptr) + offset;
1260 break; 1682 break;
1261 } 1683 }
1262 } 1684 }
1263 } 1685 }
1264 1686
1265 c = *(unsigned char *) yy_c_buf_p;/* cast for 8-bit char's */ 1687 c = *(unsigned char *) YY_G(yy_c_buf_p);/* cast for 8-bit char's */
1266 *yy_c_buf_p = '\0';/* preserve yytext */ 1688 *YY_G(yy_c_buf_p) = '\0';/* preserve yytext */
1267 yy_hold_char = *++yy_c_buf_p; 1689 YY_G(yy_hold_char) = *++YY_G(yy_c_buf_p);
1268 1690
1691/* %% [19.0] update BOL and yylineno */
1269 1692
1270 return c; 1693 return c;
1271 } 1694 }
1695/* %- */
1696 #endif/* ifndef YY_NO_INPUT */
1697/* %* */
1272 1698
1273 1699/* %- */
1274#ifdef YY_USE_PROTOS 1700#ifdef YY_USE_PROTOS
1275void yyrestart( FILE *input_file ) 1701void yyrestart( FILE *input_file YY_LAST_ARG)
1276#else 1702#else
1277void yyrestart( input_file ) 1703void yyrestart( input_file YY_LAST_ARG)
1278FILE *input_file; 1704FILE *input_file;
1705YY_DECL_LAST_ARG
1279#endif 1706#endif
1707/* %+ */
1708/* %* */
1280 { 1709 {
1281 if ( ! yy_current_buffer ) 1710 if ( ! YY_G(yy_current_buffer) )
1282 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1711 YY_G(yy_current_buffer) =
1712 yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG);
1283 1713
1284 yy_init_buffer( yy_current_buffer, input_file ); 1714 yy_init_buffer( YY_G(yy_current_buffer), input_file YY_CALL_LAST_ARG);
1285 yy_load_buffer_state(); 1715 yy_load_buffer_state( YY_CALL_ONLY_ARG );
1286 } 1716 }
1287 1717
1288 1718
1719/* %- */
1289#ifdef YY_USE_PROTOS 1720#ifdef YY_USE_PROTOS
1290void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1721void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer YY_LAST_ARG )
1291#else 1722#else
1292void yy_switch_to_buffer( new_buffer ) 1723void yy_switch_to_buffer( new_buffer YY_LAST_ARG )
1293YY_BUFFER_STATE new_buffer; 1724YY_BUFFER_STATE new_buffer;
1725YY_DECL_LAST_ARG
1294#endif 1726#endif
1727/* %+ */
1728/* %* */
1295 { 1729 {
1296 if ( yy_current_buffer == new_buffer ) 1730 if ( YY_G(yy_current_buffer) == new_buffer )
1297 return; 1731 return;
1298 1732
1299 if ( yy_current_buffer ) 1733 if ( YY_G(yy_current_buffer) )
1300 { 1734 {
1301 /* Flush out information for old buffer. */ 1735 /* Flush out information for old buffer. */
1302 *yy_c_buf_p = yy_hold_char; 1736 *YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
1303 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1737 YY_G(yy_current_buffer)->yy_buf_pos = YY_G(yy_c_buf_p);
1304 yy_current_buffer->yy_n_chars = yy_n_chars; 1738 YY_G(yy_current_buffer)->yy_n_chars = YY_G(yy_n_chars);
1305 } 1739 }
1306 1740
1307 yy_current_buffer = new_buffer; 1741 YY_G(yy_current_buffer) = new_buffer;
1308 yy_load_buffer_state(); 1742 yy_load_buffer_state( YY_CALL_ONLY_ARG );
1309 1743
1310 /* We don't actually know whether we did this switch during 1744 /* We don't actually know whether we did this switch during
1311 * EOF (yywrap()) processing, but the only time this flag 1745 * EOF (yywrap()) processing, but the only time this flag
1312 * is looked at is after yywrap() is called, so it's safe 1746 * is looked at is after yywrap() is called, so it's safe
1313 * to go ahead and always set it. 1747 * to go ahead and always set it.
1314 */ 1748 */
1315 yy_did_buffer_switch_on_eof = 1; 1749 YY_G(yy_did_buffer_switch_on_eof) = 1;
1316 } 1750 }
1317 1751
1318 1752
1753/* %- */
1319#ifdef YY_USE_PROTOS 1754#ifdef YY_USE_PROTOS
1320void yy_load_buffer_state( void ) 1755void yy_load_buffer_state( YY_ONLY_ARG )
1321#else 1756#else
1322void yy_load_buffer_state() 1757void yy_load_buffer_state(YY_ONLY_ARG )
1758YY_DECL_LAST_ARG
1323#endif 1759#endif
1760/* %+ */
1761/* %* */
1324 { 1762 {
1325 yy_n_chars = yy_current_buffer->yy_n_chars; 1763 YY_G(yy_n_chars) = YY_G(yy_current_buffer)->yy_n_chars;
1326 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1764 YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_G(yy_current_buffer)->yy_buf_pos;
1327 yyin = yy_current_buffer->yy_input_file; 1765 yyin = YY_G(yy_current_buffer)->yy_input_file;
1328 yy_hold_char = *yy_c_buf_p; 1766 YY_G(yy_hold_char) = *YY_G(yy_c_buf_p);
1329 } 1767 }
1330 1768
1331 1769
1770/* %- */
1332#ifdef YY_USE_PROTOS 1771#ifdef YY_USE_PROTOS
1333YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1772YY_BUFFER_STATE yy_create_buffer( FILE *file, int size YY_LAST_ARG)
1334#else 1773#else
1335YY_BUFFER_STATE yy_create_buffer( file, size ) 1774YY_BUFFER_STATE yy_create_buffer( file, size YY_LAST_ARG)
1336FILE *file; 1775FILE *file;
1337int size; 1776int size;
1777YY_DECL_LAST_ARG
1338#endif 1778#endif
1779/* %+ */
1780/* %* */
1339 { 1781 {
1340 YY_BUFFER_STATE b; 1782 YY_BUFFER_STATE b;
1341 1783
1342 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1784 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) YY_CALL_LAST_ARG );
1343 if ( ! b ) 1785 if ( ! b )
1344 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1786 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1345 1787
1346 b->yy_buf_size = size; 1788 b->yy_buf_size = size;
1347 1789
1348 /* yy_ch_buf has to be 2 characters longer than the size given because 1790 /* 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. 1791 * we need to put in 2 end-of-buffer characters.
1350 */ 1792 */
1351 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1793 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 YY_CALL_LAST_ARG );
1352 if ( ! b->yy_ch_buf ) 1794 if ( ! b->yy_ch_buf )
1353 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1795 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1354 1796
1355 b->yy_is_our_buffer = 1; 1797 b->yy_is_our_buffer = 1;
1356 1798
1357 yy_init_buffer( b, file ); 1799 yy_init_buffer( b, file YY_CALL_LAST_ARG);
1358 1800
1359 return b; 1801 return b;
1360 } 1802 }
1361 1803
1362 1804
1805/* %- */
1363#ifdef YY_USE_PROTOS 1806#ifdef YY_USE_PROTOS
1364void yy_delete_buffer( YY_BUFFER_STATE b ) 1807void yy_delete_buffer( YY_BUFFER_STATE b YY_LAST_ARG)
1365#else 1808#else
1366void yy_delete_buffer( b ) 1809void yy_delete_buffer( b YY_LAST_ARG)
1367YY_BUFFER_STATE b; 1810YY_BUFFER_STATE b;
1811YY_DECL_LAST_ARG
1368#endif 1812#endif
1813/* %+ */
1814/* %* */
1369 { 1815 {
1370 if ( ! b ) 1816 if ( ! b )
1371 return; 1817 return;
1372 1818
1373 if ( b == yy_current_buffer ) 1819 if ( b == YY_G(yy_current_buffer) )
1374 yy_current_buffer = (YY_BUFFER_STATE) 0; 1820 YY_G(yy_current_buffer) = (YY_BUFFER_STATE) 0;
1375 1821
1376 if ( b->yy_is_our_buffer ) 1822 if ( b->yy_is_our_buffer )
1377 yy_flex_free( (void *) b->yy_ch_buf ); 1823 yy_flex_free( (void *) b->yy_ch_buf YY_CALL_LAST_ARG );
1378 1824
1379 yy_flex_free( (void *) b ); 1825 yy_flex_free( (void *) b YY_CALL_LAST_ARG );
1380 } 1826 }
1381 1827
1382 1828
1829/* %- */
1830#ifndef YY_ALWAYS_INTERACTIVE
1831#ifndef YY_NEVER_INTERACTIVE
1832#ifdef __cplusplus
1833extern "C" int isatty YY_PROTO(( int ));
1834#else
1835extern int isatty YY_PROTO(( int ));
1836#endif /* __cplusplus */
1837#endif /* !YY_NEVER_INTERACTIVE */
1838#endif /* !YY_ALWAYS_INTERACTIVE */
1383 1839
1384#ifdef YY_USE_PROTOS 1840#ifdef YY_USE_PROTOS
1385void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1841void yy_init_buffer( YY_BUFFER_STATE b, FILE *file YY_LAST_ARG)
1386#else 1842#else
1387void yy_init_buffer( b, file ) 1843void yy_init_buffer( b, file YY_LAST_ARG)
1388YY_BUFFER_STATE b; 1844YY_BUFFER_STATE b;
1389FILE *file; 1845FILE *file;
1846YY_DECL_LAST_ARG
1390#endif 1847#endif
1391 1848
1849/* %+ */
1850/* %* */
1392 1851
1393 { 1852 {
1394 yy_flush_buffer( b ); 1853 int oerrno = errno;
1854
1855 yy_flush_buffer( b YY_CALL_LAST_ARG);
1395 1856
1396 b->yy_input_file = file; 1857 b->yy_input_file = file;
1397 b->yy_fill_buffer = 1; 1858 b->yy_fill_buffer = 1;
1398 1859
1860/* %- */
1399#if YY_ALWAYS_INTERACTIVE 1861#if YY_ALWAYS_INTERACTIVE
1400 b->yy_is_interactive = 1; 1862 b->yy_is_interactive = 1;
1401#else 1863#else
1402#if YY_NEVER_INTERACTIVE 1864#if YY_NEVER_INTERACTIVE
1403 b->yy_is_interactive = 0; 1865 b->yy_is_interactive = 0;
1404#else 1866#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; 1867 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1410#endif 1868#endif
1411
1412#endif
1413#endif 1869#endif
1870/* %+ */
1871/* %* */
1872 errno = oerrno;
1414 } 1873 }
1415 1874
1416 1875
1876/* %- */
1417#ifdef YY_USE_PROTOS 1877#ifdef YY_USE_PROTOS
1418void yy_flush_buffer( YY_BUFFER_STATE b ) 1878void yy_flush_buffer( YY_BUFFER_STATE b YY_LAST_ARG )
1419#else 1879#else
1420void yy_flush_buffer( b ) 1880void yy_flush_buffer( b YY_LAST_ARG )
1421YY_BUFFER_STATE b; 1881YY_BUFFER_STATE b;
1882YY_DECL_LAST_ARG
1422#endif 1883#endif
1423 1884
1885/* %+ */
1886/* %* */
1424 { 1887 {
1425 if ( ! b ) 1888 if ( ! b )
1426 return; 1889 return;
1427 1890
1428 b->yy_n_chars = 0; 1891 b->yy_n_chars = 0;
1429 1892
@@ -1436,35 +1899,38 @@ YY_BUFFER_STATE b;
1436 1899
1437 b->yy_buf_pos = &b->yy_ch_buf[0]; 1900 b->yy_buf_pos = &b->yy_ch_buf[0];
1438 1901
1439 b->yy_at_bol = 1; 1902 b->yy_at_bol = 1;
1440 b->yy_buffer_status = YY_BUFFER_NEW; 1903 b->yy_buffer_status = YY_BUFFER_NEW;
1441 1904
1442 if ( b == yy_current_buffer ) 1905 if ( b == YY_G(yy_current_buffer) )
1443 yy_load_buffer_state(); 1906 yy_load_buffer_state( YY_CALL_ONLY_ARG );
1444 } 1907 }
1908/* %* */
1445 1909
1446 1910
1447#ifndef YY_NO_SCAN_BUFFER 1911#ifndef YY_NO_SCAN_BUFFER
1912/* %- */
1448#ifdef YY_USE_PROTOS 1913#ifdef YY_USE_PROTOS
1449YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1914YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size YY_LAST_ARG )
1450#else 1915#else
1451YY_BUFFER_STATE yy_scan_buffer( base, size ) 1916YY_BUFFER_STATE yy_scan_buffer( base, size YY_LAST_ARG )
1452char *base; 1917char *base;
1453yy_size_t size; 1918yy_size_t size;
1919YY_DECL_LAST_ARG
1454#endif 1920#endif
1455 { 1921 {
1456 YY_BUFFER_STATE b; 1922 YY_BUFFER_STATE b;
1457 1923
1458 if ( size < 2 || 1924 if ( size < 2 ||
1459 base[size-2] != YY_END_OF_BUFFER_CHAR || 1925 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1460 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1926 base[size-1] != YY_END_OF_BUFFER_CHAR )
1461 /* They forgot to leave room for the EOB's. */ 1927 /* They forgot to leave room for the EOB's. */
1462 return 0; 1928 return 0;
1463 1929
1464 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1930 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) YY_CALL_LAST_ARG );
1465 if ( ! b ) 1931 if ( ! b )
1466 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1932 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1467 1933
1468 b->yy_buf_size = size - 2;/* "- 2" to take care of EOB's */ 1934 b->yy_buf_size = size - 2;/* "- 2" to take care of EOB's */
1469 b->yy_buf_pos = b->yy_ch_buf = base; 1935 b->yy_buf_pos = b->yy_ch_buf = base;
1470 b->yy_is_our_buffer = 0; 1936 b->yy_is_our_buffer = 0;
@@ -1472,211 +1938,502 @@ yy_size_t size;
1472 b->yy_n_chars = b->yy_buf_size; 1938 b->yy_n_chars = b->yy_buf_size;
1473 b->yy_is_interactive = 0; 1939 b->yy_is_interactive = 0;
1474 b->yy_at_bol = 1; 1940 b->yy_at_bol = 1;
1475 b->yy_fill_buffer = 0; 1941 b->yy_fill_buffer = 0;
1476 b->yy_buffer_status = YY_BUFFER_NEW; 1942 b->yy_buffer_status = YY_BUFFER_NEW;
1477 1943
1478 yy_switch_to_buffer( b ); 1944 yy_switch_to_buffer( b YY_CALL_LAST_ARG );
1479 1945
1480 return b; 1946 return b;
1481 } 1947 }
1948/* %* */
1482#endif 1949#endif
1483 1950
1484 1951
1485#ifndef YY_NO_SCAN_STRING 1952#ifndef YY_NO_SCAN_STRING
1953/* %- */
1486#ifdef YY_USE_PROTOS 1954#ifdef YY_USE_PROTOS
1487YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1955YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str YY_LAST_ARG )
1488#else 1956#else
1489YY_BUFFER_STATE yy_scan_string( yy_str ) 1957YY_BUFFER_STATE yy_scan_string( yy_str YY_LAST_ARG)
1490yyconst char *yy_str; 1958yyconst char *yy_str;
1959YY_DECL_LAST_ARG
1491#endif 1960#endif
1492 { 1961 {
1493 int len; 1962 int len;
1494 for ( len = 0; yy_str[len]; ++len ) 1963 for ( len = 0; yy_str[len]; ++len )
1495 ; 1964 ;
1496 1965
1497 return yy_scan_bytes( yy_str, len ); 1966 return yy_scan_bytes( yy_str, len YY_CALL_LAST_ARG);
1498 } 1967 }
1968/* %* */
1499#endif 1969#endif
1500 1970
1501 1971
1502#ifndef YY_NO_SCAN_BYTES 1972#ifndef YY_NO_SCAN_BYTES
1973/* %- */
1503#ifdef YY_USE_PROTOS 1974#ifdef YY_USE_PROTOS
1504YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1975YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len YY_LAST_ARG)
1505#else 1976#else
1506YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1977YY_BUFFER_STATE yy_scan_bytes( bytes, len YY_LAST_ARG)
1507yyconst char *bytes; 1978yyconst char *bytes;
1979YY_DECL_LAST_ARG
1508int len; 1980int len;
1509#endif 1981#endif
1510 { 1982 {
1511 YY_BUFFER_STATE b; 1983 YY_BUFFER_STATE b;
1512 char *buf; 1984 char *buf;
1513 yy_size_t n; 1985 yy_size_t n;
1514 int i; 1986 int i;
1515 1987
1516 /* Get memory for full buffer, including space for trailing EOB's. */ 1988 /* Get memory for full buffer, including space for trailing EOB's. */
1517 n = len + 2; 1989 n = len + 2;
1518 buf = (char *) yy_flex_alloc( n ); 1990 buf = (char *) yy_flex_alloc( n YY_CALL_LAST_ARG );
1519 if ( ! buf ) 1991 if ( ! buf )
1520 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1992 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1521 1993
1522 for ( i = 0; i < len; ++i ) 1994 for ( i = 0; i < len; ++i )
1523 buf[i] = bytes[i]; 1995 buf[i] = bytes[i];
1524 1996
1525 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1997 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1526 1998
1527 b = yy_scan_buffer( buf, n ); 1999 b = yy_scan_buffer( buf, n YY_CALL_LAST_ARG);
1528 if ( ! b ) 2000 if ( ! b )
1529 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 2001 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1530 2002
1531 /* It's okay to grow etc. this buffer, and we should throw it 2003 /* It's okay to grow etc. this buffer, and we should throw it
1532 * away when we're done. 2004 * away when we're done.
1533 */ 2005 */
1534 b->yy_is_our_buffer = 1; 2006 b->yy_is_our_buffer = 1;
1535 2007
1536 return b; 2008 return b;
1537 } 2009 }
2010/* %* */
1538#endif 2011#endif
1539 2012
1540 2013
1541#ifndef YY_NO_PUSH_STATE 2014#ifndef YY_NO_PUSH_STATE
2015/* %- */
1542#ifdef YY_USE_PROTOS 2016#ifdef YY_USE_PROTOS
1543static void yy_push_state( int new_state ) 2017static void yy_push_state( int new_state YY_LAST_ARG)
1544#else 2018#else
1545static void yy_push_state( new_state ) 2019static void yy_push_state( new_state YY_LAST_ARG)
1546int new_state; 2020int new_state;
2021YY_DECL_LAST_ARG
1547#endif 2022#endif
2023/* %+ */
2024/* %* */
1548 { 2025 {
1549 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 2026 if ( YY_G(yy_start_stack_ptr) >= YY_G(yy_start_stack_depth) )
1550 { 2027 {
1551 yy_size_t new_size; 2028 yy_size_t new_size;
1552 2029
1553 yy_start_stack_depth += YY_START_STACK_INCR; 2030 YY_G(yy_start_stack_depth) += YY_START_STACK_INCR;
1554 new_size = yy_start_stack_depth * sizeof( int ); 2031 new_size = YY_G(yy_start_stack_depth) * sizeof( int );
1555 2032
1556 if ( ! yy_start_stack ) 2033 if ( ! YY_G(yy_start_stack) )
1557 yy_start_stack = (int *) yy_flex_alloc( new_size ); 2034 YY_G(yy_start_stack) = (int *) yy_flex_alloc( new_size YY_CALL_LAST_ARG );
1558 2035
1559 else 2036 else
1560 yy_start_stack = (int *) yy_flex_realloc( 2037 YY_G(yy_start_stack) = (int *) yy_flex_realloc(
1561 (void *) yy_start_stack, new_size ); 2038 (void *) YY_G(yy_start_stack), new_size YY_CALL_LAST_ARG );
1562 2039
1563 if ( ! yy_start_stack ) 2040 if ( ! YY_G(yy_start_stack) )
1564 YY_FATAL_ERROR( 2041 YY_FATAL_ERROR(
1565 "out of memory expanding start-condition stack" ); 2042 "out of memory expanding start-condition stack" );
1566 } 2043 }
1567 2044
1568 yy_start_stack[yy_start_stack_ptr++] = YY_START; 2045 YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)++] = YY_START;
1569 2046
1570 BEGIN(new_state); 2047 BEGIN(new_state);
1571 } 2048 }
1572#endif 2049#endif
1573 2050
1574 2051
1575#ifndef YY_NO_POP_STATE 2052#ifndef YY_NO_POP_STATE
1576static void yy_pop_state() 2053/* %- */
2054#ifdef YY_USE_PROTOS
2055static void yy_pop_state( YY_ONLY_ARG )
2056#else
2057static void yy_pop_state( YY_ONLY_ARG )
2058YY_DECL_LAST_ARG
2059#endif
2060/* %+ */
2061/* %* */
1577 { 2062 {
1578 if ( --yy_start_stack_ptr < 0 ) 2063 if ( --YY_G(yy_start_stack_ptr) < 0 )
1579 YY_FATAL_ERROR( "start-condition stack underflow" ); 2064 YY_FATAL_ERROR( "start-condition stack underflow" );
1580 2065
1581 BEGIN(yy_start_stack[yy_start_stack_ptr]); 2066 BEGIN(YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr)]);
1582 } 2067 }
1583#endif 2068#endif
1584 2069
1585 2070
1586#ifndef YY_NO_TOP_STATE 2071#ifndef YY_NO_TOP_STATE
1587static int yy_top_state() 2072/* %- */
2073#ifdef YY_USE_PROTOS
2074static int yy_top_state( YY_ONLY_ARG )
2075#else
2076static int yy_top_state( YY_ONLY_ARG )
2077YY_DECL_LAST_ARG
2078#endif
2079/* %+ */
2080/* %* */
1588 { 2081 {
1589 return yy_start_stack[yy_start_stack_ptr - 1]; 2082 return YY_G(yy_start_stack)[YY_G(yy_start_stack_ptr) - 1];
1590 } 2083 }
1591#endif 2084#endif
1592 2085
1593#ifndef YY_EXIT_FAILURE 2086#ifndef YY_EXIT_FAILURE
1594#define YY_EXIT_FAILURE 2 2087#define YY_EXIT_FAILURE 2
1595#endif 2088#endif
1596 2089
1597#ifdef YY_USE_PROTOS 2090/* %- */
1598static void yy_fatal_error( yyconst char msg[] ) 2091static void yy_fatal_error( yyconst char msg[] )
1599#else
1600static void yy_fatal_error( msg )
1601char msg[];
1602#endif
1603 { 2092 {
1604 (void) fprintf( stderr, "%s\n", msg ); 2093 (void) fprintf( stderr, "%s\n", msg );
1605 exit( YY_EXIT_FAILURE ); 2094 exit( YY_EXIT_FAILURE );
1606 } 2095 }
1607 2096
2097/* %+ */
2098/* %* */
1608 2099
1609 2100
1610/* Redefine yyless() so it works in section 3 code. */ 2101/* Redefine yyless() so it works in section 3 code. */
1611 2102
1612#undef yyless 2103#undef yyless
1613#define yyless(n) \ 2104#define yyless(n) \
1614 do \ 2105 do \
1615 { \ 2106 { \
1616 /* Undo effects of setting up yytext. */ \ 2107 /* Undo effects of setting up yytext. */ \
1617 yytext[yyleng] = yy_hold_char; \ 2108 yytext[yyleng] = YY_G(yy_hold_char); \
1618 yy_c_buf_p = yytext + n; \ 2109 YY_G(yy_c_buf_p) = yytext + n; \
1619 yy_hold_char = *yy_c_buf_p; \ 2110 YY_G(yy_hold_char) = *YY_G(yy_c_buf_p); \
1620 *yy_c_buf_p = '\0'; \ 2111 *YY_G(yy_c_buf_p) = '\0'; \
1621 yyleng = n; \ 2112 yyleng = n; \
1622 } \ 2113 } \
1623 while ( 0 ) 2114 while ( 0 )
1624 2115
1625 2116
2117
2118#ifdef YY_REENTRANT
2119
2120/* Accessor methods (get/set functions) to struct members. */
2121
2122#ifndef YY_NO_GET_EXTRA
2123#ifdef YY_USE_PROTOS
2124YY_EXTRA_TYPE yyget_extra( YY_ONLY_ARG )
2125#else
2126YY_EXTRA_TYPE yyget_extra( YY_ONLY_ARG )
2127 YY_DECL_LAST_ARG
2128#endif
2129{
2130 return yyextra;
2131}
2132#endif /* !YY_NO_GET_EXTRA */
2133
2134#ifndef YY_NO_GET_LINENO
2135# ifdef YY_USE_PROTOS
2136int yyget_lineno( YY_ONLY_ARG )
2137# else
2138int yyget_lineno( YY_ONLY_ARG )
2139 YY_DECL_LAST_ARG
2140# endif
2141{
2142 return yylineno;
2143}
2144#endif /* !YY_NO_GET_LINENO */
2145
2146#ifndef YY_NO_GET_IN
2147#ifdef YY_USE_PROTOS
2148FILE *yyget_in( YY_ONLY_ARG )
2149#else
2150FILE *yyget_in( YY_ONLY_ARG )
2151 YY_DECL_LAST_ARG
2152#endif
2153{
2154 return yyin;
2155}
2156#endif /* !YY_NO_GET_IN */
2157
2158#ifndef YY_NO_GET_OUT
2159#ifdef YY_USE_PROTOS
2160FILE *yyget_out( YY_ONLY_ARG )
2161#else
2162FILE *yyget_out( YY_ONLY_ARG )
2163 YY_DECL_LAST_ARG
2164#endif
2165{
2166 return yyout;
2167}
2168#endif /* !YY_NO_GET_OUT */
2169
2170#ifndef YY_NO_GET_LENG
2171#ifdef YY_USE_PROTOS
2172int yyget_leng( YY_ONLY_ARG )
2173#else
2174int yyget_leng( YY_ONLY_ARG )
2175 YY_DECL_LAST_ARG
2176#endif
2177{
2178 return yyleng;
2179}
2180#endif /* !YY_NO_GET_LENG */
2181
2182#ifndef YY_NO_GET_TEXT
2183#ifdef YY_USE_PROTOS
2184char *yyget_text( YY_ONLY_ARG )
2185#else
2186char *yyget_text( YY_ONLY_ARG )
2187 YY_DECL_LAST_ARG
2188#endif
2189{
2190 return yytext;
2191}
2192#endif /* !YY_NO_GET_TEXT */
2193
2194#ifndef YY_NO_SET_EXTRA
2195#ifdef YY_USE_PROTOS
2196void yyset_extra( YY_EXTRA_TYPE user_defined YY_LAST_ARG )
2197#else
2198void yyset_extra( user_defined YY_LAST_ARG )
2199 YY_EXTRA_TYPE user_defined;
2200 YY_DECL_LAST_ARG
2201#endif
2202{
2203 yyextra = user_defined ;
2204}
2205#endif /* !YY_NO_SET_EXTRA */
2206
2207#ifndef YY_NO_SET_LINENO
2208# ifdef YY_USE_PROTOS
2209void yyset_lineno( int line_number YY_LAST_ARG )
2210# else
2211void yyset_lineno( line_number YY_LAST_ARG )
2212 int line_number;
2213 YY_DECL_LAST_ARG
2214# endif
2215{
2216 yylineno = line_number;
2217}
2218#endif /* !YY_NO_SET_LINENO */
2219
2220
2221#ifndef YY_NO_SET_IN
2222#ifdef YY_USE_PROTOS
2223void yyset_in( FILE * in_str YY_LAST_ARG )
2224#else
2225void yyset_in( in_str YY_LAST_ARG )
2226 FILE * in_str;
2227 YY_DECL_LAST_ARG
2228#endif
2229{
2230 yyin = in_str ;
2231}
2232#endif /* !YY_NO_SET_IN */
2233
2234#ifndef YY_NO_SET_OUT
2235#ifdef YY_USE_PROTOS
2236void yyset_out( FILE * out_str YY_LAST_ARG )
2237#else
2238void yyset_out( out_str YY_LAST_ARG )
2239 FILE * out_str;
2240 YY_DECL_LAST_ARG
2241#endif
2242{
2243 yyout = out_str ;
2244}
2245#endif /* !YY_NO_SET_OUT */
2246
2247/* Accessor methods for yylval and yylloc */
2248
2249#ifdef YY_REENTRANT_BISON_PURE
2250#ifndef YY_NO_GET_LVAL
2251#ifdef YY_USE_PROTOS
2252YYSTYPE * yyget_lval( YY_ONLY_ARG )
2253#else
2254YYSTYPE * yyget_lval( YY_ONLY_ARG )
2255 YY_DECL_LAST_ARG
2256#endif
2257{
2258 return yylval;
2259}
2260#endif /* !YY_NO_GET_LVAL */
2261
2262#ifndef YY_NO_SET_LVAL
2263#ifdef YY_USE_PROTOS
2264void yyset_lval( YYSTYPE * yylvalp YY_LAST_ARG )
2265#else
2266void yyset_lval( yylvalp YY_LAST_ARG )
2267 YYSTYPE * yylvalp;
2268 YY_DECL_LAST_ARG
2269#endif
2270{
2271 yylval = yylvalp;
2272}
2273#endif /* !YY_NO_SET_LVAL */
2274
2275#ifdef YYLTYPE
2276#ifndef YY_NO_GET_LLOC
2277#ifdef YY_USE_PROTOS
2278YYLTYPE *yyget_lloc( YY_ONLY_ARG )
2279#else
2280YYLTYPE *yyget_lloc( YY_ONLY_ARG )
2281 YY_DECL_LAST_ARG
2282#endif
2283{
2284 return yylloc;
2285}
2286#endif /* !YY_NO_GET_LLOC */
2287
2288#ifndef YY_NO_SET_LLOC
2289#ifdef YY_USE_PROTOS
2290void yyset_lloc( YYLTYPE * yyllocp YY_LAST_ARG )
2291#else
2292void yyset_lloc( yyllocp YY_LAST_ARG )
2293 YYLTYPE * yyllocp;
2294 YY_DECL_LAST_ARG
2295#endif
2296{
2297 yylloc = yyllocp;
2298}
2299#endif /* !YY_NO_SET_LLOC */
2300
2301#endif /* YYLTYPE */
2302#endif /* YY_REENTRANT_BISON_PURE */
2303
2304
2305#ifdef YY_USE_PROTOS
2306static int yy_init_globals( yyscan_t yy_globals)
2307#else
2308static int yy_init_globals( yy_globals )
2309 yyscan_t yy_globals;
2310#endif
2311 {
2312 /* Initialization is the same as for the non-reentrant scanner.
2313 This function is called once per scanner lifetime. */
2314
2315 /* We do not touch yylineno unless the option is enabled. */
2316#ifdef YY_USE_LINENO
2317 yylineno = 1;
2318#endif
2319 YY_G(yy_current_buffer) = 0;
2320 YY_G(yy_c_buf_p) = (char *) 0;
2321 YY_G(yy_init) = 1;
2322 YY_G(yy_start) = 0;
2323 YY_G(yy_start_stack_ptr) = 0;
2324 YY_G(yy_start_stack_depth) = 0;
2325 YY_G(yy_start_stack) = (int *) 0;
2326
2327/* Defined in main.c */
2328#ifdef YY_STDINIT
2329 yyin = stdin;
2330 yyout = stdout;
2331#else
2332 yyin = (FILE *) 0;
2333 yyout = (FILE *) 0;
2334#endif
2335 return 0;
2336 }
2337
2338/* User-visible API */
2339#ifdef YY_USE_PROTOS
2340int yylex_init( yyscan_t* ptr_yy_globals)
2341#else
2342int yylex_init( ptr_yy_globals )
2343 yyscan_t* ptr_yy_globals;
2344#endif
2345 {
2346 *ptr_yy_globals = (yyscan_t) yy_flex_alloc ( sizeof( struct yy_globals_t ), NULL );
2347 yy_init_globals ( *ptr_yy_globals );
2348 return 0;
2349 }
2350
2351#ifdef YY_USE_PROTOS
2352int yylex_destroy( yyscan_t yy_globals )
2353#else
2354int yylex_destroy( yy_globals )
2355 yyscan_t yy_globals;
2356#endif
2357 {
2358 if( yy_globals )
2359 {
2360
2361 /* Destroy the current (main) buffer. */
2362 yy_delete_buffer( YY_G(yy_current_buffer) YY_CALL_LAST_ARG );
2363 YY_G(yy_current_buffer) = NULL;
2364
2365 /* Destroy the start condition stack. */
2366 if( YY_G(yy_start_stack) ) {
2367 yy_flex_free( YY_G(yy_start_stack) YY_CALL_LAST_ARG );
2368 YY_G(yy_start_stack) = NULL;
2369 }
2370
2371 /* Destroy the main struct. */
2372 yy_flex_free ( yy_globals YY_CALL_LAST_ARG );
2373 }
2374 return 0;
2375 }
2376
2377#endif /* End YY_REENTRANT */
2378
1626/* Internal utility routines. */ 2379/* Internal utility routines. */
1627 2380
1628#ifndef yytext_ptr 2381#ifndef yytext_ptr
1629#ifdef YY_USE_PROTOS 2382#ifdef YY_USE_PROTOS
1630static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 2383static void yy_flex_strncpy( char *s1, yyconst char *s2, int n YY_LAST_ARG)
1631#else 2384#else
1632static void yy_flex_strncpy( s1, s2, n ) 2385static void yy_flex_strncpy( s1, s2, n YY_LAST_ARG)
1633char *s1; 2386char *s1;
1634yyconst char *s2; 2387yyconst char *s2;
1635int n; 2388int n;
2389YY_DECL_LAST_ARG
1636#endif 2390#endif
1637 { 2391 {
1638 register int i; 2392 register int i;
1639 for ( i = 0; i < n; ++i ) 2393 for ( i = 0; i < n; ++i )
1640 s1[i] = s2[i]; 2394 s1[i] = s2[i];
1641 } 2395 }
1642#endif 2396#endif
1643 2397
1644#ifdef YY_NEED_STRLEN 2398#ifdef YY_NEED_STRLEN
1645#ifdef YY_USE_PROTOS 2399#ifdef YY_USE_PROTOS
1646static int yy_flex_strlen( yyconst char *s ) 2400static int yy_flex_strlen( yyconst char *s YY_LAST_ARG)
1647#else 2401#else
1648static int yy_flex_strlen( s ) 2402static int yy_flex_strlen( s YY_LAST_ARG)
1649yyconst char *s; 2403yyconst char *s;
2404YY_DECL_LAST_ARG
1650#endif 2405#endif
1651 { 2406 {
1652 register int n; 2407 register int n;
1653 for ( n = 0; s[n]; ++n ) 2408 for ( n = 0; s[n]; ++n )
1654 ; 2409 ;
1655 2410
1656 return n; 2411 return n;
1657 } 2412 }
1658#endif 2413#endif
1659 2414
1660 2415
1661#ifdef YY_USE_PROTOS 2416#ifdef YY_USE_PROTOS
1662static void *yy_flex_alloc( yy_size_t size ) 2417static void *yy_flex_alloc( yy_size_t size YY_LAST_ARG )
1663#else 2418#else
1664static void *yy_flex_alloc( size ) 2419static void *yy_flex_alloc( size YY_LAST_ARG )
1665yy_size_t size; 2420yy_size_t size;
2421YY_DECL_LAST_ARG
1666#endif 2422#endif
1667 { 2423 {
1668 return (void *) malloc( size ); 2424 return (void *) malloc( size );
1669 } 2425 }
1670 2426
1671#ifdef YY_USE_PROTOS 2427#ifdef YY_USE_PROTOS
1672static void *yy_flex_realloc( void *ptr, yy_size_t size ) 2428static void *yy_flex_realloc( void *ptr, yy_size_t size YY_LAST_ARG )
1673#else 2429#else
1674static void *yy_flex_realloc( ptr, size ) 2430static void *yy_flex_realloc( ptr, size YY_LAST_ARG )
1675void *ptr; 2431void *ptr;
1676yy_size_t size; 2432yy_size_t size;
2433YY_DECL_LAST_ARG
1677#endif 2434#endif
1678 { 2435 {
1679 /* The cast to (char *) in the following accommodates both 2436 /* The cast to (char *) in the following accommodates both
1680 * implementations that use char* generic pointers, and those 2437 * implementations that use char* generic pointers, and those
1681 * that use void* generic pointers. It works with the latter 2438 * that use void* generic pointers. It works with the latter
1682 * because both ANSI C and C++ allow castless assignment from 2439 * because both ANSI C and C++ allow castless assignment from
@@ -1684,30 +2441,45 @@ yy_size_t size;
1684 * as though doing an assignment. 2441 * as though doing an assignment.
1685 */ 2442 */
1686 return (void *) realloc( (char *) ptr, size ); 2443 return (void *) realloc( (char *) ptr, size );
1687 } 2444 }
1688 2445
1689#ifdef YY_USE_PROTOS 2446#ifdef YY_USE_PROTOS
1690static void yy_flex_free( void *ptr ) 2447static void yy_flex_free( void *ptr YY_LAST_ARG )
1691#else 2448#else
1692static void yy_flex_free( ptr ) 2449static void yy_flex_free( ptr YY_LAST_ARG )
1693void *ptr; 2450void *ptr;
2451YY_DECL_LAST_ARG
1694#endif 2452#endif
1695 { 2453 {
1696 free( ptr ); 2454 free( (char *) ptr );/* see yy_flex_realloc() for (char *) cast */
1697 } 2455 }
1698 2456
1699#if YY_MAIN 2457#if YY_MAIN
1700int main() 2458int main()
1701 { 2459 {
2460
2461#ifdef YY_REENTRANT
2462 yyscan_t lexer;
2463 yylex_init(&lexer);
2464 yylex( lexer );
2465 yylex_destroy( lexer);
2466
2467#else
1702 yylex(); 2468 yylex();
2469#endif
2470
1703 return 0; 2471 return 0;
1704 } 2472 }
1705#endif 2473#endif
1706#line 107 "icalsslexer.l" 2474/* %e */
2475#endif /* !ssIN_HEADER */
2476#line 111 "icalsslexer.l"
2477#ifndef ssIN_HEADER
1707 2478
1708 2479
1709int sswrap() 2480int yywrap(yyscan_t yy_globals)
1710{ 2481{
1711 return 1; 2482 return 1;
1712} 2483}
1713 2484
2485#endif /* !ssIN_HEADER */