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 : #include "basiccharclass.hxx"
21 : #include "scanner.hxx"
22 : #include "sbintern.hxx"
23 :
24 : #include <vcl/svapp.hxx>
25 :
26 534 : SbiScanner::SbiScanner( const OUString& rBuf, StarBASIC* p ) : aBuf( rBuf )
27 : {
28 534 : pBasic = p;
29 534 : pLine = NULL;
30 534 : nVal = 0;
31 534 : eScanType = SbxVARIANT;
32 534 : nErrors = 0;
33 534 : nBufPos = 0;
34 534 : nCurCol1 = 0;
35 534 : nSavedCol1 = 0;
36 534 : nColLock = 0;
37 534 : nLine = 0;
38 534 : nCol1 = 0;
39 534 : nCol2 = 0;
40 534 : nCol = 0;
41 : bError =
42 : bAbort =
43 : bSpaces =
44 : bNumber =
45 : bSymbol =
46 : bCompatible =
47 : bVBASupportOn =
48 : bInStatement =
49 534 : bPrevLineExtentsComment = false;
50 534 : bHash = true;
51 534 : pSaveLine = NULL;
52 534 : }
53 :
54 2782 : SbiScanner::~SbiScanner()
55 2782 : {}
56 :
57 9928 : void SbiScanner::LockColumn()
58 : {
59 9928 : if( !nColLock++ )
60 7144 : nSavedCol1 = nCol1;
61 9928 : }
62 :
63 9667 : void SbiScanner::UnlockColumn()
64 : {
65 9667 : if( nColLock )
66 6616 : nColLock--;
67 9667 : }
68 :
69 8 : void SbiScanner::GenError( SbError code )
70 : {
71 8 : if( GetSbData()->bBlockCompilerError )
72 : {
73 0 : bAbort = true;
74 8 : return;
75 : }
76 8 : if( !bError )
77 : {
78 8 : bool bRes = true;
79 : // report only one error per statement
80 8 : bError = true;
81 8 : if( pBasic )
82 : {
83 : // in case of EXPECTED or UNEXPECTED it always refers
84 : // to the last token, so take the Col1 over
85 0 : sal_Int32 nc = nColLock ? nSavedCol1 : nCol1;
86 0 : switch( code )
87 : {
88 : case SbERR_EXPECTED:
89 : case SbERR_UNEXPECTED:
90 : case SbERR_SYMBOL_EXPECTED:
91 : case SbERR_LABEL_EXPECTED:
92 0 : nc = nCol1;
93 0 : if( nc > nCol2 ) nCol2 = nc;
94 0 : break;
95 : }
96 0 : bRes = pBasic->CError( code, aError, nLine, nc, nCol2 );
97 : }
98 8 : bAbort = bAbort || !bRes || ( code == SbERR_NO_MEMORY || code == SbERR_PROG_TOO_LARGE );
99 : }
100 8 : nErrors++;
101 : }
102 :
103 :
104 : // used by SbiTokenizer::MayBeLabel() to detect a label
105 3238 : bool SbiScanner::DoesColonFollow()
106 : {
107 3238 : if(nCol < aLine.getLength() && aLine[nCol] == ':')
108 : {
109 55 : ++pLine; ++nCol;
110 55 : return true;
111 : }
112 : else
113 3183 : return false;
114 : }
115 :
116 : // test for legal suffix
117 41639 : static SbxDataType GetSuffixType( sal_Unicode c )
118 : {
119 41639 : switch (c)
120 : {
121 : case '%':
122 206 : return SbxDataType(SbxINTEGER);
123 : case '&':
124 2 : return SbxDataType(SbxLONG);
125 : case '!':
126 1 : return SbxDataType(SbxSINGLE);
127 : case '#':
128 5 : return SbxDataType(SbxDOUBLE);
129 : case '@':
130 1 : return SbxDataType(SbxCURRENCY);
131 : case '$':
132 421 : return SbxDataType(SbxSTRING);
133 : default:
134 41003 : return SbxDataType(SbxVARIANT);
135 : }
136 : }
137 :
138 : // reading the next symbol into the variables aSym, nVal and eType
139 : // return value is sal_False at EOF or errors
140 : #define BUF_SIZE 80
141 :
142 47092 : void SbiScanner::scanAlphanumeric()
143 : {
144 47092 : sal_Int32 n = nCol;
145 415521 : while(nCol < aLine.getLength() && (BasicCharClass::isAlphaNumeric(aLine[nCol], bCompatible) || aLine[nCol] == '_'))
146 : {
147 321337 : ++pLine;
148 321337 : ++nCol;
149 : }
150 47092 : aSym = aLine.copy(n, nCol - n);
151 47092 : }
152 :
153 1 : void SbiScanner::scanGoto()
154 : {
155 1 : sal_Int32 n = nCol;
156 4 : while(n < aLine.getLength() && BasicCharClass::isWhitespace(aLine[n]))
157 2 : ++n;
158 :
159 1 : if(n + 1 < aLine.getLength())
160 : {
161 1 : OUString aTemp = aLine.copy(n, 2);
162 1 : if(aTemp.equalsIgnoreAsciiCase("to"))
163 : {
164 1 : aSym = "goto";
165 1 : pLine += n + 2 - nCol;
166 1 : nCol = n + 2;
167 1 : }
168 : }
169 1 : }
170 :
171 20209 : bool SbiScanner::readLine()
172 : {
173 20209 : if(nBufPos >= aBuf.getLength())
174 534 : return false;
175 :
176 19675 : sal_Int32 n = nBufPos;
177 19675 : sal_Int32 nLen = aBuf.getLength();
178 :
179 672195 : while(n < nLen && aBuf[n] != '\r' && aBuf[n] != '\n')
180 632845 : ++n;
181 :
182 : // Trim trailing whitespace
183 19675 : sal_Int32 nEnd = n;
184 42852 : while(nBufPos < nEnd && BasicCharClass::isWhitespace(aBuf[nEnd - 1]))
185 3502 : --nEnd;
186 :
187 19675 : aLine = aBuf.copy(nBufPos, nEnd - nBufPos);
188 :
189 : // Fast-forward past the line ending
190 19675 : if(n + 1 < nLen && aBuf[n] == '\r' && aBuf[n + 1] == '\n')
191 5 : n += 2;
192 19670 : else if(n < nLen)
193 19534 : ++n;
194 :
195 19675 : nBufPos = n;
196 19675 : pLine = aLine.getStr();
197 :
198 19675 : ++nLine;
199 19675 : nCol = nCol1 = nCol2 = 0;
200 19675 : nColLock = 0;
201 :
202 19675 : return true;
203 : }
204 :
205 115967 : bool SbiScanner::NextSym()
206 : {
207 : // memorize for the EOLN-case
208 115967 : sal_Int32 nOldLine = nLine;
209 115967 : sal_Int32 nOldCol1 = nCol1;
210 115967 : sal_Int32 nOldCol2 = nCol2;
211 115967 : sal_Unicode buf[ BUF_SIZE ], *p = buf;
212 :
213 115967 : eScanType = SbxVARIANT;
214 115967 : aSym.clear();
215 115967 : bHash = bSymbol = bNumber = bSpaces = false;
216 :
217 : // read in line?
218 115967 : if( !pLine )
219 : {
220 20209 : if(!readLine())
221 534 : return false;
222 :
223 19675 : nOldLine = nLine;
224 19675 : nOldCol1 = nOldCol2 = 0;
225 : }
226 :
227 115433 : if(nCol < aLine.getLength() && BasicCharClass::isWhitespace(aLine[nCol]))
228 : {
229 52873 : bSpaces = true;
230 194391 : while(nCol < aLine.getLength() && BasicCharClass::isWhitespace(aLine[nCol]))
231 88645 : ++pLine, ++nCol;
232 : }
233 :
234 115433 : nCol1 = nCol;
235 :
236 : // only blank line?
237 115433 : if(nCol >= aLine.getLength())
238 17406 : goto eoln;
239 :
240 98027 : if( bPrevLineExtentsComment )
241 0 : goto PrevLineCommentLbl;
242 :
243 98027 : if(nCol < aLine.getLength() && aLine[nCol] == '#')
244 : {
245 62 : ++pLine;
246 62 : ++nCol;
247 62 : bHash = true;
248 : }
249 :
250 : // copy character if symbol
251 98027 : if(nCol < aLine.getLength() && (BasicCharClass::isAlpha(aLine[nCol], bCompatible) || aLine[nCol] == '_'))
252 : {
253 : // if there's nothing behind '_' , it's the end of a line!
254 47144 : if(nCol + 1 == aLine.getLength() && aLine[nCol] == '_')
255 : {
256 : // Note that nCol is not incremented here...
257 52 : ++pLine;
258 52 : goto eoln;
259 : }
260 :
261 47092 : bSymbol = true;
262 :
263 47092 : scanAlphanumeric();
264 :
265 : // Special handling for "go to"
266 47092 : if(nCol < aLine.getLength() && bCompatible && aSym.equalsIgnoreAsciiCase("go"))
267 1 : scanGoto();
268 :
269 : // replace closing '_' by space when end of line is following
270 : // (wrong line continuation otherwise)
271 47092 : if(nCol == aLine.getLength() && aLine[nCol - 1] == '_' )
272 : {
273 : // We are going to modify a potentially shared string, so force
274 : // a copy, so that aSym is not modified by the following operation
275 1 : OUString aSymCopy( aSym.getStr(), aSym.getLength() );
276 1 : aSym = aSymCopy;
277 :
278 : // HACK: modifying a potentially shared string here!
279 1 : *const_cast<sal_Unicode*>(pLine-1) = ' ';
280 : }
281 :
282 : // type recognition?
283 : // don't test the exclamation mark
284 : // if there's a symbol behind it
285 94183 : else if((nCol >= aLine.getLength() || aLine[nCol] != '!') ||
286 3 : (nCol + 1 >= aLine.getLength() || !BasicCharClass::isAlpha(aLine[nCol + 1], bCompatible)))
287 : {
288 47090 : if(nCol < aLine.getLength())
289 : {
290 39137 : SbxDataType t(GetSuffixType(aLine[nCol]));
291 39137 : if( t != SbxVARIANT )
292 : {
293 632 : eScanType = t;
294 632 : ++pLine;
295 632 : ++nCol;
296 : }
297 : }
298 : }
299 : }
300 :
301 : // read in and convert if number
302 101768 : else if((nCol < aLine.getLength() && rtl::isAsciiDigit(aLine[nCol])) ||
303 89988 : (nCol + 1 < aLine.getLength() && aLine[nCol] == '.' && rtl::isAsciiDigit(aLine[nCol + 1])))
304 : {
305 4265 : short exp = 0;
306 4265 : short dec = 0;
307 4265 : eScanType = SbxDOUBLE;
308 4265 : bool bScanError = false;
309 4265 : bool bBufOverflow = false;
310 : // All this because of 'D' or 'd' floating point type, sigh..
311 15014 : while(!bScanError && nCol < aLine.getLength() && strchr("0123456789.DEde", aLine[nCol]))
312 : {
313 : // from 4.1.1996: buffer full? -> go on scanning empty
314 6484 : if( (p-buf) == (BUF_SIZE-1) )
315 : {
316 47 : bBufOverflow = true;
317 47 : ++pLine, ++nCol;
318 47 : continue;
319 : }
320 : // point or exponent?
321 6437 : if(aLine[nCol] == '.')
322 : {
323 168 : if( ++dec > 1 )
324 1 : bScanError = true;
325 : else
326 167 : *p++ = '.';
327 : }
328 6269 : else if(strchr("DdEe", aLine[nCol]))
329 : {
330 8 : if (++exp > 1)
331 1 : bScanError = true;
332 : else
333 : {
334 7 : *p++ = 'E';
335 7 : if (nCol + 1 < aLine.getLength() && (aLine[nCol+1] == '+' || aLine[nCol+1] == '-'))
336 : {
337 4 : ++pLine, ++nCol;
338 4 : if( (p-buf) == (BUF_SIZE-1) )
339 : {
340 0 : bBufOverflow = true;
341 0 : continue;
342 : }
343 4 : *p++ = aLine[nCol];
344 : }
345 : }
346 : }
347 : else
348 : {
349 6261 : *p++ = aLine[nCol];
350 : }
351 6437 : ++pLine, ++nCol;
352 : }
353 4265 : *p = 0;
354 4265 : aSym = p; bNumber = true;
355 :
356 : // For bad characters, scan and parse errors generate only one error.
357 4265 : SbError nError = 0;
358 4265 : if (bScanError)
359 : {
360 2 : --pLine, --nCol;
361 2 : aError = OUString( aLine[nCol]);
362 2 : nError = SbERR_BAD_CHAR_IN_NUMBER;
363 : }
364 :
365 4265 : rtl_math_ConversionStatus eStatus = rtl_math_ConversionStatus_Ok;
366 4265 : const sal_Unicode* pParseEnd = buf;
367 4265 : nVal = rtl_math_uStringToDouble( buf, buf+(p-buf), '.', ',', &eStatus, &pParseEnd );
368 4265 : if (pParseEnd != buf+(p-buf))
369 : {
370 : // e.g. "12e" or "12e+", or with bScanError "12d"+"E".
371 2 : sal_Int32 nChars = buf+(p-buf) - pParseEnd;
372 2 : pLine -= nChars;
373 2 : nCol -= nChars;
374 : // For bScanError, pLine and nCol were already decremented, just
375 : // add that character to the parse end.
376 2 : if (bScanError)
377 1 : ++nChars;
378 : // Copy error position from original string, not the buffer
379 : // replacement where "12dE" => "12EE".
380 2 : aError = aLine.copy( nCol, nChars);
381 2 : nError = SbERR_BAD_CHAR_IN_NUMBER;
382 : }
383 4263 : else if (eStatus != rtl_math_ConversionStatus_Ok)
384 : {
385 : // Keep the scan error and character at position, if any.
386 1 : if (!nError)
387 1 : nError = SbERR_MATH_OVERFLOW;
388 : }
389 :
390 4265 : if (nError)
391 4 : GenError( nError );
392 :
393 4265 : if( !dec && !exp )
394 : {
395 4091 : if( nVal >= SbxMININT && nVal <= SbxMAXINT )
396 4062 : eScanType = SbxINTEGER;
397 29 : else if( nVal >= SbxMINLNG && nVal <= SbxMAXLNG )
398 25 : eScanType = SbxLONG;
399 : }
400 :
401 4265 : if( bBufOverflow )
402 1 : GenError( SbERR_MATH_OVERFLOW );
403 :
404 : // type recognition?
405 4265 : if( nCol < aLine.getLength() )
406 : {
407 2502 : SbxDataType t(GetSuffixType(aLine[nCol]));
408 2502 : if( t != SbxVARIANT )
409 : {
410 4 : eScanType = t;
411 4 : ++pLine;
412 4 : ++nCol;
413 : }
414 : }
415 : }
416 :
417 : // Hex/octal number? Read in and convert:
418 46618 : else if(nCol < aLine.getLength() && aLine[nCol] == '&')
419 : {
420 2157 : ++pLine; ++nCol;
421 2157 : sal_Unicode base = 16;
422 2157 : sal_Unicode xch = aLine[nCol];
423 2157 : ++pLine; ++nCol;
424 2157 : switch( rtl::toAsciiUpperCase( xch ) )
425 : {
426 : case 'O':
427 3 : base = 8;
428 3 : break;
429 : case 'H':
430 14 : break;
431 : default :
432 : // treated as an operator
433 2140 : --pLine; --nCol; nCol1 = nCol-1;
434 2140 : aSym = "&";
435 2140 : return true;
436 : }
437 17 : bNumber = true;
438 : // Hex literals are signed Integers ( as defined by basic
439 : // e.g. -2,147,483,648 through 2,147,483,647 (signed)
440 17 : sal_uInt64 lu = 0;
441 17 : bool bOverflow = false;
442 119 : while(nCol < aLine.getLength() && BasicCharClass::isAlphaNumeric(aLine[nCol], false))
443 : {
444 85 : sal_Unicode ch = rtl::toAsciiUpperCase(aLine[nCol]);
445 85 : ++pLine; ++nCol;
446 168 : if( ((base == 16 ) && rtl::isAsciiHexDigit( ch ) ) ||
447 26 : ((base == 8) && rtl::isAsciiOctalDigit( ch )))
448 : {
449 83 : int i = ch - '0';
450 83 : if( i > 9 ) i -= 7;
451 83 : lu = ( lu * base ) + i;
452 83 : if( lu > SAL_MAX_UINT32 )
453 : {
454 13 : bOverflow = true;
455 : }
456 : }
457 : else
458 : {
459 2 : aError = OUString(ch);
460 2 : GenError( SbERR_BAD_CHAR_IN_NUMBER );
461 : }
462 : }
463 17 : if(nCol < aLine.getLength() && aLine[nCol] == '&') ++pLine, ++nCol;
464 17 : sal_Int32 ls = static_cast<sal_Int32>(lu);
465 17 : nVal = (double) ls;
466 17 : eScanType = ( ls >= SbxMININT && ls <= SbxMAXINT ) ? SbxINTEGER : SbxLONG;
467 17 : if( bOverflow )
468 1 : GenError( SbERR_MATH_OVERFLOW );
469 : }
470 :
471 : // Strings:
472 44461 : else if( *pLine == '"' || *pLine == '[' )
473 : {
474 7057 : sal_Unicode cSep = *pLine;
475 7057 : if( cSep == '[' )
476 8 : bSymbol = true, cSep = ']';
477 7057 : sal_Int32 n = nCol + 1;
478 14538 : while( *pLine )
479 : {
480 98715 : do pLine++, nCol++;
481 98715 : while( *pLine && ( *pLine != cSep ) );
482 7481 : if( *pLine == cSep )
483 : {
484 7481 : pLine++; nCol++;
485 7481 : if( *pLine != cSep || cSep == ']' )
486 : {
487 : // If VBA Interop then doen't eat the [] chars
488 7057 : if ( cSep == ']' && bVBASupportOn )
489 4 : aSym = aLine.copy( n - 1, nCol - n + 1);
490 : else
491 7053 : aSym = aLine.copy( n, nCol - n - 1 );
492 : // get out duplicate string delimiters
493 7057 : OUStringBuffer aSymBuf;
494 98723 : for ( sal_Int32 i = 0, len = aSym.getLength(); i < len; ++i )
495 : {
496 91666 : aSymBuf.append( aSym[i] );
497 91666 : if ( aSym[i] == cSep && ( i+1 < len ) && aSym[i+1] == cSep )
498 424 : ++i;
499 : }
500 7057 : aSym = aSymBuf.makeStringAndClear();
501 7057 : if( cSep != ']' )
502 7049 : eScanType = ( cSep == '#' ) ? SbxDATE : SbxSTRING;
503 7057 : break;
504 : }
505 0 : } else aError = OUString(cSep), GenError( SbERR_EXPECTED );
506 7057 : }
507 : }
508 : // invalid characters:
509 37404 : else if( *pLine >= 0x7F )
510 : {
511 0 : GenError( SbERR_SYNTAX ); pLine++; nCol++;
512 : }
513 : // other groups:
514 : else
515 : {
516 37404 : sal_Int32 n = 1;
517 37404 : switch( *pLine++ )
518 : {
519 370 : case '<': if( *pLine == '>' || *pLine == '=' ) n = 2; break;
520 70 : case '>': if( *pLine == '=' ) n = 2; break;
521 398 : case ':': if( *pLine == '=' ) n = 2; break;
522 : }
523 37404 : aSym = aLine.copy( nCol, n );
524 37404 : pLine += n-1; nCol = nCol + n;
525 : }
526 :
527 95835 : nCol2 = nCol-1;
528 :
529 : PrevLineCommentLbl:
530 :
531 186416 : if( bPrevLineExtentsComment || (eScanType != SbxSTRING &&
532 174988 : ( aSym.startsWith("'") || aSym.equalsIgnoreAsciiCase( "REM" ) ) ) )
533 : {
534 2216 : bPrevLineExtentsComment = false;
535 2216 : aSym = "REM";
536 2216 : sal_Int32 nLen = rtl_ustr_getLength(pLine);
537 2216 : if( bCompatible && pLine[ nLen - 1 ] == '_' && pLine[ nLen - 2 ] == ' ' )
538 0 : bPrevLineExtentsComment = true;
539 2216 : nCol2 = nCol2 + nLen;
540 2216 : pLine = NULL;
541 : }
542 95835 : return true;
543 :
544 :
545 : eoln:
546 17458 : if( nCol && *--pLine == '_' )
547 : {
548 52 : pLine = NULL;
549 52 : bool bRes = NextSym();
550 52 : if( bVBASupportOn && aSym[0] == '.' )
551 : {
552 : // object _
553 : // .Method
554 : // ^^^ <- spaces is legal in MSO VBA
555 : OSL_TRACE("*** resetting bSpaces***");
556 0 : bSpaces = false;
557 : }
558 52 : return bRes;
559 : }
560 : else
561 : {
562 17406 : pLine = NULL;
563 17406 : nLine = nOldLine;
564 17406 : nCol1 = nOldCol1;
565 17406 : nCol2 = nOldCol2;
566 17406 : aSym = "\n";
567 17406 : nColLock = 0;
568 17406 : return true;
569 : }
570 : }
571 :
572 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
