xref: /aoo4110/main/connectivity/source/parse/sqlflex.l (revision b1cdbd2c)

%{
//------------------------------------------------------------
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
//------------------------------------------------------------

#define YY_EXIT 1				// YY_FATAL will not halt the application

#ifndef _CSTDARG_
#include <cstdarg>      // std::va_list
#endif

#ifndef _INC_STRING
#include <string.h>
#endif

#include "internalnode.hxx"

#ifndef _CONNECTIVITY_SQLYACC_HXX
#define _CONNECTIVITY_SQLYACC_HXX

#ifndef SQLYYDEBUG
#define SQLYYDEBUG 1
#endif

#include "sqlbison.hxx"
#endif
#include "sqlscan.hxx"
#include <osl/diagnose.h>
#include <rtl/strbuf.hxx>
#include <connectivity/sqlparse.hxx>

#if defined __GNUC__
    #pragma GCC system_header
#elif defined __SUNPRO_CC
#pragma disable_warn
#elif defined _MSC_VER
#pragma warning(push, 1)
/**/
#ifdef yywrap
#undef  yywrap
#define yywrap() 1
#endif
/**/
#endif

using namespace connectivity;

//=============================================================================
//
// Erzeugung der Blaetter fuer die Token
// Blaetter werden generell vom Lexer erzeugt

static ::rtl::OUString aEmptyString;

static sal_Int32	gatherString(sal_Int32 delim, sal_Int32 nTyp);
static sal_Int32	gatherName(const sal_Char*);
static sal_Int32	gatherNamePre(const sal_Char* );
// has to be set before the parser starts
OSQLScanner* xxx_pGLOBAL_SQLSCAN = NULL;

#define SQL_NEW_NODE(text, token)	\
		SQLyylval.pParseNode = new OSQLInternalNode(text, token);

#define SQL_NEW_KEYWORD(token)						\
		SQLyylval.pParseNode = new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, (token));		return token;

#define SQL_NEW_INTNUM 		SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_INTNUM); return SQL_TOKEN_INTNUM;
#define SQL_NEW_APPROXNUM 	SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_APPROXNUM); return SQL_TOKEN_APPROXNUM;
#define SQL_NEW_DATE 		SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_ACCESS_DATE); return SQL_TOKEN_ACCESS_DATE;

#define YY_INPUT(buf,result,max_size) 				\
{													\
	buf[0] = xxx_pGLOBAL_SQLSCAN->SQLyygetc();		\
	result = buf[0] != -1;							\
}

#define YY_FATAL_ERROR(msg)							\
{													\
	xxx_pGLOBAL_SQLSCAN->SQLyyerror(msg);			\
}

//
//=============================================================================

%}

%s SQL
%s PREDICATE_ENG
%s PREDICATE_GER
%s DATE
%s STRING

%option noyywrap
%option never-interactive
%%

ABS					{SQL_NEW_KEYWORD(SQL_TOKEN_ABS);  }
ACOS				{SQL_NEW_KEYWORD(SQL_TOKEN_ACOS);  }
AFTER				{SQL_NEW_KEYWORD(SQL_TOKEN_AFTER);  }
ALL					{SQL_NEW_KEYWORD(SQL_TOKEN_ALL);  }
ALTER				{SQL_NEW_KEYWORD(SQL_TOKEN_ALTER);  }
AND					{SQL_NEW_KEYWORD(SQL_TOKEN_AND);  }
ANY					{SQL_NEW_KEYWORD(SQL_TOKEN_ANY);  }
ARRAY_AGG			{SQL_NEW_KEYWORD(SQL_TOKEN_ARRAY_AGG);  }
AS					{SQL_NEW_KEYWORD(SQL_TOKEN_AS);  }
ASC					{SQL_NEW_KEYWORD(SQL_TOKEN_ASC);  }
ASCII				{SQL_NEW_KEYWORD(SQL_TOKEN_ASCII);  }
ASIN				{SQL_NEW_KEYWORD(SQL_TOKEN_ASIN);  }
AT					{SQL_NEW_KEYWORD(SQL_TOKEN_AT);  }
ATAN				{SQL_NEW_KEYWORD(SQL_TOKEN_ATAN);  }
ATAN2				{SQL_NEW_KEYWORD(SQL_TOKEN_ATAN2);  }
ATOMIC				{SQL_NEW_KEYWORD(SQL_TOKEN_ATOMIC);  }
AUTHORIZATION   	{SQL_NEW_KEYWORD(SQL_TOKEN_AUTHORIZATION);  }
AVG					{SQL_NEW_KEYWORD(SQL_TOKEN_AVG);  }

BEFORE				{SQL_NEW_KEYWORD(SQL_TOKEN_BEFORE);  }
BEGIN				{SQL_NEW_KEYWORD(SQL_TOKEN_BEGIN);  }
BETWEEN				{SQL_NEW_KEYWORD(SQL_TOKEN_BETWEEN);  }
BIGINT				{SQL_NEW_KEYWORD(SQL_TOKEN_BIGINT);  }
BINARY				{SQL_NEW_KEYWORD(SQL_TOKEN_BINARY);  }
BIT					{SQL_NEW_KEYWORD(SQL_TOKEN_BIT);  }
BIT_LENGTH          {SQL_NEW_KEYWORD(SQL_TOKEN_BIT_LENGTH);  }
BLOB				{SQL_NEW_KEYWORD(SQL_TOKEN_BLOB);  }
BOTH				{SQL_NEW_KEYWORD(SQL_TOKEN_BOTH);  }
BY					{SQL_NEW_KEYWORD(SQL_TOKEN_BY);  }

CALL				{SQL_NEW_KEYWORD(SQL_TOKEN_CALL);  }
CASE				{SQL_NEW_KEYWORD(SQL_TOKEN_CASE);  }
CAST				{SQL_NEW_KEYWORD(SQL_TOKEN_CAST);  }
CEILING				{SQL_NEW_KEYWORD(SQL_TOKEN_CEILING);  }
CHAR				{SQL_NEW_KEYWORD(SQL_TOKEN_CHAR);  }
CHARACTER			{SQL_NEW_KEYWORD(SQL_TOKEN_CHARACTER);  }
CHAR(ACTER)?_LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_CHAR_LENGTH);  }
CHECK				{SQL_NEW_KEYWORD(SQL_TOKEN_CHECK);  }
CLOB				{SQL_NEW_KEYWORD(SQL_TOKEN_CLOB);  }
COALESCE			{SQL_NEW_KEYWORD(SQL_TOKEN_COALESCE);  }
COLLATE				{SQL_NEW_KEYWORD(SQL_TOKEN_COLLATE);  }
COLLECT             {SQL_NEW_KEYWORD(SQL_TOKEN_COLLECT);  }
COMMIT				{SQL_NEW_KEYWORD(SQL_TOKEN_COMMIT);  }
CONCAT				{SQL_NEW_KEYWORD(SQL_TOKEN_CONCAT);  }
CONTINUE			{SQL_NEW_KEYWORD(SQL_TOKEN_CONTINUE);  }
CONVERT				{SQL_NEW_KEYWORD(SQL_TOKEN_CONVERT);  }
COS					{SQL_NEW_KEYWORD(SQL_TOKEN_COS);  }
COT					{SQL_NEW_KEYWORD(SQL_TOKEN_COT);  }
COUNT				{SQL_NEW_KEYWORD(SQL_TOKEN_COUNT);  }
CREATE				{SQL_NEW_KEYWORD(SQL_TOKEN_CREATE);  }
CROSS				{SQL_NEW_KEYWORD(SQL_TOKEN_CROSS);  }
CUME_RANK			{SQL_NEW_KEYWORD(SQL_TOKEN_CUME_DIST);  }
CURRENT				{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT);  }
CURRENT_DATE		{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_DATE);  }
CURRENT_CATALOG					{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_CATALOG);  }
CURRENT_DEFAULT_TRANSFORM_GROUP	{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP);  }
CURRENT_PATH					{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_PATH);  }
CURRENT_ROLE					{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_ROLE);  }
CURRENT_SCHEMA					{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_SCHEMA);  }
CURRENT_USER					{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_USER);  }
CURDATE				{SQL_NEW_KEYWORD(SQL_TOKEN_CURDATE);  }
CURRENT_TIME		{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_TIME);  }
CURTIME				{SQL_NEW_KEYWORD(SQL_TOKEN_CURTIME);  }
CURRENT_TIMESTAMP	{SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_TIMESTAMP);  }
CURSOR				{SQL_NEW_KEYWORD(SQL_TOKEN_CURSOR);  }

D					{SQL_NEW_KEYWORD(SQL_TOKEN_D);  }
DATE				{SQL_NEW_KEYWORD(SQL_TOKEN_DATE);  }
DATEDIFF			{SQL_NEW_KEYWORD(SQL_TOKEN_DATEDIFF);  }
DATEVALUE			{SQL_NEW_KEYWORD(SQL_TOKEN_DATEVALUE);  }
DAY					{SQL_NEW_KEYWORD(SQL_TOKEN_DAY);  }
DAYNAME				{SQL_NEW_KEYWORD(SQL_TOKEN_DAYNAME);  }
DAYOFMONTH			{SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFMONTH);  }
DAYOFWEEK			{SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFWEEK);  }
DAYOFYEAR			{SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFYEAR);  }
DEC					{SQL_NEW_KEYWORD(SQL_TOKEN_DEC);  }
DECIMAL				{SQL_NEW_KEYWORD(SQL_TOKEN_DECIMAL);  }
DECLARE				{SQL_NEW_KEYWORD(SQL_TOKEN_DECLARE);  }
DEFAULT				{SQL_NEW_KEYWORD(SQL_TOKEN_DEFAULT);  }
DEGREES				{SQL_NEW_KEYWORD(SQL_TOKEN_DEGREES);  }
DELETE				{SQL_NEW_KEYWORD(SQL_TOKEN_DELETE);  }
DENSE_RANK			{SQL_NEW_KEYWORD(SQL_TOKEN_DENSE_RANK);  }
DESC				{SQL_NEW_KEYWORD(SQL_TOKEN_DESC);  }
DIFFERENCE			{SQL_NEW_KEYWORD(SQL_TOKEN_DIFFERENCE);  }
DISTINCT			{SQL_NEW_KEYWORD(SQL_TOKEN_DISTINCT);  }
DOUBLE				{SQL_NEW_KEYWORD(SQL_TOKEN_DOUBLE);  }
DROP				{SQL_NEW_KEYWORD(SQL_TOKEN_DROP);  }

EACH				{SQL_NEW_KEYWORD(SQL_TOKEN_EACH);  }
ELSE				{SQL_NEW_KEYWORD(SQL_TOKEN_ELSE);  }
END					{SQL_NEW_KEYWORD(SQL_TOKEN_END);  }
EVERY               {SQL_NEW_KEYWORD(SQL_TOKEN_EVERY);  }
ESCAPE				{SQL_NEW_KEYWORD(SQL_TOKEN_ESCAPE);  }
EXCEPT				{SQL_NEW_KEYWORD(SQL_TOKEN_EXCEPT);  }
EXCLUDE				{SQL_NEW_KEYWORD(SQL_TOKEN_EXCLUDE);  }
EXISTS				{SQL_NEW_KEYWORD(SQL_TOKEN_EXISTS);  }
EXP					{SQL_NEW_KEYWORD(SQL_TOKEN_EXP);  }
EXTRACT				{SQL_NEW_KEYWORD(SQL_TOKEN_EXTRACT);  }

FALSE				{SQL_NEW_KEYWORD(SQL_TOKEN_FALSE);  }
FETCH				{SQL_NEW_KEYWORD(SQL_TOKEN_FETCH);  }
FIRST				{SQL_NEW_KEYWORD(SQL_TOKEN_FIRST);  }
FIRST_VALUE			{SQL_NEW_KEYWORD(SQL_TOKEN_FIRST_VALUE);  }
FLOAT				{SQL_NEW_KEYWORD(SQL_TOKEN_FLOAT);  }
FLOOR				{SQL_NEW_KEYWORD(SQL_TOKEN_FLOOR);  }
FN					{SQL_NEW_KEYWORD(SQL_TOKEN_FN);  }
FOLLOWING			{SQL_NEW_KEYWORD(SQL_TOKEN_FOLLOWING);  }
FOR					{SQL_NEW_KEYWORD(SQL_TOKEN_FOR);  }
FOREIGN				{SQL_NEW_KEYWORD(SQL_TOKEN_FOREIGN);  }
FOUND				{SQL_NEW_KEYWORD(SQL_TOKEN_FOUND);  }
FROM				{SQL_NEW_KEYWORD(SQL_TOKEN_FROM);  }
FULL				{SQL_NEW_KEYWORD(SQL_TOKEN_FULL);  }
FUSION              {SQL_NEW_KEYWORD(SQL_TOKEN_FUSION);  }

GRANT				{SQL_NEW_KEYWORD(SQL_TOKEN_GRANT);  }
GROUP				{SQL_NEW_KEYWORD(SQL_TOKEN_GROUP);  }

HAVING				{SQL_NEW_KEYWORD(SQL_TOKEN_HAVING);  }
HOUR				{SQL_NEW_KEYWORD(SQL_TOKEN_HOUR);  }

IGNORE				{SQL_NEW_KEYWORD(SQL_TOKEN_IGNORE);  }
IN					{SQL_NEW_KEYWORD(SQL_TOKEN_IN);  }
INNER				{SQL_NEW_KEYWORD(SQL_TOKEN_INNER);  }
INSERT				{SQL_NEW_KEYWORD(SQL_TOKEN_INSERT);  }
INSTEAD				{SQL_NEW_KEYWORD(SQL_TOKEN_INSTEAD);  }
INT(EGER)?			{SQL_NEW_KEYWORD(SQL_TOKEN_INTEGER);  }
INTERSECT			{SQL_NEW_KEYWORD(SQL_TOKEN_INTERSECT);  }
INTERVAL			{SQL_NEW_KEYWORD(SQL_TOKEN_INTERVAL);  }
INTERSECTION		{SQL_NEW_KEYWORD(SQL_TOKEN_INTERSECTION);  }
INTO				{SQL_NEW_KEYWORD(SQL_TOKEN_INTO);  }
IS					{SQL_NEW_KEYWORD(SQL_TOKEN_IS);  }

JOIN				{SQL_NEW_KEYWORD(SQL_TOKEN_JOIN);  }

KEY					{SQL_NEW_KEYWORD(SQL_TOKEN_KEY);  }

LAG					{SQL_NEW_KEYWORD(SQL_TOKEN_LAG);  }
LARGE				{SQL_NEW_KEYWORD(SQL_TOKEN_LARGE);  }
LAST				{SQL_NEW_KEYWORD(SQL_TOKEN_LAST);  }
LAST_VALUE			{SQL_NEW_KEYWORD(SQL_TOKEN_LAST_VALUE);  }
LCASE				{SQL_NEW_KEYWORD(SQL_TOKEN_LCASE);  }
LEAD				{SQL_NEW_KEYWORD(SQL_TOKEN_LEAD);  }
LEADING				{SQL_NEW_KEYWORD(SQL_TOKEN_LEADING);  }
LEFT				{SQL_NEW_KEYWORD(SQL_TOKEN_LEFT);  }
LENGTH				{SQL_NEW_KEYWORD(SQL_TOKEN_LENGTH);  }
LIKE				{SQL_NEW_KEYWORD(SQL_TOKEN_LIKE);  }
LIMIT				{SQL_NEW_KEYWORD(SQL_TOKEN_LIMIT);  }
LN					{SQL_NEW_KEYWORD(SQL_TOKEN_LN);  }
LOCAL				{SQL_NEW_KEYWORD(SQL_TOKEN_LOCAL);  }
LOCATE				{SQL_NEW_KEYWORD(SQL_TOKEN_LOCATE);  }
LOG					{SQL_NEW_KEYWORD(SQL_TOKEN_LOG);  }
LOGF				{SQL_NEW_KEYWORD(SQL_TOKEN_LOGF);  }
LOG10				{SQL_NEW_KEYWORD(SQL_TOKEN_LOG10);  }
LOWER				{SQL_NEW_KEYWORD(SQL_TOKEN_LOWER);  }
LTRIM				{SQL_NEW_KEYWORD(SQL_TOKEN_LTRIM);  }

MAX					{SQL_NEW_KEYWORD(SQL_TOKEN_MAX);  }
MIN					{SQL_NEW_KEYWORD(SQL_TOKEN_MIN);  }
MINUTE				{SQL_NEW_KEYWORD(SQL_TOKEN_MINUTE);  }
MOD					{SQL_NEW_KEYWORD(SQL_TOKEN_MOD);  }
MONTH				{SQL_NEW_KEYWORD(SQL_TOKEN_MONTH);  }
MONTHNAME			{SQL_NEW_KEYWORD(SQL_TOKEN_MONTHNAME);  }

NATIONAL			{SQL_NEW_KEYWORD(SQL_TOKEN_NATIONAL);  }
NATURAL				{SQL_NEW_KEYWORD(SQL_TOKEN_NATURAL);  }
NCHAR				{SQL_NEW_KEYWORD(SQL_TOKEN_NCHAR);  }
NCLOB				{SQL_NEW_KEYWORD(SQL_TOKEN_NCLOB);  }
NEW					{SQL_NEW_KEYWORD(SQL_TOKEN_NEW);  }
NEXT				{SQL_NEW_KEYWORD(SQL_TOKEN_NEXT);  }
NO					{SQL_NEW_KEYWORD(SQL_TOKEN_NO);  }
NOT					{SQL_NEW_KEYWORD(SQL_TOKEN_NOT);  }
NOW					{SQL_NEW_KEYWORD(SQL_TOKEN_NOW);  }
NTH_VALUE			{SQL_NEW_KEYWORD(SQL_TOKEN_NTH_VALUE);  }
NTILE				{SQL_NEW_KEYWORD(SQL_TOKEN_NTILE);  }
NULL				{SQL_NEW_KEYWORD(SQL_TOKEN_NULL);  }
NULLIF				{SQL_NEW_KEYWORD(SQL_TOKEN_NULLIF);  }
NULLS				{SQL_NEW_KEYWORD(SQL_TOKEN_NULLS);  }
NUMERIC				{SQL_NEW_KEYWORD(SQL_TOKEN_NUMERIC);  }

OBJECT				{SQL_NEW_KEYWORD(SQL_TOKEN_OBJECT);  }
OCTET_LENGTH		{SQL_NEW_KEYWORD(SQL_TOKEN_OCTET_LENGTH);  }
OF					{SQL_NEW_KEYWORD(SQL_TOKEN_OF);  }
OFFSET				{SQL_NEW_KEYWORD(SQL_TOKEN_OFFSET);  }
OJ					{SQL_NEW_KEYWORD(SQL_TOKEN_OJ);  }
OLD					{SQL_NEW_KEYWORD(SQL_TOKEN_OLD);  }
ON					{SQL_NEW_KEYWORD(SQL_TOKEN_ON);  }
ONLY				{SQL_NEW_KEYWORD(SQL_TOKEN_ONLY);  }
OPTION				{SQL_NEW_KEYWORD(SQL_TOKEN_OPTION);  }
OR					{SQL_NEW_KEYWORD(SQL_TOKEN_OR);  }
ORDER				{SQL_NEW_KEYWORD(SQL_TOKEN_ORDER);  }
OTHERS				{SQL_NEW_KEYWORD(SQL_TOKEN_OTHERS);  }
OUTER				{SQL_NEW_KEYWORD(SQL_TOKEN_OUTER);  }
OVER				{SQL_NEW_KEYWORD(SQL_TOKEN_OVER);  }

PARTITION			{SQL_NEW_KEYWORD(SQL_TOKEN_PARTITION);  }
PERCENT_RANK		{SQL_NEW_KEYWORD(SQL_TOKEN_PERCENT_RANK);  }
PERCENTILE_CONT		{SQL_NEW_KEYWORD(SQL_TOKEN_PERCENTILE_CONT);  }
PERCENTILE_DISC		{SQL_NEW_KEYWORD(SQL_TOKEN_PERCENTILE_DISC);  }
PI					{SQL_NEW_KEYWORD(SQL_TOKEN_PI);  }
POSITION	        {SQL_NEW_KEYWORD(SQL_TOKEN_POSITION);  }
POWER				{SQL_NEW_KEYWORD(SQL_TOKEN_POWER);  }
PRECEDING           {SQL_NEW_KEYWORD(SQL_TOKEN_PRECEDING);  }
PRECISION           {SQL_NEW_KEYWORD(SQL_TOKEN_PRECISION);  }
PRIMARY				{SQL_NEW_KEYWORD(SQL_TOKEN_PRIMARY);  }
PRIVILEGES			{SQL_NEW_KEYWORD(SQL_TOKEN_PRIVILEGES);  }
PROCEDURE           {SQL_NEW_KEYWORD(SQL_TOKEN_PROCEDURE);  }
PUBLIC				{SQL_NEW_KEYWORD(SQL_TOKEN_PUBLIC);  }

QUARTER				{SQL_NEW_KEYWORD(SQL_TOKEN_QUARTER);  }

RADIANS				{SQL_NEW_KEYWORD(SQL_TOKEN_RADIANS);  }
RAND				{SQL_NEW_KEYWORD(SQL_TOKEN_RAND);  }
RANGE				{SQL_NEW_KEYWORD(SQL_TOKEN_RANGE);  }
RANK				{SQL_NEW_KEYWORD(SQL_TOKEN_RANK);  }
REAL				{SQL_NEW_KEYWORD(SQL_TOKEN_REAL);  }
REFERENCES			{SQL_NEW_KEYWORD(SQL_TOKEN_REFERENCES);  }
REFERENCING			{SQL_NEW_KEYWORD(SQL_TOKEN_REFERENCING);  }
REPEAT				{SQL_NEW_KEYWORD(SQL_TOKEN_REPEAT);  }
REPLACE				{SQL_NEW_KEYWORD(SQL_TOKEN_REPLACE);  }
RESPECT				{SQL_NEW_KEYWORD(SQL_TOKEN_RESPECT);  }
ROLLBACK            {SQL_NEW_KEYWORD(SQL_TOKEN_ROLLBACK);  }
ROUND			    {SQL_NEW_KEYWORD(SQL_TOKEN_ROUND);  }
ROUNDMAGIC			{SQL_NEW_KEYWORD(SQL_TOKEN_ROUNDMAGIC);  }
ROW					{SQL_NEW_KEYWORD(SQL_TOKEN_ROW);  }
ROWS					{SQL_NEW_KEYWORD(SQL_TOKEN_ROWS);  }
ROW_NUMBER			{SQL_NEW_KEYWORD(SQL_TOKEN_ROW_NUMBER);  }
RIGHT				{SQL_NEW_KEYWORD(SQL_TOKEN_RIGHT);  }
RTRIM				{SQL_NEW_KEYWORD(SQL_TOKEN_RTRIM);  }

SCHEMA				{SQL_NEW_KEYWORD(SQL_TOKEN_SCHEMA);  }
SECOND				{SQL_NEW_KEYWORD(SQL_TOKEN_SECOND);  }
SELECT				{SQL_NEW_KEYWORD(SQL_TOKEN_SELECT);  }
SET					{SQL_NEW_KEYWORD(SQL_TOKEN_SET);  }
SIZE				{SQL_NEW_KEYWORD(SQL_TOKEN_SIZE);  }
SIGN				{SQL_NEW_KEYWORD(SQL_TOKEN_SIGN);  }
SIN					{SQL_NEW_KEYWORD(SQL_TOKEN_SIN);  }
SMALLINT            {SQL_NEW_KEYWORD(SQL_TOKEN_SMALLINT);  }
SOME				{SQL_NEW_KEYWORD(SQL_TOKEN_SOME);  }
SOUNDEX				{SQL_NEW_KEYWORD(SQL_TOKEN_SOUNDEX);  }
SPACE				{SQL_NEW_KEYWORD(SQL_TOKEN_SPACE);  }
SQRT				{SQL_NEW_KEYWORD(SQL_TOKEN_SQRT);  }
STDDEV_POP          {SQL_NEW_KEYWORD(SQL_TOKEN_STDDEV_POP);  }
STDDEV_SAMP         {SQL_NEW_KEYWORD(SQL_TOKEN_STDDEV_SAMP); }
STATEMENT			{SQL_NEW_KEYWORD(SQL_TOKEN_STATEMENT);  }
SUBSTRING			{SQL_NEW_KEYWORD(SQL_TOKEN_SUBSTRING);  }
SUM					{SQL_NEW_KEYWORD(SQL_TOKEN_SUM);  }
SESSION_USER		{SQL_NEW_KEYWORD(SQL_TOKEN_SESSION_USER);  }
SYSTEM_USER			{SQL_NEW_KEYWORD(SQL_TOKEN_SYSTEM_USER);  }

TABLE				{SQL_NEW_KEYWORD(SQL_TOKEN_TABLE);  }
TAN					{SQL_NEW_KEYWORD(SQL_TOKEN_TAN);  }
THEN				{SQL_NEW_KEYWORD(SQL_TOKEN_THEN);  }
TIES				{SQL_NEW_KEYWORD(SQL_TOKEN_TIES);  }
TIME				{SQL_NEW_KEYWORD(SQL_TOKEN_TIME);  }
TIMESTAMP			{SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMP);  }
TIMESTAMPADD		{SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMPADD);  }
TIMESTAMPDIFF		{SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMPDIFF);  }
TIMEVALUE			{SQL_NEW_KEYWORD(SQL_TOKEN_TIMEVALUE);  }
TIMEZONE_HOUR		{SQL_NEW_KEYWORD(SQL_TOKEN_TIMEZONE_HOUR);  }
TIMEZONE_MINUTE		{SQL_NEW_KEYWORD(SQL_TOKEN_TIMEZONE_MINUTE);  }
TO					{SQL_NEW_KEYWORD(SQL_TOKEN_TO);  }
TRAILING			{SQL_NEW_KEYWORD(SQL_TOKEN_TRAILING);  }
TRANSLATE			{SQL_NEW_KEYWORD(SQL_TOKEN_TRANSLATE);  }
TRIGGER				{SQL_NEW_KEYWORD(SQL_TOKEN_TRIGGER);  }
TRIM				{SQL_NEW_KEYWORD(SQL_TOKEN_TRIM);  }
TRUE				{SQL_NEW_KEYWORD(SQL_TOKEN_TRUE);  }
TRUNCATE			{SQL_NEW_KEYWORD(SQL_TOKEN_TRUNCATE);  }
TS					{SQL_NEW_KEYWORD(SQL_TOKEN_TS);  }
T					{SQL_NEW_KEYWORD(SQL_TOKEN_T);  }

UCASE				{SQL_NEW_KEYWORD(SQL_TOKEN_UCASE);  }
UNBOUNDED			{SQL_NEW_KEYWORD(SQL_TOKEN_UNBOUNDED);  }
UNION				{SQL_NEW_KEYWORD(SQL_TOKEN_UNION);  }
UNIQUE				{SQL_NEW_KEYWORD(SQL_TOKEN_UNIQUE);  }
UNKNOWN				{SQL_NEW_KEYWORD(SQL_TOKEN_UNKNOWN);  }
UPDATE				{SQL_NEW_KEYWORD(SQL_TOKEN_UPDATE);  }
UPPER				{SQL_NEW_KEYWORD(SQL_TOKEN_UPPER);  }
USAGE				{SQL_NEW_KEYWORD(SQL_TOKEN_USAGE);  }
USER				{SQL_NEW_KEYWORD(SQL_TOKEN_USER);  }
USING				{SQL_NEW_KEYWORD(SQL_TOKEN_USING);  }

VARBINARY			{SQL_NEW_KEYWORD(SQL_TOKEN_VARBINARY);  }
VARCHAR             {SQL_NEW_KEYWORD(SQL_TOKEN_VARCHAR);  }
VARYING             {SQL_NEW_KEYWORD(SQL_TOKEN_VARYING);  }
VAR_POP             {SQL_NEW_KEYWORD(SQL_TOKEN_VAR_POP);  }
VAR_SAMP            {SQL_NEW_KEYWORD(SQL_TOKEN_VAR_SAMP);  }
VALUE				{SQL_NEW_KEYWORD(SQL_TOKEN_VALUE);  }
VALUES				{SQL_NEW_KEYWORD(SQL_TOKEN_VALUES);  }
VIEW				{SQL_NEW_KEYWORD(SQL_TOKEN_VIEW);  }

WEEK				{SQL_NEW_KEYWORD(SQL_TOKEN_WEEK);  }
WHEN				{SQL_NEW_KEYWORD(SQL_TOKEN_WHEN);  }
WHERE				{SQL_NEW_KEYWORD(SQL_TOKEN_WHERE);  }
WITH				{SQL_NEW_KEYWORD(SQL_TOKEN_WITH);  }
WITHIN				{SQL_NEW_KEYWORD(SQL_TOKEN_WITHIN);  }
WITHOUT				{SQL_NEW_KEYWORD(SQL_TOKEN_WITHOUT);  }
WORK				{SQL_NEW_KEYWORD(SQL_TOKEN_WORK);  }

YEAR				{SQL_NEW_KEYWORD(SQL_TOKEN_YEAR);  }

ZONE				{SQL_NEW_KEYWORD(SQL_TOKEN_ZONE);  }

"<"					{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_LESS);return SQL_LESS;}
">"					{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_GREAT);return SQL_GREAT;}
"="					{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_EQUAL);return SQL_EQUAL;}
"<="				{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_LESSEQ);return SQL_LESSEQ;}
">="				{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_GREATEQ);return SQL_GREATEQ;}
"<>"				{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_NOTEQUAL);return SQL_NOTEQUAL;}
"!="				{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_NOTEQUAL);return SQL_NOTEQUAL;}
"||"				{ SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_CONCAT);return SQL_CONCAT;}


[-+*/:(),.;?{}]    { return SQLyytext[0]; }


<SQL>[A-Za-z\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375][A-Za-z\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375_0-9]*		{return gatherName( SQLyytext);}

<SQL>([0-9]+) |
<SQL>([0-9]+"."[0-9]*) |
<SQL>("."[0-9]*)					{SQL_NEW_INTNUM; }

<SQL>[0-9]+[eE][+-]?[0-9]+   |
<SQL>[0-9]+"."[0-9]*[eE][+-]?[0-9]+ |
<SQL>"."[0-9]*[eE][+-]?[0-9]+		{SQL_NEW_APPROXNUM;  }

<PREDICATE_GER,PREDICATE_ENG,DATE>[A-Za-z\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375][A-Za-z0-9_%.,*?\200-\277\300-\337\340-\357\360-\367\370-\373\374-\375]* {return gatherNamePre(SQLyytext);}

<PREDICATE_GER,PREDICATE_ENG>([0-9]+)		{SQL_NEW_INTNUM; }
<PREDICATE_ENG>([0-9]{1,3}(","[0-9]{3})+) 	{SQL_NEW_INTNUM; }
<PREDICATE_GER>([0-9]{1,3}("."[0-9]{3})+)	{SQL_NEW_INTNUM; }

<PREDICATE_ENG>([0-9]+"."[0-9]+) |
<PREDICATE_ENG>([0-9]{1,3}(","[0-9]{3})+"."[0-9]+) |
<PREDICATE_ENG>("."[0-9]+)					{SQL_NEW_APPROXNUM;  }
<PREDICATE_ENG>[0-9]+[eE][+-]?[0-9]+   |
<PREDICATE_ENG>[0-9]+"."[0-9]*[eE][+-]?[0-9]+ |
<PREDICATE_ENG>"."[0-9]*[eE][+-]?[0-9]+		{SQL_NEW_APPROXNUM;  }

<PREDICATE_GER>([0-9]+","[0-9]+) |
<PREDICATE_GER>([0-9]{1,3}("."[0-9]{3})+","[0-9]+) |
<PREDICATE_GER>(","[0-9]+)					{SQL_NEW_APPROXNUM;  }
<PREDICATE_GER>[0-9]+[eE][+-]?[0-9]+   |
<PREDICATE_GER>[0-9]+","[0-9]*[eE][+-]?[0-9]+ |
<PREDICATE_GER>","[0-9]*[eE][+-]?[0-9]+		{SQL_NEW_APPROXNUM;  }

<PREDICATE_GER,PREDICATE_ENG>[0-9.,][A-Za-z0-9_.,%]* {return gatherNamePre(SQLyytext);}

<SQL>\"	{ return gatherString('\"',0); }
<SQL>`	{ return gatherString('`' ,0); }

<PREDICATE_GER,PREDICATE_ENG,DATE,SQL>"["		{ return gatherString(']' ,0);}

\'		{ return gatherString('\'',1); }

<PREDICATE_GER,PREDICATE_ENG,DATE>#	{ return gatherString('#' ,2); }

<DATE>[0-9]{1,4}[^ ]*[0-9] |
<DATE>[0-9]{1,4}[^ ]*[0-9][ ][0-9]{1,4}[^ ]*[0-9]		{ SQL_NEW_DATE; }

<STRING>["-""+""*""/"":""("")"",""."";""?""{""}"]		{ return SQLyytext[0]; } /*  */
<STRING>"["					{ return gatherString(']' ,0); }
<STRING>[^ ':["?"]*			{ return gatherNamePre(SQLyytext); }

\n              {}

[ \t\r]+        {}

"--".*$         {}

.				{YY_FATAL_ERROR("Invalid symbol"); return SQL_TOKEN_INVALIDSYMBOL;}

%%

// Kludge around a bug (well, Posix incompatibility) in flex 2.5.x
// http://bugs.debian.org/cgi-bin/bugreport.cgi?archive=no&bug=189332
#if YY_FLEX_MAJOR_VERSION >= 2 && YY_FLEX_MINOR_VERSION >= 5

  #ifndef YY_FLUSH_BUFFER
    #define YY_FLUSH_BUFFER SQLyy_flush_buffer(YY_CURRENT_BUFFER )
  #endif

  #ifndef yytext_ptr
    #define yytext_ptr SQLyytext
  #endif

#endif

// Versions of flex apparently differ in whether input() resp. yyinput() returns
// zero or EOF upon end of file:
inline bool checkeof(int c) { return c == 0 || c == EOF; }

/*
 * Read SQL string literal
 * Valid strings:
 *	''	'a string'	'quote '' within string'
 *	""	"a string"	"quote "" within string"
 * nTyp == 0 -> SQL_NODE_NAME
 * nTyp == 1 -> SQL_NODE_STRING
 * nTyp == 2 -> SQL_NODE_ACCESS_DATE
 */
sal_Int32 gatherString( sal_Int32 delim, sal_Int32 nTyp)
{
	sal_Char ch;
	::rtl::OStringBuffer sBuffer(256);

	while (!checkeof(ch = yyinput()))
	{
		if (ch == delim)
		{
			if ((ch = yyinput()) != delim)
			{
				if (!checkeof(ch))
					unput(ch);

				switch(nTyp)
				{
					case 0:
						SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_NAME);
						return SQL_TOKEN_NAME;
					case 1:
						SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_STRING);
						return SQL_TOKEN_STRING;
					case 2:
						SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_ACCESS_DATE);
						return SQL_TOKEN_ACCESS_DATE;
				}
			}
			else
			{
			    sBuffer.append(ch);
			}

		}
		else if (nTyp != 1 && (ch == '\r' || ch == '\n') )
			break;
		else
		{
		    sBuffer.append(ch);
		}
	}
	YY_FATAL_ERROR("Unterminated name string");
	return SQL_TOKEN_INVALIDSYMBOL;
}

sal_Int32 mapEnumToToken(IParseContext::InternationalKeyCode _eKeyCode )
{
	sal_Int32 nTokenID = 0;
	switch( _eKeyCode )
	{
		case IParseContext::KEY_LIKE:		nTokenID = SQL_TOKEN_LIKE;		break;
		case IParseContext::KEY_NOT:		nTokenID = SQL_TOKEN_NOT;		break;
		case IParseContext::KEY_NULL:		nTokenID = SQL_TOKEN_NULL;		break;
		case IParseContext::KEY_TRUE:		nTokenID = SQL_TOKEN_TRUE;		break;
		case IParseContext::KEY_FALSE:		nTokenID = SQL_TOKEN_FALSE;		break;
		case IParseContext::KEY_IS:			nTokenID = SQL_TOKEN_IS;		break;
		case IParseContext::KEY_BETWEEN:	nTokenID = SQL_TOKEN_BETWEEN;	break;
		case IParseContext::KEY_OR:			nTokenID = SQL_TOKEN_OR;		break;
		case IParseContext::KEY_AND:		nTokenID = SQL_TOKEN_AND;		break;
		case IParseContext::KEY_AVG:		nTokenID = SQL_TOKEN_AVG;		break;
		case IParseContext::KEY_COUNT:		nTokenID = SQL_TOKEN_COUNT;		break;
		case IParseContext::KEY_MAX:		nTokenID = SQL_TOKEN_MAX;		break;
		case IParseContext::KEY_MIN:		nTokenID = SQL_TOKEN_MIN;		break;
		case IParseContext::KEY_SUM:		nTokenID = SQL_TOKEN_SUM;		break;
        case IParseContext::KEY_EVERY:      nTokenID = SQL_TOKEN_EVERY;     break;
        case IParseContext::KEY_ANY:        nTokenID = SQL_TOKEN_ANY;       break;
        case IParseContext::KEY_SOME:       nTokenID = SQL_TOKEN_SOME;      break;
        case IParseContext::KEY_STDDEV_POP: nTokenID = SQL_TOKEN_STDDEV_POP; break;
        case IParseContext::KEY_STDDEV_SAMP: nTokenID = SQL_TOKEN_STDDEV_SAMP; break;
        case IParseContext::KEY_VAR_SAMP:   nTokenID = SQL_TOKEN_VAR_SAMP;  break;
        case IParseContext::KEY_VAR_POP:    nTokenID = SQL_TOKEN_VAR_POP;   break;
        case IParseContext::KEY_COLLECT:    nTokenID = SQL_TOKEN_COLLECT;   break;
        case IParseContext::KEY_FUSION:     nTokenID = SQL_TOKEN_FUSION;    break;
        case IParseContext::KEY_INTERSECTION: nTokenID = SQL_TOKEN_INTERSECTION; break;
                default:
            OSL_ENSURE( false, "mapEnumToToken: unsupported key!" );
	}
	return nTokenID;
}
/*
 * Read SQL Name literal
 * Valid Names or internatioanl keywords:
 *	As we have international keywords, we test first on them
 */
sal_Int32 gatherName(const sal_Char* text)
{
	sal_Int32 nToken;
	OSL_ENSURE(xxx_pGLOBAL_SQLSCAN,"You forgot to set the scanner!");
	IParseContext::InternationalKeyCode eKeyCode = xxx_pGLOBAL_SQLSCAN->getInternationalTokenID(text);
	switch (eKeyCode)
	{
		case IParseContext::KEY_LIKE:
		case IParseContext::KEY_NOT:
		case IParseContext::KEY_NULL:
		case IParseContext::KEY_TRUE:
		case IParseContext::KEY_FALSE:
		case IParseContext::KEY_IS:
		case IParseContext::KEY_BETWEEN:
		case IParseContext::KEY_OR:
		case IParseContext::KEY_AND:
		case IParseContext::KEY_COUNT:
		case IParseContext::KEY_AVG:
		case IParseContext::KEY_MAX:
		case IParseContext::KEY_MIN:
		case IParseContext::KEY_SUM:
        case IParseContext::KEY_EVERY:
        case IParseContext::KEY_ANY:
        case IParseContext::KEY_SOME:
        case IParseContext::KEY_STDDEV_POP:
        case IParseContext::KEY_STDDEV_SAMP:
        case IParseContext::KEY_VAR_SAMP:
        case IParseContext::KEY_VAR_POP:
        case IParseContext::KEY_COLLECT:
        case IParseContext::KEY_FUSION:
        case IParseContext::KEY_INTERSECTION:
			nToken = mapEnumToToken(eKeyCode);
			SQL_NEW_KEYWORD(nToken);
			break;
		default:
			SQL_NEW_NODE(::rtl::OUString(text,strlen(text),RTL_TEXTENCODING_UTF8), SQL_NODE_NAME);
			return SQL_TOKEN_NAME;
	}
}
/**
 Read SQL Name literal for predicate check
 Valid Names or internatioanl keywords:
 As we have international keywords, we test first on them
*/
sal_Int32 gatherNamePre(const sal_Char* text)
{
	sal_Int32 nToken;
	OSL_ENSURE(xxx_pGLOBAL_SQLSCAN,"You forgot to set the scanner!");
	IParseContext::InternationalKeyCode eKeyCode = xxx_pGLOBAL_SQLSCAN->getInternationalTokenID(text);
	switch (eKeyCode)
	{
		case IParseContext::KEY_LIKE:
		case IParseContext::KEY_NOT:
		case IParseContext::KEY_NULL:
		case IParseContext::KEY_TRUE:
		case IParseContext::KEY_FALSE:
		case IParseContext::KEY_IS:
		case IParseContext::KEY_BETWEEN:
		case IParseContext::KEY_OR:
		case IParseContext::KEY_AND:
		case IParseContext::KEY_COUNT:
		case IParseContext::KEY_AVG:
		case IParseContext::KEY_MAX:
		case IParseContext::KEY_MIN:
		case IParseContext::KEY_SUM:
        case IParseContext::KEY_EVERY:
        case IParseContext::KEY_ANY:
        case IParseContext::KEY_SOME:
        case IParseContext::KEY_STDDEV_POP:
        case IParseContext::KEY_STDDEV_SAMP:
        case IParseContext::KEY_VAR_SAMP:
        case IParseContext::KEY_VAR_POP:
        case IParseContext::KEY_COLLECT:
        case IParseContext::KEY_FUSION:
        case IParseContext::KEY_INTERSECTION:
			nToken = mapEnumToToken(eKeyCode);
			SQL_NEW_KEYWORD(nToken);
			break;
		default:
		// we need a special handling for parameter
		{
			::rtl::OString sStmt = xxx_pGLOBAL_SQLSCAN->getStatement();
			sal_Int32 nLength = strlen(text);
			sal_Int32 nPos = xxx_pGLOBAL_SQLSCAN->GetCurrentPos() - nLength - 2;
			if (sStmt.getStr()[nPos] == ':')
			{
				SQL_NEW_NODE(::rtl::OUString(text,nLength,RTL_TEXTENCODING_UTF8), SQL_NODE_NAME);
				nToken = SQL_TOKEN_NAME;
			}
			else
			{
				SQL_NEW_NODE(::rtl::OUString(text,nLength,RTL_TEXTENCODING_UTF8), SQL_NODE_STRING);
				nToken = SQL_TOKEN_STRING;
			}
		}
	}
	return nToken;
}

using namespace connectivity;

static sal_uInt32 Intl_TokenID[] =
{
	SQL_TOKEN_LIKE, SQL_TOKEN_NOT, SQL_TOKEN_NULL, SQL_TOKEN_TRUE,
	SQL_TOKEN_FALSE, SQL_TOKEN_IS, SQL_TOKEN_BETWEEN, SQL_TOKEN_OR,
	SQL_TOKEN_AND, SQL_TOKEN_AVG, SQL_TOKEN_COUNT, SQL_TOKEN_MAX,
	SQL_TOKEN_MIN, SQL_TOKEN_SUM
};
static bool IN_SQLyyerror;
//------------------------------------------------------------------------------
OSQLScanner::OSQLScanner()
			: m_nCurrentPos(0)
		    , m_bInternational(sal_False)
			, m_pContext(NULL)
			, m_nRule(0) // 0 is INITIAL
{
	IN_SQLyyerror = false;
}

//------------------------------------------------------------------------------
OSQLScanner::~OSQLScanner()
{
}
//------------------------------------------------------------------------------
void OSQLScanner::SQLyyerror(sal_Char *fmt)
{

	if(IN_SQLyyerror)
		return;
	IN_SQLyyerror = true;

	OSL_ENSURE(m_pContext, "OSQLScanner::SQLyyerror: No Context set");
	m_sErrorMessage = ::rtl::OUString(fmt,strlen(fmt),RTL_TEXTENCODING_UTF8);
	if (m_nCurrentPos < m_sStatement.getLength())
	{
		m_sErrorMessage += ::rtl::OUString::createFromAscii(": ");

		::rtl::OUString aError;
		static sal_Int32 BUFFERSIZE = 256;
		static sal_Char* Buffer = 0;
		if(!Buffer)
			Buffer = new sal_Char[BUFFERSIZE];

		sal_Char *s = Buffer;
		sal_Int32 nPos = 1;
		sal_Int32 ch = SQLyytext ? (SQLyytext[0] == 0 ? ' ' : SQLyytext[0]): ' ';
		*s++ = ch;
		while (!checkeof(ch = yyinput()))
		{
			if (ch == ' ')
			{
				if ((ch = yyinput()) != ' ')
				{
					if (!checkeof(ch))
						unput(ch);
				}
				*s = '\0';
				aError = ::rtl::OUString(Buffer,nPos,RTL_TEXTENCODING_UTF8);
				break;
			}
			else
			{
				*s++ = ch;
				if (++nPos == BUFFERSIZE)
				{
					::rtl::OString aBuf(Buffer);
					delete[] Buffer;
					BUFFERSIZE *=2;
					Buffer = new sal_Char[BUFFERSIZE];
					for(sal_Int32 i=0;i<aBuf.getLength();++i,++Buffer)
						*Buffer = aBuf.getStr()[i];
					s = &Buffer[nPos];
				}
			}
		}
		m_sErrorMessage += aError;
		delete[] Buffer;
		Buffer = NULL;
	}
	IN_SQLyyerror = false;
	YY_FLUSH_BUFFER;
}

//------------------------------------------------------------------------------
void OSQLScanner::prepareScan(const ::rtl::OUString & rNewStatement, const IParseContext* pContext, sal_Bool bInternational)
{
	YY_FLUSH_BUFFER;
	BEGIN(m_nRule);

	m_sErrorMessage = ::rtl::OUString();
	m_sStatement	= ::rtl::OUStringToOString( rNewStatement, RTL_TEXTENCODING_UTF8);
	m_nCurrentPos	= 0;
	m_bInternational = bInternational;
	m_pContext		= pContext;
}

//------------------------------------------------------------------------------
sal_Int32 OSQLScanner::SQLyygetc(void)
{
	sal_Int32 nPos = (m_nCurrentPos >= m_sStatement.getLength()) ? -1 : m_sStatement.getStr()[m_nCurrentPos];
    m_nCurrentPos++;
    return nPos;
}

//------------------------------------------------------------------------------
IParseContext::InternationalKeyCode OSQLScanner::getInternationalTokenID(const sal_Char* sToken) const
{
	OSL_ENSURE(m_pContext, "OSQLScanner::getInternationalTokenID: No Context set");
	return (m_bInternational) ? m_pContext->getIntlKeyCode(::rtl::OString(sToken) ) : IParseContext::KEY_NONE;
}
// -------------------------------------------------------------------------
sal_Int32	OSQLScanner::GetCurrentRule() const { return m_nRule; }
sal_Int32	OSQLScanner::GetGERRule() const		{ return PREDICATE_GER; }
sal_Int32	OSQLScanner::GetENGRule() const		{ return PREDICATE_ENG; }
sal_Int32	OSQLScanner::GetSQLRule() const		{ return SQL; }
sal_Int32	OSQLScanner::GetDATERule() const	{ return DATE; }
sal_Int32	OSQLScanner::GetSTRINGRule() const	{ return STRING; }
// -------------------------------------------------------------------------
void OSQLScanner::setScanner(sal_Bool _bNull)
{
	xxx_pGLOBAL_SQLSCAN = _bNull ? NULL : this;
}
// -------------------------------------------------------------------------
sal_Int32 OSQLScanner::SQLlex()
{
	return SQLyylex();
}

#if defined __SUNPRO_CC
#pragma enable_warn
#elif defined _MSC_VER
#pragma warning(pop)
#endif