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