Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Annotate
Revision Log

activation-context-query-lexer.c @ 18311

Visit:

Revision 18311, 43.3 KB checked in by ghudson, 22 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r18310, which included commits to RCS files with non-trunk default branches.

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/bonobo-activation/server/activation-context-query-lexer.c @ 18311

Download in other formats: