~drizzle-trunk/drizzle/development : contents of storage/innobase/pars/pars0lex.l at revision 873.2.35

~drizzle-trunk/drizzle/development : (revision 873.2.35)

/******************************************************
SQL parser lexical analyzer: input file for the GNU Flex lexer generator

(c) 1997 Innobase Oy

Created 12/14/1997 Heikki Tuuri
Published under the GPL version 2

The InnoDB parser is frozen because MySQL takes care of SQL parsing.
Therefore we normally keep the InnoDB parser C files as they are, and do
not automatically generate them from pars0grm.y and pars0lex.l.

How to make the InnoDB parser and lexer C files:

1. Run ./make_flex.sh to generate lexer files.

2. Run ./make_bison.sh to generate parser files.

These instructions seem to work at least with bison-1.875d and flex-2.5.31 on
Linux.
*******************************************************/

%option nostdinit
%option 8bit
%option warn
%option pointer
%option never-interactive
%option nodefault
%option noinput
%option nounput
%option noyywrap
%option noyy_scan_buffer
%option noyy_scan_bytes
%option noyy_scan_string
%option nounistd

%{
#define YYSTYPE que_node_t*

#include "univ.i"
#include "pars0pars.h"
#include "pars0grm.h"
#include "pars0sym.h"
#include "mem0mem.h"
#include "os0proc.h"

#define malloc(A)	ut_malloc(A)
#define free(A)		ut_free(A)
#define realloc(P, A)	ut_realloc(P, A)
#define exit(A) 	ut_error

#define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size)

/* String buffer for removing quotes */
static ulint	stringbuf_len_alloc = 0; /* Allocated length */
static ulint	stringbuf_len = 0; /* Current length */
static char*	stringbuf; /* Start of buffer */
/* Appends a string to the buffer. */
static
void
string_append(
/*==========*/
	const char*	str,	/* in: string to be appended */
	ulint		len)	/* in: length of the string */
{
	if (stringbuf == NULL) {
		stringbuf = malloc(1);
		stringbuf_len_alloc = 1;
	}

	if (stringbuf_len + len > stringbuf_len_alloc) {
		while (stringbuf_len + len > stringbuf_len_alloc) {
			stringbuf_len_alloc <<= 1;
		}
		stringbuf = realloc(stringbuf, stringbuf_len_alloc);
	}

	memcpy(stringbuf + stringbuf_len, str, len);
	stringbuf_len += len;
}

%}

DIGIT	[0-9]
ID	[a-z_A-Z][a-z_A-Z0-9]*
BOUND_LIT	\:[a-z_A-Z0-9]+
BOUND_ID	\$[a-z_A-Z0-9]+

%x comment
%x quoted
%x id
%%

{DIGIT}+	{
			yylval = sym_tab_add_int_lit(pars_sym_tab_global,
								atoi(yytext));
			return(PARS_INT_LIT);
}

{DIGIT}+"."{DIGIT}* {
			ut_error;	/* not implemented */

			return(PARS_FLOAT_LIT);
}

{BOUND_LIT}	{
			ulint	type;

			yylval = sym_tab_add_bound_lit(pars_sym_tab_global,
				yytext + 1, &type);

			return((int) type);
}

{BOUND_ID}	{
			yylval = sym_tab_add_bound_id(pars_sym_tab_global,
				yytext + 1);

			return(PARS_ID_TOKEN);
}

"'"		{
/* Quoted character string literals are handled in an explicit
start state 'quoted'.  This state is entered and the buffer for
the scanned string is emptied upon encountering a starting quote.

In the state 'quoted', only two actions are possible (defined below). */
			BEGIN(quoted);
			stringbuf_len = 0;
}
<quoted>[^\']+	{
			/* Got a sequence of characters other than "'":
			append to string buffer */
			string_append(yytext, yyleng);
}
<quoted>"'"+	{
			/* Got a sequence of "'" characters:
			append half of them to string buffer,
			as "''" represents a single "'".
			We apply truncating division,
			so that "'''" will result in "'". */

			string_append(yytext, yyleng / 2);

			/* If we got an odd number of quotes, then the
			last quote we got is the terminating quote.
			At the end of the string, we return to the
			initial start state and report the scanned
			string literal. */

			if (yyleng % 2) {
				BEGIN(INITIAL);
				yylval = sym_tab_add_str_lit(
					pars_sym_tab_global,
					(byte*) stringbuf, stringbuf_len);
				return(PARS_STR_LIT);
			}
}

\"		{
/* Quoted identifiers are handled in an explicit start state 'id'.
This state is entered and the buffer for the scanned string is emptied
upon encountering a starting quote.

In the state 'id', only two actions are possible (defined below). */
			BEGIN(id);
			stringbuf_len = 0;
}
<id>[^\"]+	{
			/* Got a sequence of characters other than '"':
			append to string buffer */
			string_append(yytext, yyleng);
}
<id>\"+	{
			/* Got a sequence of '"' characters:
			append half of them to string buffer,
			as '""' represents a single '"'.
			We apply truncating division,
			so that '"""' will result in '"'. */

			string_append(yytext, yyleng / 2);

			/* If we got an odd number of quotes, then the
			last quote we got is the terminating quote.
			At the end of the string, we return to the
			initial start state and report the scanned
			identifier. */

			if (yyleng % 2) {
				BEGIN(INITIAL);
				yylval = sym_tab_add_id(
					pars_sym_tab_global,
					(byte*) stringbuf, stringbuf_len);

				return(PARS_ID_TOKEN);
			}
}

"NULL"		{
			yylval = sym_tab_add_null_lit(pars_sym_tab_global);

			return(PARS_NULL_LIT);
}

"SQL"		{
			/* Implicit cursor name */
			yylval = sym_tab_add_str_lit(pars_sym_tab_global,
							(byte*) yytext, yyleng);
			return(PARS_SQL_TOKEN);
}

"AND"		{
			return(PARS_AND_TOKEN);
}

"OR"		{
			return(PARS_OR_TOKEN);
}

"NOT"		{
			return(PARS_NOT_TOKEN);
}

"PROCEDURE"	{
			return(PARS_PROCEDURE_TOKEN);
}

"IN"		{
			return(PARS_IN_TOKEN);
}

"OUT"		{
			return(PARS_OUT_TOKEN);
}

"BINARY"	{
	 		return(PARS_BINARY_TOKEN);
}

"BLOB"		{
	 		return(PARS_BLOB_TOKEN);
}

"INT"		{
	 		return(PARS_INT_TOKEN);
}

"INTEGER"	{
	 		return(PARS_INT_TOKEN);
}

"FLOAT"		{
	 		return(PARS_FLOAT_TOKEN);
}

"CHAR"		{
	 		return(PARS_CHAR_TOKEN);
}

"IS"		{
			return(PARS_IS_TOKEN);
}

"BEGIN"		{
			return(PARS_BEGIN_TOKEN);
}

"END"		{
			return(PARS_END_TOKEN);
}

"IF"		{
			return(PARS_IF_TOKEN);
}

"THEN"		{
			return(PARS_THEN_TOKEN);
}

"ELSE"		{
			return(PARS_ELSE_TOKEN);
}

"ELSIF"		{
			return(PARS_ELSIF_TOKEN);
}

"LOOP"		{
			return(PARS_LOOP_TOKEN);
}

"WHILE"		{
			return(PARS_WHILE_TOKEN);
}

"RETURN"	{
			return(PARS_RETURN_TOKEN);
}

"SELECT"	{
			return(PARS_SELECT_TOKEN);
}

"SUM"		{
			return(PARS_SUM_TOKEN);
}

"COUNT"		{
			return(PARS_COUNT_TOKEN);
}

"DISTINCT"	{
			return(PARS_DISTINCT_TOKEN);
}

"FROM"		{
			return(PARS_FROM_TOKEN);
}

"WHERE"		{
			return(PARS_WHERE_TOKEN);
}

"FOR"		{
			return(PARS_FOR_TOKEN);
}

"READ"		{
			return(PARS_READ_TOKEN);
}

"ORDER"		{
			return(PARS_ORDER_TOKEN);
}

"BY"		{
			return(PARS_BY_TOKEN);
}

"ASC"		{
			return(PARS_ASC_TOKEN);
}

"DESC"		{
			return(PARS_DESC_TOKEN);
}

"INSERT"	{
			return(PARS_INSERT_TOKEN);
}

"INTO"		{
			return(PARS_INTO_TOKEN);
}

"VALUES"	{
			return(PARS_VALUES_TOKEN);
}

"UPDATE"	{
			return(PARS_UPDATE_TOKEN);
}

"SET"		{
			return(PARS_SET_TOKEN);
}

"DELETE"	{
			return(PARS_DELETE_TOKEN);
}

"CURRENT"	{
			return(PARS_CURRENT_TOKEN);
}

"OF"		{
			return(PARS_OF_TOKEN);
}

"CREATE"	{
			return(PARS_CREATE_TOKEN);
}

"TABLE"		{
			return(PARS_TABLE_TOKEN);
}

"INDEX"		{
	 		return(PARS_INDEX_TOKEN);
}

"UNIQUE"	{
	 		return(PARS_UNIQUE_TOKEN);
}

"CLUSTERED"	{
	 		return(PARS_CLUSTERED_TOKEN);
}

"DOES_NOT_FIT_IN_MEMORY"	{
			return(PARS_DOES_NOT_FIT_IN_MEM_TOKEN);
}

"ON"		{
	 		return(PARS_ON_TOKEN);
}

"DECLARE"	{
			return(PARS_DECLARE_TOKEN);
}

"CURSOR"	{
			return(PARS_CURSOR_TOKEN);
}

"OPEN"	{
			return(PARS_OPEN_TOKEN);
}

"FETCH"	{
			return(PARS_FETCH_TOKEN);
}

"CLOSE"	{
			return(PARS_CLOSE_TOKEN);
}

"NOTFOUND"	{
			return(PARS_NOTFOUND_TOKEN);
}

"TO_CHAR"	{
			return(PARS_TO_CHAR_TOKEN);
}

"TO_NUMBER"	{
			return(PARS_TO_NUMBER_TOKEN);
}

"TO_BINARY"	{
			return(PARS_TO_BINARY_TOKEN);
}

"BINARY_TO_NUMBER" {
			return(PARS_BINARY_TO_NUMBER_TOKEN);
}

"SUBSTR"	{
			return(PARS_SUBSTR_TOKEN);
}

"REPLSTR"	{
			return(PARS_REPLSTR_TOKEN);
}

"CONCAT"	{
			return(PARS_CONCAT_TOKEN);
}

"INSTR"		{
			return(PARS_INSTR_TOKEN);
}

"LENGTH"	{
			return(PARS_LENGTH_TOKEN);
}

"SYSDATE"	{
			return(PARS_SYSDATE_TOKEN);
}

"PRINTF"	{
			return(PARS_PRINTF_TOKEN);
}

"ASSERT"	{
			return(PARS_ASSERT_TOKEN);
}

"RND"		{
			return(PARS_RND_TOKEN);
}

"RND_STR"	{
			return(PARS_RND_STR_TOKEN);
}

"ROW_PRINTF"	{
			return(PARS_ROW_PRINTF_TOKEN);
}

"COMMIT"	{
			return(PARS_COMMIT_TOKEN);
}

"ROLLBACK"	{
			return(PARS_ROLLBACK_TOKEN);
}

"WORK"		{
			return(PARS_WORK_TOKEN);
}

"UNSIGNED"	{
			return(PARS_UNSIGNED_TOKEN);
}

"EXIT"		{
			return(PARS_EXIT_TOKEN);
}

"FUNCTION"	{
			return(PARS_FUNCTION_TOKEN);
}

"LOCK"	{
			return(PARS_LOCK_TOKEN);
}

"SHARE"	{
			return(PARS_SHARE_TOKEN);
}

"MODE"	{
			return(PARS_MODE_TOKEN);
}

{ID}		{
			yylval = sym_tab_add_id(pars_sym_tab_global,
							(byte*)yytext,
							ut_strlen(yytext));
			return(PARS_ID_TOKEN);
}

".."		{
			return(PARS_DDOT_TOKEN);
}

":="		{
			return(PARS_ASSIGN_TOKEN);
}

"<="		{
			return(PARS_LE_TOKEN);
}

">="		{
			return(PARS_GE_TOKEN);
}

"<>"		{
			return(PARS_NE_TOKEN);
}

"("		{

			return((int)(*yytext));
}

"="		{

			return((int)(*yytext));
}

">"		{

			return((int)(*yytext));
}

"<"		{

			return((int)(*yytext));
}

","		{

			return((int)(*yytext));
}

";"		{

			return((int)(*yytext));
}

")"		{

			return((int)(*yytext));
}

"+" 		{

			return((int)(*yytext));
}

"-"		{

			return((int)(*yytext));
}

"*"		{

			return((int)(*yytext));
}

"/"		{

			return((int)(*yytext));
}

"%"		{

			return((int)(*yytext));
}

"{"		{

			return((int)(*yytext));
}

"}"		{

			return((int)(*yytext));
}

"?"		{

			return((int)(*yytext));
}

"/*"			BEGIN(comment); /* eat up comment */

<comment>[^*]*
<comment>"*"+[^*/]*
<comment>"*"+"/"        BEGIN(INITIAL);

[ \t\n]+		/* eat up whitespace */


.		{
			fprintf(stderr,"Unrecognized character: %02x\n",
				*yytext);

			ut_error;

			return(0);
}

%%

641.1.2 by Monty Taylor Imported 1.0.1 with clean - with no changes.	1	/******************************************************
	2	SQL parser lexical analyzer: input file for the GNU Flex lexer generator
	3
	4	(c) 1997 Innobase Oy
	5
	6	Created 12/14/1997 Heikki Tuuri
	7	Published under the GPL version 2
	8
	9	The InnoDB parser is frozen because MySQL takes care of SQL parsing.
	10	Therefore we normally keep the InnoDB parser C files as they are, and do
	11	not automatically generate them from pars0grm.y and pars0lex.l.
	12
	13	How to make the InnoDB parser and lexer C files:
	14
	15	1. Run ./make_flex.sh to generate lexer files.
	16
	17	2. Run ./make_bison.sh to generate parser files.
	18
	19	These instructions seem to work at least with bison-1.875d and flex-2.5.31 on
	20	Linux.
	21	*******************************************************/
	22
	23	%option nostdinit
	24	%option 8bit
	25	%option warn
	26	%option pointer
	27	%option never-interactive
	28	%option nodefault
	29	%option noinput
	30	%option nounput
	31	%option noyywrap
	32	%option noyy_scan_buffer
	33	%option noyy_scan_bytes
	34	%option noyy_scan_string
	35	%option nounistd
	36
	37	%{
	38	#define YYSTYPE que_node_t*
	39
	40	#include "univ.i"
	41	#include "pars0pars.h"
	42	#include "pars0grm.h"
	43	#include "pars0sym.h"
	44	#include "mem0mem.h"
	45	#include "os0proc.h"
	46
	47	#define malloc(A) ut_malloc(A)
	48	#define free(A) ut_free(A)
	49	#define realloc(P, A) ut_realloc(P, A)
	50	#define exit(A) ut_error
	51
	52	#define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size)
	53
	54	/* String buffer for removing quotes */
	55	static ulint stringbuf_len_alloc = 0; /* Allocated length */
	56	static ulint stringbuf_len = 0; /* Current length */
	57	static char* stringbuf; /* Start of buffer */
	58	/* Appends a string to the buffer. */
	59	static
	60	void
	61	string_append(
	62	/==========/
	63	const char* str, /* in: string to be appended */
	64	ulint len) /* in: length of the string */
65	{
66	if (stringbuf == NULL) {
67	stringbuf = malloc(1);
68	stringbuf_len_alloc = 1;
69	}
70
71	if (stringbuf_len + len > stringbuf_len_alloc) {
72	while (stringbuf_len + len > stringbuf_len_alloc) {
73	stringbuf_len_alloc <<= 1;
74	}
75	stringbuf = realloc(stringbuf, stringbuf_len_alloc);
76	}
77
78	memcpy(stringbuf + stringbuf_len, str, len);
79	stringbuf_len += len;
80	}
81
82	%}
83
84	DIGIT [0-9]
85	ID [a-z_A-Z][a-z_A-Z0-9]*
86	BOUND_LIT \:[a-z_A-Z0-9]+
87	BOUND_ID \$[a-z_A-Z0-9]+
88
89	%x comment
90	%x quoted
91	%x id
92	%%
93
94	{DIGIT}+ {
95	yylval = sym_tab_add_int_lit(pars_sym_tab_global,
96	atoi(yytext));
97	return(PARS_INT_LIT);
98	}
99
100	{DIGIT}+"."{DIGIT}* {
101	ut_error; /* not implemented */
102
103	return(PARS_FLOAT_LIT);
104	}
105
106	{BOUND_LIT} {
107	ulint type;
108
109	yylval = sym_tab_add_bound_lit(pars_sym_tab_global,
110	yytext + 1, &type);
111
112	return((int) type);
113	}
114
115	{BOUND_ID} {
116	yylval = sym_tab_add_bound_id(pars_sym_tab_global,
117	yytext + 1);
118
119	return(PARS_ID_TOKEN);
120	}
121
122	"'" {
123	/* Quoted character string literals are handled in an explicit
124	start state 'quoted'. This state is entered and the buffer for
125	the scanned string is emptied upon encountering a starting quote.
126
127	In the state 'quoted', only two actions are possible (defined below). */
128	BEGIN(quoted);
129	stringbuf_len = 0;
130	}
131	<quoted>[^\']+ {
132	/* Got a sequence of characters other than "'":
133	append to string buffer */
134	string_append(yytext, yyleng);
135	}
136	<quoted>"'"+ {
137	/* Got a sequence of "'" characters:
138	append half of them to string buffer,
139	as "''" represents a single "'".
140	We apply truncating division,
141	so that "'''" will result in "'". */
142
143	string_append(yytext, yyleng / 2);
144
145	/* If we got an odd number of quotes, then the
146	last quote we got is the terminating quote.
147	At the end of the string, we return to the
148	initial start state and report the scanned
149	string literal. */
150
151	if (yyleng % 2) {
152	BEGIN(INITIAL);
153	yylval = sym_tab_add_str_lit(
154	pars_sym_tab_global,
155	(byte*) stringbuf, stringbuf_len);
156	return(PARS_STR_LIT);
157	}
158	}
159
160	\" {
161	/* Quoted identifiers are handled in an explicit start state 'id'.
162	This state is entered and the buffer for the scanned string is emptied
163	upon encountering a starting quote.
164
165	In the state 'id', only two actions are possible (defined below). */
166	BEGIN(id);
167	stringbuf_len = 0;
168	}
169	<id>[^\"]+ {
170	/* Got a sequence of characters other than '"':
171	append to string buffer */
172	string_append(yytext, yyleng);
173	}
174	<id>\"+ {
175	/* Got a sequence of '"' characters:
176	append half of them to string buffer,
177	as '""' represents a single '"'.
178	We apply truncating division,
179	so that '"""' will result in '"'. */
180
181	string_append(yytext, yyleng / 2);
182
183	/* If we got an odd number of quotes, then the
184	last quote we got is the terminating quote.
185	At the end of the string, we return to the
186	initial start state and report the scanned
187	identifier. */
188
189	if (yyleng % 2) {
190	BEGIN(INITIAL);
191	yylval = sym_tab_add_id(
192	pars_sym_tab_global,
193	(byte*) stringbuf, stringbuf_len);
194
195	return(PARS_ID_TOKEN);
196	}
197	}
198
199	"NULL" {
200	yylval = sym_tab_add_null_lit(pars_sym_tab_global);
201
202	return(PARS_NULL_LIT);
203	}
204
205	"SQL" {
206	/* Implicit cursor name */
207	yylval = sym_tab_add_str_lit(pars_sym_tab_global,
208	(byte*) yytext, yyleng);
209	return(PARS_SQL_TOKEN);
210	}
211
212	"AND" {
213	return(PARS_AND_TOKEN);
214	}
215
216	"OR" {
217	return(PARS_OR_TOKEN);
218	}
219
220	"NOT" {
221	return(PARS_NOT_TOKEN);
222	}
223
224	"PROCEDURE" {
225	return(PARS_PROCEDURE_TOKEN);
226	}
227
228	"IN" {
229	return(PARS_IN_TOKEN);
230	}
231
232	"OUT" {
233	return(PARS_OUT_TOKEN);
234	}
235
236	"BINARY" {
237	return(PARS_BINARY_TOKEN);
238	}
239
240	"BLOB" {
241	return(PARS_BLOB_TOKEN);
242	}
243
244	"INT" {
245	return(PARS_INT_TOKEN);
246	}
247
248	"INTEGER" {
249	return(PARS_INT_TOKEN);
250	}
251
252	"FLOAT" {
253	return(PARS_FLOAT_TOKEN);
254	}
255
256	"CHAR" {
257	return(PARS_CHAR_TOKEN);
258	}
259
260	"IS" {
261	return(PARS_IS_TOKEN);
262	}
263
264	"BEGIN" {
265	return(PARS_BEGIN_TOKEN);
266	}
267
268	"END" {
269	return(PARS_END_TOKEN);
270	}
271
272	"IF" {
273	return(PARS_IF_TOKEN);
274	}
275
276	"THEN" {
277	return(PARS_THEN_TOKEN);
278	}
279
280	"ELSE" {
281	return(PARS_ELSE_TOKEN);
282	}
283
284	"ELSIF" {
285	return(PARS_ELSIF_TOKEN);
286	}
287
288	"LOOP" {
289	return(PARS_LOOP_TOKEN);
290	}
291
292	"WHILE" {
293	return(PARS_WHILE_TOKEN);
294	}
295
296	"RETURN" {
297	return(PARS_RETURN_TOKEN);
298	}
299
300	"SELECT" {
301	return(PARS_SELECT_TOKEN);
302	}
303
304	"SUM" {
305	return(PARS_SUM_TOKEN);
306	}
307
308	"COUNT" {
309	return(PARS_COUNT_TOKEN);
310	}
311
312	"DISTINCT" {
313	return(PARS_DISTINCT_TOKEN);
314	}
315
316	"FROM" {
317	return(PARS_FROM_TOKEN);
318	}
319
320	"WHERE" {
321	return(PARS_WHERE_TOKEN);
322	}
323
324	"FOR" {
325	return(PARS_FOR_TOKEN);
326	}
327
328	"READ" {
329	return(PARS_READ_TOKEN);
330	}
331
332	"ORDER" {
333	return(PARS_ORDER_TOKEN);
334	}
335
336	"BY" {
337	return(PARS_BY_TOKEN);
338	}
339
340	"ASC" {
341	return(PARS_ASC_TOKEN);
342	}
343
344	"DESC" {
345	return(PARS_DESC_TOKEN);
346	}
347
348	"INSERT" {
349	return(PARS_INSERT_TOKEN);
350	}
351
352	"INTO" {
353	return(PARS_INTO_TOKEN);
354	}
355
356	"VALUES" {
357	return(PARS_VALUES_TOKEN);
358	}
359
360	"UPDATE" {
361	return(PARS_UPDATE_TOKEN);
362	}
363
364	"SET" {
365	return(PARS_SET_TOKEN);
366	}
367
368	"DELETE" {
369	return(PARS_DELETE_TOKEN);
370	}
371
372	"CURRENT" {
373	return(PARS_CURRENT_TOKEN);
374	}
375
376	"OF" {
377	return(PARS_OF_TOKEN);
378	}
379
380	"CREATE" {
381	return(PARS_CREATE_TOKEN);
382	}
383
384	"TABLE" {
385	return(PARS_TABLE_TOKEN);
386	}
387
388	"INDEX" {
389	return(PARS_INDEX_TOKEN);
390	}
391
392	"UNIQUE" {
393	return(PARS_UNIQUE_TOKEN);
394	}
395
396	"CLUSTERED" {
397	return(PARS_CLUSTERED_TOKEN);
398	}
399
400	"DOES_NOT_FIT_IN_MEMORY" {
401	return(PARS_DOES_NOT_FIT_IN_MEM_TOKEN);
402	}
403
404	"ON" {
405	return(PARS_ON_TOKEN);
406	}
407
408	"DECLARE" {
409	return(PARS_DECLARE_TOKEN);
410	}
411
412	"CURSOR" {
413	return(PARS_CURSOR_TOKEN);
414	}
415
416	"OPEN" {
417	return(PARS_OPEN_TOKEN);
418	}
419
420	"FETCH" {
421	return(PARS_FETCH_TOKEN);
422	}
423
424	"CLOSE" {
425	return(PARS_CLOSE_TOKEN);
426	}
427
428	"NOTFOUND" {
429	return(PARS_NOTFOUND_TOKEN);
430	}
431
432	"TO_CHAR" {
433	return(PARS_TO_CHAR_TOKEN);
434	}
435
436	"TO_NUMBER" {
437	return(PARS_TO_NUMBER_TOKEN);
438	}
439
440	"TO_BINARY" {
441	return(PARS_TO_BINARY_TOKEN);
442	}
443
444	"BINARY_TO_NUMBER" {
445	return(PARS_BINARY_TO_NUMBER_TOKEN);
446	}
447
448	"SUBSTR" {
449	return(PARS_SUBSTR_TOKEN);
450	}
451
452	"REPLSTR" {
453	return(PARS_REPLSTR_TOKEN);
454	}
455
456	"CONCAT" {
457	return(PARS_CONCAT_TOKEN);
458	}
459
460	"INSTR" {
461	return(PARS_INSTR_TOKEN);
462	}
463
464	"LENGTH" {
465	return(PARS_LENGTH_TOKEN);
466	}
467
468	"SYSDATE" {
469	return(PARS_SYSDATE_TOKEN);
470	}
471
472	"PRINTF" {
473	return(PARS_PRINTF_TOKEN);
474	}
475
476	"ASSERT" {
477	return(PARS_ASSERT_TOKEN);
478	}
479
480	"RND" {
481	return(PARS_RND_TOKEN);
482	}
483
484	"RND_STR" {
485	return(PARS_RND_STR_TOKEN);
486	}
487
488	"ROW_PRINTF" {
489	return(PARS_ROW_PRINTF_TOKEN);
490	}
491
492	"COMMIT" {
493	return(PARS_COMMIT_TOKEN);
494	}
495
496	"ROLLBACK" {
497	return(PARS_ROLLBACK_TOKEN);
498	}
499
500	"WORK" {
501	return(PARS_WORK_TOKEN);
502	}
503
504	"UNSIGNED" {
505	return(PARS_UNSIGNED_TOKEN);
506	}
507
508	"EXIT" {
509	return(PARS_EXIT_TOKEN);
510	}
511
512	"FUNCTION" {
513	return(PARS_FUNCTION_TOKEN);
514	}
515
516	"LOCK" {
517	return(PARS_LOCK_TOKEN);
518	}
519
520	"SHARE" {
521	return(PARS_SHARE_TOKEN);
522	}
523
524	"MODE" {
525	return(PARS_MODE_TOKEN);
526	}
527
528	{ID} {
529	yylval = sym_tab_add_id(pars_sym_tab_global,
530	(byte*)yytext,
531	ut_strlen(yytext));
532	return(PARS_ID_TOKEN);
533	}
534
535	".." {
536	return(PARS_DDOT_TOKEN);
537	}
538
539	":=" {
540	return(PARS_ASSIGN_TOKEN);
541	}
542
543	"<=" {
544	return(PARS_LE_TOKEN);
545	}
546
547	">=" {
548	return(PARS_GE_TOKEN);
549	}
550
551	"<>" {
552	return(PARS_NE_TOKEN);
553	}
554
555	"(" {
556
557	return((int)(*yytext));
558	}
559
560	"=" {
561
562	return((int)(*yytext));
563	}
564
565	">" {
566
567	return((int)(*yytext));
568	}
569
570	"<" {
571
572	return((int)(*yytext));
573	}
574
575	"," {
576
577	return((int)(*yytext));
578	}
579
580	";" {
581
582	return((int)(*yytext));
583	}
584
585	")" {
586
587	return((int)(*yytext));
588	}
589
590	"+" {
591
592	return((int)(*yytext));
593	}
594
595	"-" {
596
597	return((int)(*yytext));
598	}
599
600	"*" {
601
602	return((int)(*yytext));
603	}
604
605	"/" {
606
607	return((int)(*yytext));
608	}
609
610	"%" {
611
612	return((int)(*yytext));
613	}
614
615	"{" {
616
617	return((int)(*yytext));
618	}
619
620	"}" {
621
622	return((int)(*yytext));
623	}
624
625	"?" {
626
627	return((int)(*yytext));
628	}
629
630	"/" BEGIN(comment); / eat up comment */
631
632	<comment>[^]
633	<comment>""+[^/]*
634	<comment>"*"+"/" BEGIN(INITIAL);
635
636	[ \t\n]+ /* eat up whitespace */
637
638
639	. {
640	fprintf(stderr,"Unrecognized character: %02x\n",
641	*yytext);
642
643	ut_error;
644
645	return(0);
646	}
647
648	%%