Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include "basiccharclass.hxx"
22 : #include "sbcomp.hxx"
23 :
24 : struct TokenTable { SbiToken t; const char *s; };
25 :
26 : static short nToken; // number of tokens
27 :
28 : static const TokenTable* pTokTable;
29 :
30 : static const TokenTable aTokTable_Basic [] = {
31 : { CAT, "&" },
32 : { MUL, "*" },
33 : { PLUS, "+" },
34 : { MINUS, "-" },
35 : { DIV, "/" },
36 : { EOS, ":" },
37 : { ASSIGN, ":=" },
38 : { LT, "<" },
39 : { LE, "<=" },
40 : { NE, "<>" },
41 : { EQ, "=" },
42 : { GT, ">" },
43 : { GE, ">=" },
44 : { ACCESS, "Access" },
45 : { ALIAS, "Alias" },
46 : { AND, "And" },
47 : { ANY, "Any" },
48 : { APPEND, "Append" },
49 : { AS, "As" },
50 : { ATTRIBUTE,"Attribute" },
51 : { BASE, "Base" },
52 : { BINARY, "Binary" },
53 : { TBOOLEAN, "Boolean" },
54 : { BYREF, "ByRef", },
55 : { TBYTE, "Byte", },
56 : { BYVAL, "ByVal", },
57 : { CALL, "Call" },
58 : { CASE, "Case" },
59 : { _CDECL_, "Cdecl" },
60 : { CLASSMODULE, "ClassModule" },
61 : { CLOSE, "Close" },
62 : { COMPARE, "Compare" },
63 : { COMPATIBLE,"Compatible" },
64 : { _CONST_, "Const" },
65 : { TCURRENCY,"Currency" },
66 : { TDATE, "Date" },
67 : { DECLARE, "Declare" },
68 : { DEFBOOL, "DefBool" },
69 : { DEFCUR, "DefCur" },
70 : { DEFDATE, "DefDate" },
71 : { DEFDBL, "DefDbl" },
72 : { DEFERR, "DefErr" },
73 : { DEFINT, "DefInt" },
74 : { DEFLNG, "DefLng" },
75 : { DEFOBJ, "DefObj" },
76 : { DEFSNG, "DefSng" },
77 : { DEFSTR, "DefStr" },
78 : { DEFVAR, "DefVar" },
79 : { DIM, "Dim" },
80 : { DO, "Do" },
81 : { TDOUBLE, "Double" },
82 : { EACH, "Each" },
83 : { ELSE, "Else" },
84 : { ELSEIF, "ElseIf" },
85 : { END, "End" },
86 : { ENDENUM, "End Enum" },
87 : { ENDFUNC, "End Function" },
88 : { ENDIF, "End If" },
89 : { ENDPROPERTY, "End Property" },
90 : { ENDSELECT,"End Select" },
91 : { ENDSUB, "End Sub" },
92 : { ENDTYPE, "End Type" },
93 : { ENDIF, "EndIf" },
94 : { ENUM, "Enum" },
95 : { EQV, "Eqv" },
96 : { ERASE, "Erase" },
97 : { _ERROR_, "Error" },
98 : { EXIT, "Exit" },
99 : { BASIC_EXPLICIT, "Explicit" },
100 : { FOR, "For" },
101 : { FUNCTION, "Function" },
102 : { GET, "Get" },
103 : { GLOBAL, "Global" },
104 : { GOSUB, "GoSub" },
105 : { GOTO, "GoTo" },
106 : { IF, "If" },
107 : { IMP, "Imp" },
108 : { IMPLEMENTS, "Implements" },
109 : { _IN_, "In" },
110 : { INPUT, "Input" }, // also INPUT #
111 : { TINTEGER, "Integer" },
112 : { IS, "Is" },
113 : { LET, "Let" },
114 : { LIB, "Lib" },
115 : { LIKE, "Like" },
116 : { LINE, "Line" },
117 : { LINEINPUT,"Line Input" },
118 : { LOCAL, "Local" },
119 : { LOCK, "Lock" },
120 : { TLONG, "Long" },
121 : { LOOP, "Loop" },
122 : { LPRINT, "LPrint" },
123 : { LSET, "LSet" }, // JSM
124 : { MOD, "Mod" },
125 : { NAME, "Name" },
126 : { NEW, "New" },
127 : { NEXT, "Next" },
128 : { NOT, "Not" },
129 : { TOBJECT, "Object" },
130 : { ON, "On" },
131 : { OPEN, "Open" },
132 : { OPTION, "Option" },
133 : { _OPTIONAL_, "Optional" },
134 : { OR, "Or" },
135 : { OUTPUT, "Output" },
136 : { PARAMARRAY, "ParamArray" },
137 : { PRESERVE, "Preserve" },
138 : { PRINT, "Print" },
139 : { PRIVATE, "Private" },
140 : { PROPERTY, "Property" },
141 : { PUBLIC, "Public" },
142 : { RANDOM, "Random" },
143 : { READ, "Read" },
144 : { REDIM, "ReDim" },
145 : { REM, "Rem" },
146 : { RESUME, "Resume" },
147 : { RETURN, "Return" },
148 : { RSET, "RSet" }, // JSM
149 : { SELECT, "Select" },
150 : { SET, "Set" },
151 : #ifdef SHARED
152 : #undef SHARED
153 : #define tmpSHARED
154 : #endif
155 : { SHARED, "Shared" },
156 : #ifdef tmpSHARED
157 : #define SHARED
158 : #undef tmpSHARED
159 : #endif
160 : { TSINGLE, "Single" },
161 : { STATIC, "Static" },
162 : { STEP, "Step" },
163 : { STOP, "Stop" },
164 : { TSTRING, "String" },
165 : { SUB, "Sub" },
166 : { STOP, "System" },
167 : { TEXT, "Text" },
168 : { THEN, "Then" },
169 : { TO, "To", },
170 : { TYPE, "Type" },
171 : { TYPEOF, "TypeOf" },
172 : { UNTIL, "Until" },
173 : { TVARIANT, "Variant" },
174 : { VBASUPPORT, "VbaSupport" },
175 : { WEND, "Wend" },
176 : { WHILE, "While" },
177 : { WITH, "With" },
178 : { WITHEVENTS, "WithEvents" },
179 : { WRITE, "Write" }, // also WRITE #
180 : { XOR, "Xor" },
181 : { NIL, "" }
182 : };
183 :
184 :
185 : // #i109076
186 387 : TokenLabelInfo::TokenLabelInfo( void )
187 : {
188 387 : m_pTokenCanBeLabelTab = new bool[VBASUPPORT+1];
189 102942 : for( int i = 0 ; i <= VBASUPPORT ; ++i )
190 : {
191 102555 : m_pTokenCanBeLabelTab[i] = false;
192 : }
193 : // Token accepted as label by VBA
194 : SbiToken eLabelToken[] = { ACCESS, ALIAS, APPEND, BASE, BINARY, CLASSMODULE,
195 : COMPARE, COMPATIBLE, DEFERR, _ERROR_, BASIC_EXPLICIT, LIB, LINE, LPRINT, NAME,
196 387 : TOBJECT, OUTPUT, PROPERTY, RANDOM, READ, STEP, STOP, TEXT, VBASUPPORT, NIL };
197 387 : SbiToken* pTok = eLabelToken;
198 : SbiToken eTok;
199 9675 : for( pTok = eLabelToken ; (eTok = *pTok) != NIL ; ++pTok )
200 : {
201 9288 : m_pTokenCanBeLabelTab[eTok] = true;
202 : }
203 387 : }
204 :
205 2548 : TokenLabelInfo::~TokenLabelInfo()
206 : {
207 2548 : delete[] m_pTokenCanBeLabelTab;
208 2548 : }
209 :
210 :
211 : // the constructor detects the length of the token table
212 :
213 387 : SbiTokenizer::SbiTokenizer( const OUString& rSrc, StarBASIC* pb )
214 : : SbiScanner(rSrc, pb)
215 : , eCurTok(NIL)
216 : , ePush(NIL)
217 : , nPLine(0)
218 : , nPCol1(0)
219 : , nPCol2(0)
220 : , bEof(false)
221 : , bEos(true)
222 : , bKeywords(true)
223 : , bAs(false)
224 387 : , bErrorIsSymbol(true)
225 : {
226 387 : pTokTable = aTokTable_Basic;
227 387 : if( !nToken )
228 : {
229 : const TokenTable *tp;
230 35 : for( nToken = 0, tp = pTokTable; tp->t; nToken++, tp++ )
231 : {}
232 : }
233 387 : }
234 :
235 2548 : SbiTokenizer::~SbiTokenizer()
236 : {
237 2548 : }
238 :
239 :
240 3270 : void SbiTokenizer::Push( SbiToken t )
241 : {
242 3270 : if( ePush != NIL )
243 0 : Error( SbERR_INTERNAL_ERROR, "PUSH" );
244 3270 : else ePush = t;
245 3270 : }
246 :
247 0 : void SbiTokenizer::Error( SbError code, const char* pMsg )
248 : {
249 0 : aError = OUString::createFromAscii( pMsg );
250 0 : Error( code );
251 0 : }
252 :
253 0 : void SbiTokenizer::Error( SbError code, const OUString &aMsg )
254 : {
255 0 : aError = aMsg;
256 0 : Error( code );
257 0 : }
258 :
259 0 : void SbiTokenizer::Error( SbError code, SbiToken tok )
260 : {
261 0 : aError = Symbol( tok );
262 0 : Error( code );
263 0 : }
264 :
265 : // reading in the next token without absorbing it
266 :
267 214003 : SbiToken SbiTokenizer::Peek()
268 : {
269 214003 : if( ePush == NIL )
270 : {
271 50350 : sal_uInt16 nOldLine = nLine;
272 50350 : sal_uInt16 nOldCol1 = nCol1;
273 50350 : sal_uInt16 nOldCol2 = nCol2;
274 50350 : ePush = Next();
275 50350 : nPLine = nLine; nLine = nOldLine;
276 50350 : nPCol1 = nCol1; nCol1 = nOldCol1;
277 50350 : nPCol2 = nCol2; nCol2 = nOldCol2;
278 : }
279 214003 : return eCurTok = ePush;
280 : }
281 :
282 : // For decompilation. Numbers and symbols return an empty string.
283 :
284 52 : const OUString& SbiTokenizer::Symbol( SbiToken t )
285 : {
286 : // character token?
287 52 : if( t < FIRSTKWD )
288 : {
289 0 : aSym = OUString(sal::static_int_cast<sal_Unicode>(t));
290 0 : return aSym;
291 : }
292 52 : switch( t )
293 : {
294 : case NEG :
295 0 : aSym = "-";
296 0 : return aSym;
297 : case EOS :
298 0 : aSym = ":/CRLF";
299 0 : return aSym;
300 : case EOLN :
301 0 : aSym = "CRLF";
302 0 : return aSym;
303 : default:
304 52 : break;
305 : }
306 52 : const TokenTable* tp = pTokTable;
307 7106 : for( short i = 0; i < nToken; i++, tp++ )
308 : {
309 7060 : if( tp->t == t )
310 : {
311 6 : aSym = OStringToOUString(tp->s, RTL_TEXTENCODING_ASCII_US);
312 6 : return aSym;
313 : }
314 : }
315 46 : const sal_Unicode *p = aSym.getStr();
316 46 : if (*p <= ' ')
317 : {
318 0 : aSym = "???";
319 : }
320 46 : return aSym;
321 : }
322 :
323 : // Reading in the next token and put it down.
324 : // Tokens that don't appear in the token table
325 : // are directly returned as a character.
326 : // Some words are treated in a special way.
327 :
328 161922 : SbiToken SbiTokenizer::Next()
329 : {
330 161922 : if (bEof)
331 : {
332 0 : return EOLN;
333 : }
334 : // have read in one already?
335 161922 : if( ePush != NIL )
336 : {
337 53427 : eCurTok = ePush;
338 53427 : ePush = NIL;
339 53427 : nLine = nPLine;
340 53427 : nCol1 = nPCol1;
341 53427 : nCol2 = nPCol2;
342 53427 : bEos = IsEoln( eCurTok );
343 53427 : return eCurTok;
344 : }
345 : const TokenTable *tp;
346 :
347 108495 : if( !NextSym() )
348 : {
349 387 : bEof = bEos = true;
350 387 : return eCurTok = EOLN;
351 : }
352 :
353 108108 : if( aSym.startsWith("\n") )
354 : {
355 16079 : bEos = true;
356 16079 : return eCurTok = EOLN;
357 : }
358 92029 : bEos = false;
359 :
360 92029 : if( bNumber )
361 : {
362 3918 : return eCurTok = NUMBER;
363 : }
364 88111 : else if( ( eScanType == SbxDATE || eScanType == SbxSTRING ) && !bSymbol )
365 : {
366 6535 : return eCurTok = FIXSTRING;
367 : }
368 81576 : else if( aSym.isEmpty() )
369 : {
370 : //something went wrong
371 0 : bEof = bEos = true;
372 0 : return eCurTok = EOLN;
373 : }
374 : // Special cases of characters that are between "Z" and "a". ICompare()
375 : // evaluates the position of these characters in different ways.
376 81576 : else if( aSym[0] == '^' )
377 : {
378 0 : return eCurTok = EXPON;
379 : }
380 81576 : else if( aSym[0] == '\\' )
381 : {
382 0 : return eCurTok = IDIV;
383 : }
384 : else
385 : {
386 81576 : if( eScanType != SbxVARIANT
387 80979 : || ( !bKeywords && bSymbol ) )
388 597 : return eCurTok = SYMBOL;
389 : // valid token?
390 80979 : short lb = 0;
391 80979 : short ub = nToken-1;
392 : short delta;
393 623936 : do
394 : {
395 651473 : delta = (ub - lb) >> 1;
396 651473 : tp = &pTokTable[ lb + delta ];
397 651473 : sal_Int32 res = aSym.compareToIgnoreAsciiCaseAscii( tp->s );
398 :
399 651473 : if( res == 0 )
400 : {
401 27537 : goto special;
402 : }
403 623936 : if( res < 0 )
404 : {
405 392358 : if ((ub - lb) == 2)
406 : {
407 53958 : ub = lb;
408 : }
409 : else
410 : {
411 338400 : ub = ub - delta;
412 : }
413 : }
414 : else
415 : {
416 231578 : if ((ub -lb) == 2)
417 : {
418 1487 : lb = ub;
419 : }
420 : else
421 : {
422 230091 : lb = lb + delta;
423 : }
424 : }
425 : }
426 : while( delta );
427 : // Symbol? if not >= token
428 53442 : sal_Unicode ch = aSym[0];
429 53442 : if( !theBasicCharClass::get().isAlpha( ch, bCompatible ) && !bSymbol )
430 : {
431 24463 : return eCurTok = (SbiToken) (ch & 0x00FF);
432 : }
433 28979 : return eCurTok = SYMBOL;
434 : }
435 : special:
436 : // #i92642
437 27537 : bool bStartOfLine = (eCurTok == NIL || eCurTok == REM || eCurTok == EOLN);
438 27537 : if( !bStartOfLine && (tp->t == NAME || tp->t == LINE) )
439 : {
440 141 : return eCurTok = SYMBOL;
441 : }
442 27396 : else if( tp->t == TEXT )
443 : {
444 72 : return eCurTok = SYMBOL;
445 : }
446 : // maybe we can expand this for other statements that have parameters
447 : // that are keywords ( and those keywords are only used within such
448 : // statements )
449 : // what's happening here is that if we come across 'append' ( and we are
450 : // not in the middle of parsing a special statement ( like 'Open')
451 : // we just treat keyword 'append' as a normal 'SYMBOL'.
452 : // Also we accept Dim APPEND
453 27324 : else if ( ( !bInStatement || eCurTok == DIM ) && tp->t == APPEND )
454 : {
455 0 : return eCurTok = SYMBOL;
456 : }
457 : // #i92642: Special LINE token handling -> SbiParser::Line()
458 :
459 : // END IF, CASE, SUB, DEF, FUNCTION, TYPE, CLASS, WITH
460 27324 : if( tp->t == END )
461 : {
462 : // from 15.3.96, special treatment for END, at Peek() the current
463 : // time is lost, so memorize everything and restore after
464 1439 : sal_uInt16 nOldLine = nLine;
465 1439 : sal_uInt16 nOldCol = nCol;
466 1439 : sal_uInt16 nOldCol1 = nCol1;
467 1439 : sal_uInt16 nOldCol2 = nCol2;
468 1439 : OUString aOldSym = aSym;
469 1439 : SaveLine(); // save pLine in the scanner
470 :
471 1439 : eCurTok = Peek();
472 1439 : switch( eCurTok )
473 : {
474 533 : case IF: Next(); eCurTok = ENDIF; break;
475 16 : case SELECT: Next(); eCurTok = ENDSELECT; break;
476 568 : case SUB: Next(); eCurTok = ENDSUB; break;
477 261 : case FUNCTION: Next(); eCurTok = ENDFUNC; break;
478 0 : case PROPERTY: Next(); eCurTok = ENDPROPERTY; break;
479 0 : case TYPE: Next(); eCurTok = ENDTYPE; break;
480 0 : case ENUM: Next(); eCurTok = ENDENUM; break;
481 39 : case WITH: Next(); eCurTok = ENDWITH; break;
482 22 : default : eCurTok = END; break;
483 : }
484 1439 : nCol1 = nOldCol1;
485 1439 : if( eCurTok == END )
486 : {
487 : // reset everything so that token is read completely newly after END
488 22 : ePush = NIL;
489 22 : nLine = nOldLine;
490 22 : nCol = nOldCol;
491 22 : nCol2 = nOldCol2;
492 22 : aSym = aOldSym;
493 22 : RestoreLine();
494 : }
495 1439 : return eCurTok;
496 : }
497 : // are data types keywords?
498 : // there is ERROR(), DATA(), STRING() etc.
499 25885 : eCurTok = tp->t;
500 : // AS: data types are keywords
501 25885 : if( tp->t == AS )
502 : {
503 1958 : bAs = true;
504 : }
505 : else
506 : {
507 23927 : if( bAs )
508 : {
509 1955 : bAs = false;
510 : }
511 21972 : else if( eCurTok >= DATATYPE1 && eCurTok <= DATATYPE2 && (bErrorIsSymbol || eCurTok != _ERROR_) )
512 : {
513 125 : eCurTok = SYMBOL;
514 : }
515 : }
516 :
517 : // CLASSMODULE, PROPERTY, GET, ENUM token only visible in compatible mode
518 25885 : SbiToken eTok = tp->t;
519 25885 : if( bCompatible )
520 : {
521 : // #129904 Suppress system
522 19690 : if( eTok == STOP && aSym.equalsIgnoreAsciiCase("system") )
523 : {
524 0 : eCurTok = SYMBOL;
525 : }
526 19690 : if( eTok == GET && bStartOfLine )
527 : {
528 0 : eCurTok = SYMBOL;
529 : }
530 : }
531 : else
532 : {
533 6195 : if( eTok == CLASSMODULE ||
534 6195 : eTok == IMPLEMENTS ||
535 6195 : eTok == PARAMARRAY ||
536 6195 : eTok == ENUM ||
537 6195 : eTok == PROPERTY ||
538 6195 : eTok == GET ||
539 : eTok == TYPEOF )
540 : {
541 0 : eCurTok = SYMBOL;
542 : }
543 : }
544 :
545 25885 : bEos = IsEoln( eCurTok );
546 25885 : return eCurTok;
547 : }
548 :
549 6158 : bool SbiTokenizer::MayBeLabel( bool bNeedsColon )
550 : {
551 6158 : if( eCurTok == SYMBOL || m_aTokenLabelInfo.canTokenBeLabel( eCurTok ) )
552 : {
553 3128 : return bNeedsColon ? DoesColonFollow() : true;
554 : }
555 : else
556 : {
557 3030 : return ( eCurTok == NUMBER
558 1 : && eScanType == SbxINTEGER
559 3031 : && nVal >= 0 );
560 : }
561 : }
562 :
563 :
564 0 : OUString SbiTokenizer::GetKeywordCase( const OUString& sKeyword )
565 : {
566 0 : if( !nToken )
567 : {
568 : const TokenTable *tp;
569 0 : for( nToken = 0, tp = pTokTable; tp->t; nToken++, tp++ )
570 : {}
571 : }
572 0 : const TokenTable* tp = pTokTable;
573 0 : for( short i = 0; i < nToken; i++, tp++ )
574 : {
575 0 : OUString sStr = OStringToOUString(tp->s, RTL_TEXTENCODING_ASCII_US);
576 0 : if( sStr.equalsIgnoreAsciiCase(sKeyword) )
577 : {
578 0 : return sStr;
579 : }
580 0 : }
581 0 : return OUString("");
582 : }
583 :
584 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
