/********************************************************************

        OQL lexical analyzer (conformant to ODMG 2.0 OQL)
	The material is provided as-is, with no warranty of any kind.

        Author: Dirk Olbertz, Fraunhofer ISST

        Contact:Deutsche Telekom, Technologiezentrum, D-64307 Darmstadt
		Fraunhofer ISST, Postfach 520 130, D-44207 Dortmund
		   http://www.isst.fhg.de, mailto:Weissenberg@do.isst.fhg.de

        Date: 	98/03/16

        Decription: 
		This file is based on the BNF for ODMG-93 OQL provided 
		by the ODMG and analyzes the lexical correctness of an
		OQL source-file.

        Modified by Leonidas Fegaras, 10/1/98

*********************************************************************/

%{
%}
%option noyywrap

INTEGER        	[0-9]+
FLOAT          	({INTEGER}"."{INTEGER})(e[+-]?{INTEGER})?
CHAR  	       	\'[^\']\'
STR		\"([^"]*\"\")*[^"]*\"
STR2		\'([^']*\'\')*[^']*\'

IDENT		[a-zA-Z][a-zA-Z0-9_]*

BLANK		[ \t]+
NEWLINE	        \n
%x COMMENT1
COMMENT2        "//"[^\n]*

%%
define		{ parser_column+=6; return ctoken(DEFINE); }
as		{ parser_column+=2; return ctoken(AS); }
nil		{ parser_column+=3; return ctoken(NIL); }
true		{ parser_column+=4; return ctoken(TRUE); }
false		{ parser_column+=5; return ctoken(FALSE); }
"("		{ parser_column+=1; return ctoken(LRPAR); }
")"             { parser_column+=1; return ctoken(RRPAR); }
"+"		{ parser_column+=1; return ctoken(PLUS); }
"-"		{ parser_column+=1; return ctoken(MINUS); }
"*"		{ parser_column+=1; return ctoken(MULT); }
"/"		{ parser_column+=1; return ctoken(DIV); }
mod		{ parser_column+=3; return ctoken(MOD); }
abs		{ parser_column+=3; return ctoken(ABS); }
"||"		{ parser_column+=2; return ctoken(DOUBLEVERT); }
like		{ parser_column+=4; return ctoken(LIKE); }
"="		{ parser_column+=1; return ctoken(EQUAL); }
"!="		{ parser_column+=2; return ctoken(NOTEQUAL); }
">"             { parser_column+=1; return ctoken(GREATER); }
"<"		{ parser_column+=1; return ctoken(LESS); }
">="		{ parser_column+=2; return ctoken(GREATEREQUAL); }
"<="		{ parser_column+=2; return ctoken(LESSEQUAL); }
not		{ parser_column+=3; return ctoken(NOT); }
and		{ parser_column+=3; return ctoken(AND); }
or		{ parser_column+=2; return ctoken(OR); }
struct          { parser_column+=6; return ctoken(STRUCT); }
set		{ parser_column+=3; return ctoken(SET); }
bag		{ parser_column+=3; return ctoken(BAG); }
list		{ parser_column+=4; return ctoken(LIST); }
array		{ parser_column+=5; return ctoken(ARRAY); }
"]"		{ parser_column+=1; return ctoken(REPAR); }
"["		{ parser_column+=1; return ctoken(LEPAR); }
"."  		{ parser_column+=1; return ctoken(DOT); }
"->"	        { parser_column+=2; return ctoken(DOT); }
".."		{ parser_column+=2; return ctoken(TWODOT); }
":"		{ parser_column+=1; return ctoken(DOUBLEDOT); } 
";"		{ parser_column+=1; return SEMI; }
","		{ parser_column+=1; return ctoken(KOMMA); }
first		{ parser_column+=5; return ctoken(FIRST); }
last		{ parser_column+=4; return ctoken(LAST); }
for		{ parser_column+=3; return ctoken(FOR); }
all		{ parser_column+=3; return ctoken(ALL); }
in		{ parser_column+=2; return ctoken(IN); }
exists	        { parser_column+=6; return ctoken(EXISTS); }
unique	        { parser_column+=6; return ctoken(UNIQUE); }
some		{ parser_column+=4; return ctoken(SOME); }
any		{ parser_column+=3; return ctoken(ANY); }
count		{ parser_column+=5; return ctoken(COUNT); }
sum		{ parser_column+=3; return ctoken(SUM); }
min		{ parser_column+=3; return ctoken(MIN); }
max		{ parser_column+=3; return ctoken(MAX); }
avg		{ parser_column+=3; return ctoken(AVG); }
select	        { parser_column+=6; return ctoken(SELECT); }
distinct	{ parser_column+=8; return ctoken(DISTINCT); }
from		{ parser_column+=4; return ctoken(FROM); }
where		{ parser_column+=5; return ctoken(WHERE); }
group		{ parser_column+=5; return ctoken(GROUP); }
by		{ parser_column+=2; return ctoken(BY); }
having	        { parser_column+=6; return ctoken(HAVING); }
order		{ parser_column+=5; return ctoken(ORDER); }
asc		{ parser_column+=3; return ctoken(ASC); }
desc		{ parser_column+=4; return ctoken(DESC); }
intersect	{ parser_column+=9; return ctoken(INTERSECT); }
union		{ parser_column+=5; return ctoken(UNION); }
except	        { parser_column+=6; return ctoken(EXCEPT); }
listtoset	{ parser_column+=9; return ctoken(LISTTOSET); }
element	        { parser_column+=7; return ctoken(ELEMENT); }
flatten	        { parser_column+=7; return ctoken(FLATTEN); }

"%"	        { parser_column+=1; return ESCAPE; }
"{"	        { parser_column+=1; return LSPAR; }
"}"	        { parser_column+=1; return RSPAR; }
"+="	        { parser_column+=2; return ctoken(INSERT); }
"-="	        { parser_column+=2; return ctoken(DELETE); }
":="	        { parser_column+=2; return ctoken(ASSIGN); }
create	        { parser_column+=6; return ctoken(CREATE); }
index	        { parser_column+=5; return ctoken(INDEX); }
on	        { parser_column+=2; return ctoken(ON); }
drop	        { parser_column+=4; return ctoken(DROP); }
print	        { parser_column+=5; return ctoken(PRINT); }
collect	        { parser_column+=7; return ctoken(COLLECT); }
statistics      { parser_column+=10; return ctoken(STATISTICS); }
module	        { parser_column+=6; return ctoken(MODULE); }
import	        { parser_column+=6; return ctoken(IMPORT); }
each	        { parser_column+=4; return ctoken(EACH); }
do	        { parser_column+=2; return ctoken(DO); }
begin	        { parser_column+=5; return ctoken(BEGINT); }
commit	        { parser_column+=6; return ctoken(COMMIT); }
abort	        { parser_column+=5; return ctoken(ABORT); }
initialize	{ parser_column+=10; return ctoken(INITIALIZE); }
cleanup	        { parser_column+=7; return ctoken(CLEANUP); }
case	        { parser_column+=4; return ctoken(CASE); }
of	        { parser_column+=2; return ctoken(OF); }
end	        { parser_column+=3; return ctoken(END); }
default	        { parser_column+=7; return ctoken(DEFAULT); }
options	        { parser_column+=7; return ctoken(OPTIONS); }
if	        { parser_column+=2; return ctoken(IFT); }
then	        { parser_column+=2; return ctoken(THENT); }
else	        { parser_column+=2; return ctoken(ELSET); }
persistent      { parser_column+=10; return ctoken(PERSISTENT); }
"</"	        { parser_column+=2; return ctoken(ENDTAG); }
"._"		{ parser_column+=2; return ctoken(ANY_TAG); }
".*"		{ parser_column+=2; return ctoken(STAR_TAG); }

{BLANK}         {
                    parser_column+=strlen(yytext);
		    ctext();
                }
{COMMENT2}	{
                    parser_column=0;
		    ctext();
                }

"/*"			 BEGIN(COMMENT1);
<COMMENT1>[^*\n]*        /* eat anything that's not a '*' */
<COMMENT1>"*"+[^*/\n]*   /* eat up '*'s not followed by '/'s */
<COMMENT1>\n             { ++parser_line; ctext(); parser_column=0; }
<COMMENT1>"*"+"/"        BEGIN(INITIAL);


{NEWLINE}	{
                    parser_line++;
                    parser_column=0;
		    ctext();
                }
{IDENT}         {
		    yylval.StringType = (char*)malloc((unsigned)strlen(yytext)+1);
                    parser_column+=strlen(yytext);
                    strcpy(yylval.StringType,yytext);
                    return ctoken(identifier);
		}
{INTEGER}       {
                    yylval.Integer = atol(yytext);
                    parser_column+=strlen(yytext);
                    return ctoken(integer_literal);
                }
{FLOAT}         {
                    yylval.Float = (double)atof(yytext);
                    parser_column+=strlen(yytext);
                    return ctoken(float_literal);
                }
{STR}|{STR2}|{CHAR}   { 
		    yylval.StringType = (char*)malloc((unsigned)strlen(yytext)+1);
                    parser_column+=strlen(yytext);
                    strcpy(yylval.StringType,yytext);
                    return ctoken(string_literal); 
		}
.		{   parser_column+=strlen(yytext);
		    ctext();
                }
%%