1 %{ 2 3 //-------------------------------------------------------------------------- 4 // 5 // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 6 // 7 // Copyright 2000, 2010 Oracle and/or its affiliates. 8 // 9 // OpenOffice.org - a multi-platform office productivity suite 10 // 11 // This file is part of OpenOffice.org. 12 // 13 // OpenOffice.org is free software: you can redistribute it and/or modify 14 // it under the terms of the GNU Lesser General Public License version 3 15 // only, as published by the Free Software Foundation. 16 // 17 // OpenOffice.org is distributed in the hope that it will be useful, 18 // but WITHOUT ANY WARRANTY; without even the implied warranty of 19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 // GNU Lesser General Public License version 3 for more details 21 // (a copy is included in the LICENSE file that accompanied this code). 22 // 23 // You should have received a copy of the GNU Lesser General Public License 24 // version 3 along with OpenOffice.org. If not, see 25 // <http://www.openoffice.org/license.html> 26 // for a copy of the LGPLv3 License. 27 // 28 //-------------------------------------------------------------------------- 29 30 #define YY_EXIT 1 // YY_FATAL will not halt the application 31 32 #ifndef _CSTDARG_ 33 #include <cstdarg> // std::va_list 34 #endif 35 36 #ifndef _INC_STRING 37 #include <string.h> 38 #endif 39 40 #include "internalnode.hxx" 41 42 #ifndef _CONNECTIVITY_SQLYACC_HXX 43 #define _CONNECTIVITY_SQLYACC_HXX 44 45 #ifndef SQLYYDEBUG 46 #define SQLYYDEBUG 1 47 #endif 48 49 #include "sqlbison.hxx" 50 #endif 51 #include "sqlscan.hxx" 52 #include <osl/diagnose.h> 53 #include <rtl/strbuf.hxx> 54 #include <connectivity/sqlparse.hxx> 55 56 #if defined __GNUC__ 57 #pragma GCC system_header 58 #elif defined __SUNPRO_CC 59 #pragma disable_warn 60 #elif defined _MSC_VER 61 #pragma warning(push, 1) 62 /**/ 63 #ifdef yywrap 64 #undef yywrap 65 #define yywrap() 1 66 #endif 67 /**/ 68 #endif 69 70 using namespace connectivity; 71 72 //============================================================================= 73 // 74 // Erzeugung der Blaetter fuer die Token 75 // Blaetter werden generell vom Lexer erzeugt 76 77 static ::rtl::OUString aEmptyString; 78 79 static sal_Int32 gatherString(sal_Int32 delim, sal_Int32 nTyp); 80 static sal_Int32 gatherName(const sal_Char*); 81 static sal_Int32 gatherNamePre(const sal_Char* ); 82 // has to be set before the parser starts 83 OSQLScanner* xxx_pGLOBAL_SQLSCAN = NULL; 84 85 #define SQL_NEW_NODE(text, token) \ 86 SQLyylval.pParseNode = new OSQLInternalNode(text, token); 87 88 #define SQL_NEW_KEYWORD(token) \ 89 SQLyylval.pParseNode = new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD, (token)); return token; 90 91 #define SQL_NEW_INTNUM SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_INTNUM); return SQL_TOKEN_INTNUM; 92 #define SQL_NEW_APPROXNUM SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_APPROXNUM); return SQL_TOKEN_APPROXNUM; 93 #define SQL_NEW_DATE SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_ACCESS_DATE); return SQL_TOKEN_ACCESS_DATE; 94 95 #define YY_INPUT(buf,result,max_size) \ 96 { \ 97 buf[0] = xxx_pGLOBAL_SQLSCAN->SQLyygetc(); \ 98 result = buf[0] != -1; \ 99 } 100 101 #define YY_FATAL_ERROR(msg) \ 102 { \ 103 xxx_pGLOBAL_SQLSCAN->SQLyyerror(msg); \ 104 } 105 106 // 107 //============================================================================= 108 109 %} 110 111 %s SQL 112 %s PREDICATE_ENG 113 %s PREDICATE_GER 114 %s DATE 115 %s STRING 116 117 %option noyywrap 118 %option never-interactive 119 %% 120 121 ABS {SQL_NEW_KEYWORD(SQL_TOKEN_ABS); } 122 ACOS {SQL_NEW_KEYWORD(SQL_TOKEN_ACOS); } 123 AFTER {SQL_NEW_KEYWORD(SQL_TOKEN_AFTER); } 124 ALL {SQL_NEW_KEYWORD(SQL_TOKEN_ALL); } 125 ALTER {SQL_NEW_KEYWORD(SQL_TOKEN_ALTER); } 126 AND {SQL_NEW_KEYWORD(SQL_TOKEN_AND); } 127 ANY {SQL_NEW_KEYWORD(SQL_TOKEN_ANY); } 128 ARRAY_AGG {SQL_NEW_KEYWORD(SQL_TOKEN_ARRAY_AGG); } 129 AS {SQL_NEW_KEYWORD(SQL_TOKEN_AS); } 130 ASC {SQL_NEW_KEYWORD(SQL_TOKEN_ASC); } 131 ASCII {SQL_NEW_KEYWORD(SQL_TOKEN_ASCII); } 132 ASIN {SQL_NEW_KEYWORD(SQL_TOKEN_ASIN); } 133 AT {SQL_NEW_KEYWORD(SQL_TOKEN_AT); } 134 ATAN {SQL_NEW_KEYWORD(SQL_TOKEN_ATAN); } 135 ATAN2 {SQL_NEW_KEYWORD(SQL_TOKEN_ATAN2); } 136 ATOMIC {SQL_NEW_KEYWORD(SQL_TOKEN_ATOMIC); } 137 AUTHORIZATION {SQL_NEW_KEYWORD(SQL_TOKEN_AUTHORIZATION); } 138 AVG {SQL_NEW_KEYWORD(SQL_TOKEN_AVG); } 139 140 BEFORE {SQL_NEW_KEYWORD(SQL_TOKEN_BEFORE); } 141 BEGIN {SQL_NEW_KEYWORD(SQL_TOKEN_BEGIN); } 142 BETWEEN {SQL_NEW_KEYWORD(SQL_TOKEN_BETWEEN); } 143 BIGINT {SQL_NEW_KEYWORD(SQL_TOKEN_BIGINT); } 144 BINARY {SQL_NEW_KEYWORD(SQL_TOKEN_BINARY); } 145 BIT {SQL_NEW_KEYWORD(SQL_TOKEN_BIT); } 146 BIT_LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_BIT_LENGTH); } 147 BLOB {SQL_NEW_KEYWORD(SQL_TOKEN_BLOB); } 148 BOTH {SQL_NEW_KEYWORD(SQL_TOKEN_BOTH); } 149 BY {SQL_NEW_KEYWORD(SQL_TOKEN_BY); } 150 151 CALL {SQL_NEW_KEYWORD(SQL_TOKEN_CALL); } 152 CASE {SQL_NEW_KEYWORD(SQL_TOKEN_CASE); } 153 CAST {SQL_NEW_KEYWORD(SQL_TOKEN_CAST); } 154 CEILING {SQL_NEW_KEYWORD(SQL_TOKEN_CEILING); } 155 CHAR {SQL_NEW_KEYWORD(SQL_TOKEN_CHAR); } 156 CHARACTER {SQL_NEW_KEYWORD(SQL_TOKEN_CHARACTER); } 157 CHAR(ACTER)?_LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_CHAR_LENGTH); } 158 CHECK {SQL_NEW_KEYWORD(SQL_TOKEN_CHECK); } 159 CLOB {SQL_NEW_KEYWORD(SQL_TOKEN_CLOB); } 160 COALESCE {SQL_NEW_KEYWORD(SQL_TOKEN_COALESCE); } 161 COLLATE {SQL_NEW_KEYWORD(SQL_TOKEN_COLLATE); } 162 COLLECT {SQL_NEW_KEYWORD(SQL_TOKEN_COLLECT); } 163 COMMIT {SQL_NEW_KEYWORD(SQL_TOKEN_COMMIT); } 164 CONCAT {SQL_NEW_KEYWORD(SQL_TOKEN_CONCAT); } 165 CONTINUE {SQL_NEW_KEYWORD(SQL_TOKEN_CONTINUE); } 166 CONVERT {SQL_NEW_KEYWORD(SQL_TOKEN_CONVERT); } 167 COS {SQL_NEW_KEYWORD(SQL_TOKEN_COS); } 168 COT {SQL_NEW_KEYWORD(SQL_TOKEN_COT); } 169 COUNT {SQL_NEW_KEYWORD(SQL_TOKEN_COUNT); } 170 CREATE {SQL_NEW_KEYWORD(SQL_TOKEN_CREATE); } 171 CROSS {SQL_NEW_KEYWORD(SQL_TOKEN_CROSS); } 172 CUME_RANK {SQL_NEW_KEYWORD(SQL_TOKEN_CUME_DIST); } 173 CURRENT {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT); } 174 CURRENT_DATE {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_DATE); } 175 CURRENT_CATALOG {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_CATALOG); } 176 CURRENT_DEFAULT_TRANSFORM_GROUP {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP); } 177 CURRENT_PATH {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_PATH); } 178 CURRENT_ROLE {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_ROLE); } 179 CURRENT_SCHEMA {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_SCHEMA); } 180 CURRENT_USER {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_USER); } 181 CURDATE {SQL_NEW_KEYWORD(SQL_TOKEN_CURDATE); } 182 CURRENT_TIME {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_TIME); } 183 CURTIME {SQL_NEW_KEYWORD(SQL_TOKEN_CURTIME); } 184 CURRENT_TIMESTAMP {SQL_NEW_KEYWORD(SQL_TOKEN_CURRENT_TIMESTAMP); } 185 CURSOR {SQL_NEW_KEYWORD(SQL_TOKEN_CURSOR); } 186 187 D {SQL_NEW_KEYWORD(SQL_TOKEN_D); } 188 DATE {SQL_NEW_KEYWORD(SQL_TOKEN_DATE); } 189 DATEDIFF {SQL_NEW_KEYWORD(SQL_TOKEN_DATEDIFF); } 190 DATEVALUE {SQL_NEW_KEYWORD(SQL_TOKEN_DATEVALUE); } 191 DAY {SQL_NEW_KEYWORD(SQL_TOKEN_DAY); } 192 DAYNAME {SQL_NEW_KEYWORD(SQL_TOKEN_DAYNAME); } 193 DAYOFMONTH {SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFMONTH); } 194 DAYOFWEEK {SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFWEEK); } 195 DAYOFYEAR {SQL_NEW_KEYWORD(SQL_TOKEN_DAYOFYEAR); } 196 DEC {SQL_NEW_KEYWORD(SQL_TOKEN_DEC); } 197 DECIMAL {SQL_NEW_KEYWORD(SQL_TOKEN_DECIMAL); } 198 DECLARE {SQL_NEW_KEYWORD(SQL_TOKEN_DECLARE); } 199 DEFAULT {SQL_NEW_KEYWORD(SQL_TOKEN_DEFAULT); } 200 DEGREES {SQL_NEW_KEYWORD(SQL_TOKEN_DEGREES); } 201 DELETE {SQL_NEW_KEYWORD(SQL_TOKEN_DELETE); } 202 DENSE_RANK {SQL_NEW_KEYWORD(SQL_TOKEN_DENSE_RANK); } 203 DESC {SQL_NEW_KEYWORD(SQL_TOKEN_DESC); } 204 DIFFERENCE {SQL_NEW_KEYWORD(SQL_TOKEN_DIFFERENCE); } 205 DISTINCT {SQL_NEW_KEYWORD(SQL_TOKEN_DISTINCT); } 206 DOUBLE {SQL_NEW_KEYWORD(SQL_TOKEN_DOUBLE); } 207 DROP {SQL_NEW_KEYWORD(SQL_TOKEN_DROP); } 208 209 EACH {SQL_NEW_KEYWORD(SQL_TOKEN_EACH); } 210 ELSE {SQL_NEW_KEYWORD(SQL_TOKEN_ELSE); } 211 END {SQL_NEW_KEYWORD(SQL_TOKEN_END); } 212 EVERY {SQL_NEW_KEYWORD(SQL_TOKEN_EVERY); } 213 ESCAPE {SQL_NEW_KEYWORD(SQL_TOKEN_ESCAPE); } 214 EXCEPT {SQL_NEW_KEYWORD(SQL_TOKEN_EXCEPT); } 215 EXCLUDE {SQL_NEW_KEYWORD(SQL_TOKEN_EXCLUDE); } 216 EXISTS {SQL_NEW_KEYWORD(SQL_TOKEN_EXISTS); } 217 EXP {SQL_NEW_KEYWORD(SQL_TOKEN_EXP); } 218 EXTRACT {SQL_NEW_KEYWORD(SQL_TOKEN_EXTRACT); } 219 220 FALSE {SQL_NEW_KEYWORD(SQL_TOKEN_FALSE); } 221 FETCH {SQL_NEW_KEYWORD(SQL_TOKEN_FETCH); } 222 FIRST {SQL_NEW_KEYWORD(SQL_TOKEN_FIRST); } 223 FIRST_VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_FIRST_VALUE); } 224 FLOAT {SQL_NEW_KEYWORD(SQL_TOKEN_FLOAT); } 225 FLOOR {SQL_NEW_KEYWORD(SQL_TOKEN_FLOOR); } 226 FN {SQL_NEW_KEYWORD(SQL_TOKEN_FN); } 227 FOLLOWING {SQL_NEW_KEYWORD(SQL_TOKEN_FOLLOWING); } 228 FOR {SQL_NEW_KEYWORD(SQL_TOKEN_FOR); } 229 FOREIGN {SQL_NEW_KEYWORD(SQL_TOKEN_FOREIGN); } 230 FOUND {SQL_NEW_KEYWORD(SQL_TOKEN_FOUND); } 231 FROM {SQL_NEW_KEYWORD(SQL_TOKEN_FROM); } 232 FULL {SQL_NEW_KEYWORD(SQL_TOKEN_FULL); } 233 FUSION {SQL_NEW_KEYWORD(SQL_TOKEN_FUSION); } 234 235 GRANT {SQL_NEW_KEYWORD(SQL_TOKEN_GRANT); } 236 GROUP {SQL_NEW_KEYWORD(SQL_TOKEN_GROUP); } 237 238 HAVING {SQL_NEW_KEYWORD(SQL_TOKEN_HAVING); } 239 HOUR {SQL_NEW_KEYWORD(SQL_TOKEN_HOUR); } 240 241 IGNORE {SQL_NEW_KEYWORD(SQL_TOKEN_IGNORE); } 242 IN {SQL_NEW_KEYWORD(SQL_TOKEN_IN); } 243 INNER {SQL_NEW_KEYWORD(SQL_TOKEN_INNER); } 244 INSERT {SQL_NEW_KEYWORD(SQL_TOKEN_INSERT); } 245 INSTEAD {SQL_NEW_KEYWORD(SQL_TOKEN_INSTEAD); } 246 INT(EGER)? {SQL_NEW_KEYWORD(SQL_TOKEN_INTEGER); } 247 INTERSECT {SQL_NEW_KEYWORD(SQL_TOKEN_INTERSECT); } 248 INTERVAL {SQL_NEW_KEYWORD(SQL_TOKEN_INTERVAL); } 249 INTERSECTION {SQL_NEW_KEYWORD(SQL_TOKEN_INTERSECTION); } 250 INTO {SQL_NEW_KEYWORD(SQL_TOKEN_INTO); } 251 IS {SQL_NEW_KEYWORD(SQL_TOKEN_IS); } 252 253 JOIN {SQL_NEW_KEYWORD(SQL_TOKEN_JOIN); } 254 255 KEY {SQL_NEW_KEYWORD(SQL_TOKEN_KEY); } 256 257 LAG {SQL_NEW_KEYWORD(SQL_TOKEN_LAG); } 258 LARGE {SQL_NEW_KEYWORD(SQL_TOKEN_LARGE); } 259 LAST {SQL_NEW_KEYWORD(SQL_TOKEN_LAST); } 260 LAST_VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_LAST_VALUE); } 261 LCASE {SQL_NEW_KEYWORD(SQL_TOKEN_LCASE); } 262 LEAD {SQL_NEW_KEYWORD(SQL_TOKEN_LEAD); } 263 LEADING {SQL_NEW_KEYWORD(SQL_TOKEN_LEADING); } 264 LEFT {SQL_NEW_KEYWORD(SQL_TOKEN_LEFT); } 265 LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_LENGTH); } 266 LIKE {SQL_NEW_KEYWORD(SQL_TOKEN_LIKE); } 267 LIMIT {SQL_NEW_KEYWORD(SQL_TOKEN_LIMIT); } 268 LN {SQL_NEW_KEYWORD(SQL_TOKEN_LN); } 269 LOCAL {SQL_NEW_KEYWORD(SQL_TOKEN_LOCAL); } 270 LOCATE {SQL_NEW_KEYWORD(SQL_TOKEN_LOCATE); } 271 LOG {SQL_NEW_KEYWORD(SQL_TOKEN_LOG); } 272 LOGF {SQL_NEW_KEYWORD(SQL_TOKEN_LOGF); } 273 LOG10 {SQL_NEW_KEYWORD(SQL_TOKEN_LOG10); } 274 LOWER {SQL_NEW_KEYWORD(SQL_TOKEN_LOWER); } 275 LTRIM {SQL_NEW_KEYWORD(SQL_TOKEN_LTRIM); } 276 277 MAX {SQL_NEW_KEYWORD(SQL_TOKEN_MAX); } 278 MIN {SQL_NEW_KEYWORD(SQL_TOKEN_MIN); } 279 MINUTE {SQL_NEW_KEYWORD(SQL_TOKEN_MINUTE); } 280 MOD {SQL_NEW_KEYWORD(SQL_TOKEN_MOD); } 281 MONTH {SQL_NEW_KEYWORD(SQL_TOKEN_MONTH); } 282 MONTHNAME {SQL_NEW_KEYWORD(SQL_TOKEN_MONTHNAME); } 283 284 NATIONAL {SQL_NEW_KEYWORD(SQL_TOKEN_NATIONAL); } 285 NATURAL {SQL_NEW_KEYWORD(SQL_TOKEN_NATURAL); } 286 NCHAR {SQL_NEW_KEYWORD(SQL_TOKEN_NCHAR); } 287 NCLOB {SQL_NEW_KEYWORD(SQL_TOKEN_NCLOB); } 288 NEW {SQL_NEW_KEYWORD(SQL_TOKEN_NEW); } 289 NEXT {SQL_NEW_KEYWORD(SQL_TOKEN_NEXT); } 290 NO {SQL_NEW_KEYWORD(SQL_TOKEN_NO); } 291 NOT {SQL_NEW_KEYWORD(SQL_TOKEN_NOT); } 292 NOW {SQL_NEW_KEYWORD(SQL_TOKEN_NOW); } 293 NTH_VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_NTH_VALUE); } 294 NTILE {SQL_NEW_KEYWORD(SQL_TOKEN_NTILE); } 295 NULL {SQL_NEW_KEYWORD(SQL_TOKEN_NULL); } 296 NULLIF {SQL_NEW_KEYWORD(SQL_TOKEN_NULLIF); } 297 NULLS {SQL_NEW_KEYWORD(SQL_TOKEN_NULLS); } 298 NUMERIC {SQL_NEW_KEYWORD(SQL_TOKEN_NUMERIC); } 299 300 OBJECT {SQL_NEW_KEYWORD(SQL_TOKEN_OBJECT); } 301 OCTET_LENGTH {SQL_NEW_KEYWORD(SQL_TOKEN_OCTET_LENGTH); } 302 OF {SQL_NEW_KEYWORD(SQL_TOKEN_OF); } 303 OFFSET {SQL_NEW_KEYWORD(SQL_TOKEN_OFFSET); } 304 OJ {SQL_NEW_KEYWORD(SQL_TOKEN_OJ); } 305 OLD {SQL_NEW_KEYWORD(SQL_TOKEN_OLD); } 306 ON {SQL_NEW_KEYWORD(SQL_TOKEN_ON); } 307 ONLY {SQL_NEW_KEYWORD(SQL_TOKEN_ONLY); } 308 OPTION {SQL_NEW_KEYWORD(SQL_TOKEN_OPTION); } 309 OR {SQL_NEW_KEYWORD(SQL_TOKEN_OR); } 310 ORDER {SQL_NEW_KEYWORD(SQL_TOKEN_ORDER); } 311 OTHERS {SQL_NEW_KEYWORD(SQL_TOKEN_OTHERS); } 312 OUTER {SQL_NEW_KEYWORD(SQL_TOKEN_OUTER); } 313 OVER {SQL_NEW_KEYWORD(SQL_TOKEN_OVER); } 314 315 PARTITION {SQL_NEW_KEYWORD(SQL_TOKEN_PARTITION); } 316 PERCENT_RANK {SQL_NEW_KEYWORD(SQL_TOKEN_PERCENT_RANK); } 317 PERCENTILE_CONT {SQL_NEW_KEYWORD(SQL_TOKEN_PERCENTILE_CONT); } 318 PERCENTILE_DISC {SQL_NEW_KEYWORD(SQL_TOKEN_PERCENTILE_DISC); } 319 PI {SQL_NEW_KEYWORD(SQL_TOKEN_PI); } 320 POSITION {SQL_NEW_KEYWORD(SQL_TOKEN_POSITION); } 321 POWER {SQL_NEW_KEYWORD(SQL_TOKEN_POWER); } 322 PRECEDING {SQL_NEW_KEYWORD(SQL_TOKEN_PRECEDING); } 323 PRECISION {SQL_NEW_KEYWORD(SQL_TOKEN_PRECISION); } 324 PRIMARY {SQL_NEW_KEYWORD(SQL_TOKEN_PRIMARY); } 325 PRIVILEGES {SQL_NEW_KEYWORD(SQL_TOKEN_PRIVILEGES); } 326 PROCEDURE {SQL_NEW_KEYWORD(SQL_TOKEN_PROCEDURE); } 327 PUBLIC {SQL_NEW_KEYWORD(SQL_TOKEN_PUBLIC); } 328 329 QUARTER {SQL_NEW_KEYWORD(SQL_TOKEN_QUARTER); } 330 331 RADIANS {SQL_NEW_KEYWORD(SQL_TOKEN_RADIANS); } 332 RAND {SQL_NEW_KEYWORD(SQL_TOKEN_RAND); } 333 RANGE {SQL_NEW_KEYWORD(SQL_TOKEN_RANGE); } 334 RANK {SQL_NEW_KEYWORD(SQL_TOKEN_RANK); } 335 REAL {SQL_NEW_KEYWORD(SQL_TOKEN_REAL); } 336 REFERENCES {SQL_NEW_KEYWORD(SQL_TOKEN_REFERENCES); } 337 REFERENCING {SQL_NEW_KEYWORD(SQL_TOKEN_REFERENCING); } 338 REPEAT {SQL_NEW_KEYWORD(SQL_TOKEN_REPEAT); } 339 REPLACE {SQL_NEW_KEYWORD(SQL_TOKEN_REPLACE); } 340 RESPECT {SQL_NEW_KEYWORD(SQL_TOKEN_RESPECT); } 341 ROLLBACK {SQL_NEW_KEYWORD(SQL_TOKEN_ROLLBACK); } 342 ROUND {SQL_NEW_KEYWORD(SQL_TOKEN_ROUND); } 343 ROUNDMAGIC {SQL_NEW_KEYWORD(SQL_TOKEN_ROUNDMAGIC); } 344 ROW {SQL_NEW_KEYWORD(SQL_TOKEN_ROW); } 345 ROWS {SQL_NEW_KEYWORD(SQL_TOKEN_ROWS); } 346 ROW_NUMBER {SQL_NEW_KEYWORD(SQL_TOKEN_ROW_NUMBER); } 347 RIGHT {SQL_NEW_KEYWORD(SQL_TOKEN_RIGHT); } 348 RTRIM {SQL_NEW_KEYWORD(SQL_TOKEN_RTRIM); } 349 350 SCHEMA {SQL_NEW_KEYWORD(SQL_TOKEN_SCHEMA); } 351 SECOND {SQL_NEW_KEYWORD(SQL_TOKEN_SECOND); } 352 SELECT {SQL_NEW_KEYWORD(SQL_TOKEN_SELECT); } 353 SET {SQL_NEW_KEYWORD(SQL_TOKEN_SET); } 354 SIZE {SQL_NEW_KEYWORD(SQL_TOKEN_SIZE); } 355 SIGN {SQL_NEW_KEYWORD(SQL_TOKEN_SIGN); } 356 SIN {SQL_NEW_KEYWORD(SQL_TOKEN_SIN); } 357 SMALLINT {SQL_NEW_KEYWORD(SQL_TOKEN_SMALLINT); } 358 SOME {SQL_NEW_KEYWORD(SQL_TOKEN_SOME); } 359 SOUNDEX {SQL_NEW_KEYWORD(SQL_TOKEN_SOUNDEX); } 360 SPACE {SQL_NEW_KEYWORD(SQL_TOKEN_SPACE); } 361 SQRT {SQL_NEW_KEYWORD(SQL_TOKEN_SQRT); } 362 STDDEV_POP {SQL_NEW_KEYWORD(SQL_TOKEN_STDDEV_POP); } 363 STDDEV_SAMP {SQL_NEW_KEYWORD(SQL_TOKEN_STDDEV_SAMP); } 364 STATEMENT {SQL_NEW_KEYWORD(SQL_TOKEN_STATEMENT); } 365 SUBSTRING {SQL_NEW_KEYWORD(SQL_TOKEN_SUBSTRING); } 366 SUM {SQL_NEW_KEYWORD(SQL_TOKEN_SUM); } 367 SESSION_USER {SQL_NEW_KEYWORD(SQL_TOKEN_SESSION_USER); } 368 SYSTEM_USER {SQL_NEW_KEYWORD(SQL_TOKEN_SYSTEM_USER); } 369 370 TABLE {SQL_NEW_KEYWORD(SQL_TOKEN_TABLE); } 371 TAN {SQL_NEW_KEYWORD(SQL_TOKEN_TAN); } 372 THEN {SQL_NEW_KEYWORD(SQL_TOKEN_THEN); } 373 TIES {SQL_NEW_KEYWORD(SQL_TOKEN_TIES); } 374 TIME {SQL_NEW_KEYWORD(SQL_TOKEN_TIME); } 375 TIMESTAMP {SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMP); } 376 TIMESTAMPADD {SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMPADD); } 377 TIMESTAMPDIFF {SQL_NEW_KEYWORD(SQL_TOKEN_TIMESTAMPDIFF); } 378 TIMEVALUE {SQL_NEW_KEYWORD(SQL_TOKEN_TIMEVALUE); } 379 TIMEZONE_HOUR {SQL_NEW_KEYWORD(SQL_TOKEN_TIMEZONE_HOUR); } 380 TIMEZONE_MINUTE {SQL_NEW_KEYWORD(SQL_TOKEN_TIMEZONE_MINUTE); } 381 TO {SQL_NEW_KEYWORD(SQL_TOKEN_TO); } 382 TRAILING {SQL_NEW_KEYWORD(SQL_TOKEN_TRAILING); } 383 TRANSLATE {SQL_NEW_KEYWORD(SQL_TOKEN_TRANSLATE); } 384 TRIGGER {SQL_NEW_KEYWORD(SQL_TOKEN_TRIGGER); } 385 TRIM {SQL_NEW_KEYWORD(SQL_TOKEN_TRIM); } 386 TRUE {SQL_NEW_KEYWORD(SQL_TOKEN_TRUE); } 387 TRUNCATE {SQL_NEW_KEYWORD(SQL_TOKEN_TRUNCATE); } 388 TS {SQL_NEW_KEYWORD(SQL_TOKEN_TS); } 389 T {SQL_NEW_KEYWORD(SQL_TOKEN_T); } 390 391 UCASE {SQL_NEW_KEYWORD(SQL_TOKEN_UCASE); } 392 UNBOUNDED {SQL_NEW_KEYWORD(SQL_TOKEN_UNBOUNDED); } 393 UNION {SQL_NEW_KEYWORD(SQL_TOKEN_UNION); } 394 UNIQUE {SQL_NEW_KEYWORD(SQL_TOKEN_UNIQUE); } 395 UNKNOWN {SQL_NEW_KEYWORD(SQL_TOKEN_UNKNOWN); } 396 UPDATE {SQL_NEW_KEYWORD(SQL_TOKEN_UPDATE); } 397 UPPER {SQL_NEW_KEYWORD(SQL_TOKEN_UPPER); } 398 USAGE {SQL_NEW_KEYWORD(SQL_TOKEN_USAGE); } 399 USER {SQL_NEW_KEYWORD(SQL_TOKEN_USER); } 400 USING {SQL_NEW_KEYWORD(SQL_TOKEN_USING); } 401 402 VARBINARY {SQL_NEW_KEYWORD(SQL_TOKEN_VARBINARY); } 403 VARCHAR {SQL_NEW_KEYWORD(SQL_TOKEN_VARCHAR); } 404 VARYING {SQL_NEW_KEYWORD(SQL_TOKEN_VARYING); } 405 VAR_POP {SQL_NEW_KEYWORD(SQL_TOKEN_VAR_POP); } 406 VAR_SAMP {SQL_NEW_KEYWORD(SQL_TOKEN_VAR_SAMP); } 407 VALUE {SQL_NEW_KEYWORD(SQL_TOKEN_VALUE); } 408 VALUES {SQL_NEW_KEYWORD(SQL_TOKEN_VALUES); } 409 VIEW {SQL_NEW_KEYWORD(SQL_TOKEN_VIEW); } 410 411 WEEK {SQL_NEW_KEYWORD(SQL_TOKEN_WEEK); } 412 WHEN {SQL_NEW_KEYWORD(SQL_TOKEN_WHEN); } 413 WHERE {SQL_NEW_KEYWORD(SQL_TOKEN_WHERE); } 414 WITH {SQL_NEW_KEYWORD(SQL_TOKEN_WITH); } 415 WITHIN {SQL_NEW_KEYWORD(SQL_TOKEN_WITHIN); } 416 WITHOUT {SQL_NEW_KEYWORD(SQL_TOKEN_WITHOUT); } 417 WORK {SQL_NEW_KEYWORD(SQL_TOKEN_WORK); } 418 419 YEAR {SQL_NEW_KEYWORD(SQL_TOKEN_YEAR); } 420 421 ZONE {SQL_NEW_KEYWORD(SQL_TOKEN_ZONE); } 422 423 "<" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_LESS);return SQL_LESS;} 424 ">" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_GREAT);return SQL_GREAT;} 425 "=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_EQUAL);return SQL_EQUAL;} 426 "<=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_LESSEQ);return SQL_LESSEQ;} 427 ">=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_GREATEQ);return SQL_GREATEQ;} 428 "<>" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_NOTEQUAL);return SQL_NOTEQUAL;} 429 "!=" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_NOTEQUAL);return SQL_NOTEQUAL;} 430 "||" { SQL_NEW_NODE(::rtl::OUString(SQLyytext,strlen(SQLyytext),RTL_TEXTENCODING_UTF8), SQL_NODE_CONCAT);return SQL_CONCAT;} 431 432 433 [-+*/:(),.;?{}] { return SQLyytext[0]; } 434 435 436 <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);} 437 438 <SQL>([0-9]+) | 439 <SQL>([0-9]+"."[0-9]*) | 440 <SQL>("."[0-9]*) {SQL_NEW_INTNUM; } 441 442 <SQL>[0-9]+[eE][+-]?[0-9]+ | 443 <SQL>[0-9]+"."[0-9]*[eE][+-]?[0-9]+ | 444 <SQL>"."[0-9]*[eE][+-]?[0-9]+ {SQL_NEW_APPROXNUM; } 445 446 <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);} 447 448 <PREDICATE_GER,PREDICATE_ENG>([0-9]+) {SQL_NEW_INTNUM; } 449 <PREDICATE_ENG>([0-9]{1,3}(","[0-9]{3})+) {SQL_NEW_INTNUM; } 450 <PREDICATE_GER>([0-9]{1,3}("."[0-9]{3})+) {SQL_NEW_INTNUM; } 451 452 <PREDICATE_ENG>([0-9]+"."[0-9]+) | 453 <PREDICATE_ENG>([0-9]{1,3}(","[0-9]{3})+"."[0-9]+) | 454 <PREDICATE_ENG>("."[0-9]+) {SQL_NEW_APPROXNUM; } 455 <PREDICATE_ENG>[0-9]+[eE][+-]?[0-9]+ | 456 <PREDICATE_ENG>[0-9]+"."[0-9]*[eE][+-]?[0-9]+ | 457 <PREDICATE_ENG>"."[0-9]*[eE][+-]?[0-9]+ {SQL_NEW_APPROXNUM; } 458 459 <PREDICATE_GER>([0-9]+","[0-9]+) | 460 <PREDICATE_GER>([0-9]{1,3}("."[0-9]{3})+","[0-9]+) | 461 <PREDICATE_GER>(","[0-9]+) {SQL_NEW_APPROXNUM; } 462 <PREDICATE_GER>[0-9]+[eE][+-]?[0-9]+ | 463 <PREDICATE_GER>[0-9]+","[0-9]*[eE][+-]?[0-9]+ | 464 <PREDICATE_GER>","[0-9]*[eE][+-]?[0-9]+ {SQL_NEW_APPROXNUM; } 465 466 <PREDICATE_GER,PREDICATE_ENG>[0-9.,][A-Za-z0-9_.,%]* {return gatherNamePre(SQLyytext);} 467 468 <SQL>\" { return gatherString('\"',0); } 469 <SQL>` { return gatherString('`' ,0); } 470 471 <PREDICATE_GER,PREDICATE_ENG,DATE,SQL>"[" { return gatherString(']' ,0);} 472 473 \' { return gatherString('\'',1); } 474 475 <PREDICATE_GER,PREDICATE_ENG,DATE># { return gatherString('#' ,2); } 476 477 <DATE>[0-9]{1,4}[^ ]*[0-9] | 478 <DATE>[0-9]{1,4}[^ ]*[0-9][ ][0-9]{1,4}[^ ]*[0-9] { SQL_NEW_DATE; } 479 480 <STRING>["-""+""*""/"":""("")"",""."";""?""{""}"] { return SQLyytext[0]; } /* */ 481 <STRING>"[" { return gatherString(']' ,0); } 482 <STRING>[^ ':["?"]* { return gatherNamePre(SQLyytext); } 483 484 \n {} 485 486 [ \t\r]+ {} 487 488 "--".*$ {} 489 490 . {YY_FATAL_ERROR("Invalid symbol"); return SQL_TOKEN_INVALIDSYMBOL;} 491 492 %% 493 494 // Kludge around a bug (well, Posix incompatibility) in flex 2.5.x 495 // http://bugs.debian.org/cgi-bin/bugreport.cgi?archive=no&bug=189332 496 #if YY_FLEX_MAJOR_VERSION >= 2 && YY_FLEX_MINOR_VERSION >= 5 497 498 #ifndef YY_FLUSH_BUFFER 499 #define YY_FLUSH_BUFFER SQLyy_flush_buffer(YY_CURRENT_BUFFER ) 500 #endif 501 502 #ifndef yytext_ptr 503 #define yytext_ptr SQLyytext 504 #endif 505 506 #endif 507 508 // Versions of flex apparently differ in whether input() resp. yyinput() returns 509 // zero or EOF upon end of file: 510 inline bool checkeof(int c) { return c == 0 || c == EOF; } 511 512 /* 513 * Read SQL string literal 514 * Valid strings: 515 * '' 'a string' 'quote '' within string' 516 * "" "a string" "quote "" within string" 517 * nTyp == 0 -> SQL_NODE_NAME 518 * nTyp == 1 -> SQL_NODE_STRING 519 * nTyp == 2 -> SQL_NODE_ACCESS_DATE 520 */ 521 sal_Int32 gatherString( sal_Int32 delim, sal_Int32 nTyp) 522 { 523 sal_Char ch; 524 ::rtl::OStringBuffer sBuffer(256); 525 526 while (!checkeof(ch = yyinput())) 527 { 528 if (ch == delim) 529 { 530 if ((ch = yyinput()) != delim) 531 { 532 if (!checkeof(ch)) 533 unput(ch); 534 535 switch(nTyp) 536 { 537 case 0: 538 SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_NAME); 539 return SQL_TOKEN_NAME; 540 case 1: 541 SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_STRING); 542 return SQL_TOKEN_STRING; 543 case 2: 544 SQL_NEW_NODE(::rtl::OStringToOUString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8), SQL_NODE_ACCESS_DATE); 545 return SQL_TOKEN_ACCESS_DATE; 546 } 547 } 548 else 549 { 550 sBuffer.append(ch); 551 } 552 553 } 554 else if (nTyp != 1 && (ch == '\r' || ch == '\n') ) 555 break; 556 else 557 { 558 sBuffer.append(ch); 559 } 560 } 561 YY_FATAL_ERROR("Unterminated name string"); 562 return SQL_TOKEN_INVALIDSYMBOL; 563 } 564 565 sal_Int32 mapEnumToToken(IParseContext::InternationalKeyCode _eKeyCode ) 566 { 567 sal_Int32 nTokenID = 0; 568 switch( _eKeyCode ) 569 { 570 case IParseContext::KEY_LIKE: nTokenID = SQL_TOKEN_LIKE; break; 571 case IParseContext::KEY_NOT: nTokenID = SQL_TOKEN_NOT; break; 572 case IParseContext::KEY_NULL: nTokenID = SQL_TOKEN_NULL; break; 573 case IParseContext::KEY_TRUE: nTokenID = SQL_TOKEN_TRUE; break; 574 case IParseContext::KEY_FALSE: nTokenID = SQL_TOKEN_FALSE; break; 575 case IParseContext::KEY_IS: nTokenID = SQL_TOKEN_IS; break; 576 case IParseContext::KEY_BETWEEN: nTokenID = SQL_TOKEN_BETWEEN; break; 577 case IParseContext::KEY_OR: nTokenID = SQL_TOKEN_OR; break; 578 case IParseContext::KEY_AND: nTokenID = SQL_TOKEN_AND; break; 579 case IParseContext::KEY_AVG: nTokenID = SQL_TOKEN_AVG; break; 580 case IParseContext::KEY_COUNT: nTokenID = SQL_TOKEN_COUNT; break; 581 case IParseContext::KEY_MAX: nTokenID = SQL_TOKEN_MAX; break; 582 case IParseContext::KEY_MIN: nTokenID = SQL_TOKEN_MIN; break; 583 case IParseContext::KEY_SUM: nTokenID = SQL_TOKEN_SUM; break; 584 case IParseContext::KEY_EVERY: nTokenID = SQL_TOKEN_EVERY; break; 585 case IParseContext::KEY_ANY: nTokenID = SQL_TOKEN_ANY; break; 586 case IParseContext::KEY_SOME: nTokenID = SQL_TOKEN_SOME; break; 587 case IParseContext::KEY_STDDEV_POP: nTokenID = SQL_TOKEN_STDDEV_POP; break; 588 case IParseContext::KEY_STDDEV_SAMP: nTokenID = SQL_TOKEN_STDDEV_SAMP; break; 589 case IParseContext::KEY_VAR_SAMP: nTokenID = SQL_TOKEN_VAR_SAMP; break; 590 case IParseContext::KEY_VAR_POP: nTokenID = SQL_TOKEN_VAR_POP; break; 591 case IParseContext::KEY_COLLECT: nTokenID = SQL_TOKEN_COLLECT; break; 592 case IParseContext::KEY_FUSION: nTokenID = SQL_TOKEN_FUSION; break; 593 case IParseContext::KEY_INTERSECTION: nTokenID = SQL_TOKEN_INTERSECTION; break; 594 default: 595 OSL_ENSURE( false, "mapEnumToToken: unsupported key!" ); 596 } 597 return nTokenID; 598 } 599 /* 600 * Read SQL Name literal 601 * Valid Names or internatioanl keywords: 602 * As we have international keywords, we test first on them 603 */ 604 sal_Int32 gatherName(const sal_Char* text) 605 { 606 sal_Int32 nToken; 607 OSL_ENSURE(xxx_pGLOBAL_SQLSCAN,"You forgot to set the scanner!"); 608 IParseContext::InternationalKeyCode eKeyCode = xxx_pGLOBAL_SQLSCAN->getInternationalTokenID(text); 609 switch (eKeyCode) 610 { 611 case IParseContext::KEY_LIKE: 612 case IParseContext::KEY_NOT: 613 case IParseContext::KEY_NULL: 614 case IParseContext::KEY_TRUE: 615 case IParseContext::KEY_FALSE: 616 case IParseContext::KEY_IS: 617 case IParseContext::KEY_BETWEEN: 618 case IParseContext::KEY_OR: 619 case IParseContext::KEY_AND: 620 case IParseContext::KEY_COUNT: 621 case IParseContext::KEY_AVG: 622 case IParseContext::KEY_MAX: 623 case IParseContext::KEY_MIN: 624 case IParseContext::KEY_SUM: 625 case IParseContext::KEY_EVERY: 626 case IParseContext::KEY_ANY: 627 case IParseContext::KEY_SOME: 628 case IParseContext::KEY_STDDEV_POP: 629 case IParseContext::KEY_STDDEV_SAMP: 630 case IParseContext::KEY_VAR_SAMP: 631 case IParseContext::KEY_VAR_POP: 632 case IParseContext::KEY_COLLECT: 633 case IParseContext::KEY_FUSION: 634 case IParseContext::KEY_INTERSECTION: 635 nToken = mapEnumToToken(eKeyCode); 636 SQL_NEW_KEYWORD(nToken); 637 break; 638 default: 639 SQL_NEW_NODE(::rtl::OUString(text,strlen(text),RTL_TEXTENCODING_UTF8), SQL_NODE_NAME); 640 return SQL_TOKEN_NAME; 641 } 642 } 643 /** 644 Read SQL Name literal for predicate check 645 Valid Names or internatioanl keywords: 646 As we have international keywords, we test first on them 647 */ 648 sal_Int32 gatherNamePre(const sal_Char* text) 649 { 650 sal_Int32 nToken; 651 OSL_ENSURE(xxx_pGLOBAL_SQLSCAN,"You forgot to set the scanner!"); 652 IParseContext::InternationalKeyCode eKeyCode = xxx_pGLOBAL_SQLSCAN->getInternationalTokenID(text); 653 switch (eKeyCode) 654 { 655 case IParseContext::KEY_LIKE: 656 case IParseContext::KEY_NOT: 657 case IParseContext::KEY_NULL: 658 case IParseContext::KEY_TRUE: 659 case IParseContext::KEY_FALSE: 660 case IParseContext::KEY_IS: 661 case IParseContext::KEY_BETWEEN: 662 case IParseContext::KEY_OR: 663 case IParseContext::KEY_AND: 664 case IParseContext::KEY_COUNT: 665 case IParseContext::KEY_AVG: 666 case IParseContext::KEY_MAX: 667 case IParseContext::KEY_MIN: 668 case IParseContext::KEY_SUM: 669 case IParseContext::KEY_EVERY: 670 case IParseContext::KEY_ANY: 671 case IParseContext::KEY_SOME: 672 case IParseContext::KEY_STDDEV_POP: 673 case IParseContext::KEY_STDDEV_SAMP: 674 case IParseContext::KEY_VAR_SAMP: 675 case IParseContext::KEY_VAR_POP: 676 case IParseContext::KEY_COLLECT: 677 case IParseContext::KEY_FUSION: 678 case IParseContext::KEY_INTERSECTION: 679 nToken = mapEnumToToken(eKeyCode); 680 SQL_NEW_KEYWORD(nToken); 681 break; 682 default: 683 // we need a special handling for parameter 684 { 685 ::rtl::OString sStmt = xxx_pGLOBAL_SQLSCAN->getStatement(); 686 sal_Int32 nLength = strlen(text); 687 sal_Int32 nPos = xxx_pGLOBAL_SQLSCAN->GetCurrentPos() - nLength - 2; 688 if (sStmt.getStr()[nPos] == ':') 689 { 690 SQL_NEW_NODE(::rtl::OUString(text,nLength,RTL_TEXTENCODING_UTF8), SQL_NODE_NAME); 691 nToken = SQL_TOKEN_NAME; 692 } 693 else 694 { 695 SQL_NEW_NODE(::rtl::OUString(text,nLength,RTL_TEXTENCODING_UTF8), SQL_NODE_STRING); 696 nToken = SQL_TOKEN_STRING; 697 } 698 } 699 } 700 return nToken; 701 } 702 703 using namespace connectivity; 704 705 static sal_uInt32 Intl_TokenID[] = 706 { 707 SQL_TOKEN_LIKE, SQL_TOKEN_NOT, SQL_TOKEN_NULL, SQL_TOKEN_TRUE, 708 SQL_TOKEN_FALSE, SQL_TOKEN_IS, SQL_TOKEN_BETWEEN, SQL_TOKEN_OR, 709 SQL_TOKEN_AND, SQL_TOKEN_AVG, SQL_TOKEN_COUNT, SQL_TOKEN_MAX, 710 SQL_TOKEN_MIN, SQL_TOKEN_SUM 711 }; 712 static bool IN_SQLyyerror; 713 //------------------------------------------------------------------------------ 714 OSQLScanner::OSQLScanner() 715 : m_nCurrentPos(0) 716 , m_bInternational(sal_False) 717 , m_pContext(NULL) 718 , m_nRule(0) // 0 is INITIAL 719 { 720 IN_SQLyyerror = false; 721 } 722 723 //------------------------------------------------------------------------------ 724 OSQLScanner::~OSQLScanner() 725 { 726 } 727 //------------------------------------------------------------------------------ 728 void OSQLScanner::SQLyyerror(sal_Char *fmt) 729 { 730 731 if(IN_SQLyyerror) 732 return; 733 IN_SQLyyerror = true; 734 735 OSL_ENSURE(m_pContext, "OSQLScanner::SQLyyerror: No Context set"); 736 m_sErrorMessage = ::rtl::OUString(fmt,strlen(fmt),RTL_TEXTENCODING_UTF8); 737 if (m_nCurrentPos < m_sStatement.getLength()) 738 { 739 m_sErrorMessage += ::rtl::OUString::createFromAscii(": "); 740 741 ::rtl::OUString aError; 742 static sal_Int32 BUFFERSIZE = 256; 743 static sal_Char* Buffer = 0; 744 if(!Buffer) 745 Buffer = new sal_Char[BUFFERSIZE]; 746 747 sal_Char *s = Buffer; 748 sal_Int32 nPos = 1; 749 sal_Int32 ch = SQLyytext ? (SQLyytext[0] == 0 ? ' ' : SQLyytext[0]): ' '; 750 *s++ = ch; 751 while (!checkeof(ch = yyinput())) 752 { 753 if (ch == ' ') 754 { 755 if ((ch = yyinput()) != ' ') 756 { 757 if (!checkeof(ch)) 758 unput(ch); 759 } 760 *s = '\0'; 761 aError = ::rtl::OUString(Buffer,nPos,RTL_TEXTENCODING_UTF8); 762 break; 763 } 764 else 765 { 766 *s++ = ch; 767 if (++nPos == BUFFERSIZE) 768 { 769 ::rtl::OString aBuf(Buffer); 770 delete[] Buffer; 771 BUFFERSIZE *=2; 772 Buffer = new sal_Char[BUFFERSIZE]; 773 for(sal_Int32 i=0;i<aBuf.getLength();++i,++Buffer) 774 *Buffer = aBuf.getStr()[i]; 775 s = &Buffer[nPos]; 776 } 777 } 778 } 779 m_sErrorMessage += aError; 780 delete[] Buffer; 781 Buffer = NULL; 782 } 783 IN_SQLyyerror = false; 784 YY_FLUSH_BUFFER; 785 } 786 787 //------------------------------------------------------------------------------ 788 void OSQLScanner::prepareScan(const ::rtl::OUString & rNewStatement, const IParseContext* pContext, sal_Bool bInternational) 789 { 790 YY_FLUSH_BUFFER; 791 BEGIN(m_nRule); 792 793 m_sErrorMessage = ::rtl::OUString(); 794 m_sStatement = ::rtl::OString(rNewStatement,rNewStatement.getLength(), RTL_TEXTENCODING_UTF8); 795 m_nCurrentPos = 0; 796 m_bInternational = bInternational; 797 m_pContext = pContext; 798 } 799 800 //------------------------------------------------------------------------------ 801 sal_Int32 OSQLScanner::SQLyygetc(void) 802 { 803 sal_Int32 nPos = (m_nCurrentPos >= m_sStatement.getLength()) ? -1 : m_sStatement.getStr()[m_nCurrentPos]; 804 m_nCurrentPos++; 805 return nPos; 806 } 807 808 //------------------------------------------------------------------------------ 809 IParseContext::InternationalKeyCode OSQLScanner::getInternationalTokenID(const sal_Char* sToken) const 810 { 811 OSL_ENSURE(m_pContext, "OSQLScanner::getInternationalTokenID: No Context set"); 812 return (m_bInternational) ? m_pContext->getIntlKeyCode(::rtl::OString(sToken) ) : IParseContext::KEY_NONE; 813 } 814 // ------------------------------------------------------------------------- 815 sal_Int32 OSQLScanner::GetCurrentRule() const { return m_nRule; } 816 sal_Int32 OSQLScanner::GetGERRule() const { return PREDICATE_GER; } 817 sal_Int32 OSQLScanner::GetENGRule() const { return PREDICATE_ENG; } 818 sal_Int32 OSQLScanner::GetSQLRule() const { return SQL; } 819 sal_Int32 OSQLScanner::GetDATERule() const { return DATE; } 820 sal_Int32 OSQLScanner::GetSTRINGRule() const { return STRING; } 821 // ------------------------------------------------------------------------- 822 void OSQLScanner::setScanner(sal_Bool _bNull) 823 { 824 xxx_pGLOBAL_SQLSCAN = _bNull ? NULL : this; 825 } 826 // ------------------------------------------------------------------------- 827 sal_Int32 OSQLScanner::SQLlex() 828 { 829 return SQLyylex(); 830 } 831 832 #if defined __SUNPRO_CC 833 #pragma enable_warn 834 #elif defined _MSC_VER 835 #pragma warning(pop) 836 #endif 837