xref: /trunk/main/connectivity/source/parse/sqlflex.l (revision 24c56ab9f1bd1305754aa2f564704f38ff57627e)

%{
//------------------------------------------------------------
//
// 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