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 <basic/sbx.hxx>
21 : #include "sbunoobj.hxx"
22 : #include "parser.hxx"
23 : #include <svtools/miscopt.hxx>
24 : #include <osl/diagnose.h>
25 : #include <com/sun/star/reflection/theCoreReflection.hpp>
26 : #include <comphelper/namedvaluecollection.hxx>
27 : #include <comphelper/processfactory.hxx>
28 : #include <com/sun/star/reflection/XInterfaceMemberTypeDescription.hpp>
29 : #include <com/sun/star/reflection/XIdlMethod.hpp>
30 : #include <com/sun/star/uno/Exception.hpp>
31 : #include <basic/codecompletecache.hxx>
32 : #include <boost/scoped_ptr.hpp>
33 :
34 : using namespace ::com::sun::star;
35 : using namespace ::com::sun::star::uno;
36 :
37 : // Declaration of a variable
38 : // If there are errors it will be parsed up to the comma or the newline.
39 : // Return-value: a new instance, which were inserted and then deleted.
40 : // Array-Indexex were returned as SbiDimList
41 :
42 1109 : SbiSymDef* SbiParser::VarDecl( SbiDimList** ppDim, bool bStatic, bool bConst )
43 : {
44 1109 : bool bWithEvents = false;
45 1109 : if( Peek() == WITHEVENTS )
46 : {
47 0 : Next();
48 0 : bWithEvents = true;
49 : }
50 1109 : if( !TestSymbol() ) return NULL;
51 1109 : SbxDataType t = eScanType;
52 1109 : SbiSymDef* pDef = bConst ? new SbiConstDef( aSym ) : new SbiSymDef( aSym );
53 1109 : SbiDimList* pDim = NULL;
54 : // Brackets?
55 1109 : if( Peek() == LPAREN )
56 : {
57 45 : pDim = new SbiDimList( this );
58 45 : if( !pDim->GetDims() )
59 19 : pDef->SetWithBrackets();
60 : }
61 1109 : pDef->SetType( t );
62 1109 : if( bStatic )
63 0 : pDef->SetStatic();
64 1109 : if( bWithEvents )
65 0 : pDef->SetWithEvents();
66 1109 : TypeDecl( *pDef );
67 1109 : if( !ppDim && pDim )
68 : {
69 0 : if(pDim->GetDims() )
70 0 : Error( SbERR_EXPECTED, "()" );
71 0 : delete pDim;
72 : }
73 1109 : else if( ppDim )
74 889 : *ppDim = pDim;
75 1109 : return pDef;
76 : }
77 :
78 : // Resolving of a AS-Type-Declaration
79 : // The data type were inserted into the handed over variable
80 :
81 1528 : void SbiParser::TypeDecl( SbiSymDef& rDef, bool bAsNewAlreadyParsed )
82 : {
83 1528 : SbxDataType eType = rDef.GetType();
84 1528 : if( bAsNewAlreadyParsed || Peek() == AS )
85 : {
86 1029 : short nSize = 0;
87 1029 : if( !bAsNewAlreadyParsed )
88 1029 : Next();
89 1029 : rDef.SetDefinedAs();
90 1029 : SbiToken eTok = Next();
91 1029 : if( !bAsNewAlreadyParsed && eTok == NEW )
92 : {
93 28 : rDef.SetNew();
94 28 : eTok = Next();
95 : }
96 1029 : switch( eTok )
97 : {
98 : case ANY:
99 0 : if( rDef.IsNew() )
100 0 : Error( SbERR_SYNTAX );
101 0 : eType = SbxVARIANT; break;
102 : case TINTEGER:
103 : case TLONG:
104 : case TSINGLE:
105 : case TDOUBLE:
106 : case TCURRENCY:
107 : case TDATE:
108 : case TSTRING:
109 : case TOBJECT:
110 : case _ERROR_:
111 : case TBOOLEAN:
112 : case TVARIANT:
113 : case TBYTE:
114 890 : if( rDef.IsNew() )
115 0 : Error( SbERR_SYNTAX );
116 890 : eType = (eTok==TBYTE) ? SbxBYTE : SbxDataType( eTok - TINTEGER + SbxINTEGER );
117 890 : if( eType == SbxSTRING )
118 : {
119 : // STRING*n ?
120 460 : if( Peek() == MUL )
121 : { // fixed size!
122 0 : Next();
123 0 : SbiConstExpression aSize( this );
124 0 : nSize = aSize.GetShortValue();
125 0 : if( nSize < 0 || (bVBASupportOn && nSize <= 0) )
126 0 : Error( SbERR_OUT_OF_RANGE );
127 : else
128 0 : rDef.SetFixedStringLength( nSize );
129 : }
130 : }
131 890 : break;
132 : case SYMBOL: // can only be a TYPE or a object class!
133 125 : if( eScanType != SbxVARIANT )
134 0 : Error( SbERR_SYNTAX );
135 : else
136 : {
137 125 : OUString aCompleteName = aSym;
138 :
139 : // #52709 DIM AS NEW for Uno with full-qualified name
140 125 : if( Peek() == DOT )
141 : {
142 15 : OUString aDotStr( '.' );
143 15 : while( Peek() == DOT )
144 : {
145 57 : aCompleteName += aDotStr;
146 57 : Next();
147 57 : SbiToken ePeekTok = Peek();
148 57 : if( ePeekTok == SYMBOL || IsKwd( ePeekTok ) )
149 : {
150 57 : Next();
151 57 : aCompleteName += aSym;
152 : }
153 : else
154 : {
155 0 : Next();
156 0 : Error( SbERR_UNEXPECTED, SYMBOL );
157 0 : break;
158 : }
159 15 : }
160 : }
161 110 : else if( rEnumArray->Find( aCompleteName, SbxCLASS_OBJECT ) || ( IsVBASupportOn() && VBAConstantHelper::instance().isVBAConstantType( aCompleteName ) ) )
162 : {
163 0 : eType = SbxLONG;
164 0 : break;
165 : }
166 :
167 : // Take over in the string pool
168 125 : rDef.SetTypeId( aGblStrings.Add( aCompleteName ) );
169 :
170 125 : if( rDef.IsNew() && pProc == NULL )
171 0 : aRequiredTypes.push_back( aCompleteName );
172 : }
173 125 : eType = SbxOBJECT;
174 125 : break;
175 : case FIXSTRING: // new syntax for complex UNO types
176 14 : rDef.SetTypeId( aGblStrings.Add( aSym ) );
177 14 : eType = SbxOBJECT;
178 14 : break;
179 : default:
180 0 : Error( SbERR_UNEXPECTED, eTok );
181 0 : Next();
182 : }
183 : // The variable could have been declared with a suffix
184 1029 : if( rDef.GetType() != SbxVARIANT )
185 : {
186 139 : if( rDef.GetType() != eType )
187 0 : Error( SbERR_VAR_DEFINED, rDef.GetName() );
188 139 : else if( eType == SbxSTRING && rDef.GetLen() != nSize )
189 0 : Error( SbERR_VAR_DEFINED, rDef.GetName() );
190 : }
191 1029 : rDef.SetType( eType );
192 1029 : rDef.SetLen( nSize );
193 : }
194 1528 : }
195 :
196 : // Here variables, arrays and structures were definied.
197 : // DIM/PRIVATE/PUBLIC/GLOBAL
198 :
199 828 : void SbiParser::Dim()
200 : {
201 828 : DefVar( _DIM, pProc && bVBASupportOn && pProc->IsStatic() );
202 828 : }
203 :
204 829 : void SbiParser::DefVar( SbiOpcode eOp, bool bStatic )
205 : {
206 829 : SbiSymPool* pOldPool = pPool;
207 829 : bool bSwitchPool = false;
208 829 : bool bPersistantGlobal = false;
209 829 : SbiToken eFirstTok = eCurTok;
210 :
211 829 : if( pProc && ( eCurTok == GLOBAL || eCurTok == PUBLIC || eCurTok == PRIVATE ) )
212 0 : Error( SbERR_NOT_IN_SUBR, eCurTok );
213 829 : if( eCurTok == PUBLIC || eCurTok == GLOBAL )
214 : {
215 87 : bSwitchPool = true; // at the right moment switch to the global pool
216 87 : if( eCurTok == GLOBAL )
217 62 : bPersistantGlobal = true;
218 : }
219 : // behavior in VBA is that a module scope variable's lifetime is
220 : // tied to the document. e.g. a module scope variable is global
221 829 : if( GetBasic()->IsDocBasic() && bVBASupportOn && !pProc )
222 149 : bPersistantGlobal = true;
223 : // PRIVATE is a synonymous for DIM
224 : // _CONST_?
225 829 : bool bConst = false;
226 829 : if( eCurTok == _CONST_ )
227 29 : bConst = true;
228 800 : else if( Peek() == _CONST_ )
229 43 : Next(), bConst = true;
230 :
231 : // #110004 It can also be a sub/function
232 1554 : if( !bConst && (eCurTok == SUB || eCurTok == FUNCTION || eCurTok == PROPERTY ||
233 1450 : eCurTok == STATIC || eCurTok == ENUM || eCurTok == DECLARE || eCurTok == TYPE) )
234 : {
235 : // Next token is read here, because !bConst
236 37 : bool bPrivate = ( eFirstTok == PRIVATE );
237 :
238 37 : if( eCurTok == STATIC )
239 : {
240 0 : Next();
241 0 : DefStatic( bPrivate );
242 : }
243 37 : else if( eCurTok == SUB || eCurTok == FUNCTION || eCurTok == PROPERTY )
244 : {
245 : // End global chain if necessary (not done in
246 : // SbiParser::Parse() under these conditions
247 32 : if( bNewGblDefs && nGblChain == 0 )
248 : {
249 0 : nGblChain = aGen.Gen( _JUMP, 0 );
250 0 : bNewGblDefs = false;
251 : }
252 32 : Next();
253 32 : DefProc( false, bPrivate );
254 69 : return;
255 : }
256 5 : else if( eCurTok == ENUM )
257 : {
258 0 : Next();
259 0 : DefEnum( bPrivate );
260 0 : return;
261 : }
262 5 : else if( eCurTok == DECLARE )
263 : {
264 4 : Next();
265 4 : DefDeclare( bPrivate );
266 4 : return;
267 : }
268 : // #i109049
269 1 : else if( eCurTok == TYPE )
270 : {
271 1 : Next();
272 1 : DefType( bPrivate );
273 1 : return;
274 : }
275 : }
276 :
277 : #ifdef SHARED
278 : #define tmpSHARED
279 : #undef SHARED
280 : #endif
281 : // SHARED were ignored
282 792 : if( Peek() == SHARED ) Next();
283 : #ifdef tmpSHARED
284 : #define SHARED
285 : #undef tmpSHARED
286 : #endif
287 : // PRESERVE only at REDIM
288 792 : if( Peek() == PRESERVE )
289 : {
290 0 : Next();
291 0 : if( eOp == _REDIM )
292 0 : eOp = _REDIMP;
293 : else
294 0 : Error( SbERR_UNEXPECTED, eCurTok );
295 : }
296 : SbiSymDef* pDef;
297 : SbiDimList* pDim;
298 :
299 : // #40689, Statics -> Modul-Initialising, skip in Sub
300 792 : sal_uInt32 nEndOfStaticLbl = 0;
301 792 : if( !bVBASupportOn && bStatic )
302 : {
303 0 : nEndOfStaticLbl = aGen.Gen( _JUMP, 0 );
304 0 : aGen.Statement(); // catch up on static here
305 : }
306 :
307 792 : bool bDefined = false;
308 1679 : while( ( pDef = VarDecl( &pDim, bStatic, bConst ) ) != NULL )
309 : {
310 : /*fprintf(stderr, "Actual sub: \n");
311 : fprintf(stderr, "Symbol name: %s\n",OUStringToOString(pDef->GetName(),RTL_TEXTENCODING_UTF8).getStr());*/
312 887 : EnableErrors();
313 : // search variable:
314 887 : if( bSwitchPool )
315 136 : pPool = &aGlobals;
316 887 : SbiSymDef* pOld = pPool->Find( pDef->GetName() );
317 : // search also in the Runtime-Library
318 887 : bool bRtlSym = false;
319 887 : if( !pOld )
320 : {
321 882 : pOld = CheckRTLForSym( pDef->GetName(), SbxVARIANT );
322 882 : if( pOld )
323 1 : bRtlSym = true;
324 : }
325 887 : if( pOld && !(eOp == _REDIM || eOp == _REDIMP) )
326 : {
327 5 : if( pDef->GetScope() == SbLOCAL && pOld->GetScope() != SbLOCAL )
328 5 : pOld = NULL;
329 : }
330 887 : if( pOld )
331 : {
332 1 : bDefined = true;
333 : // always an error at a RTL-S
334 1 : if( !bRtlSym && (eOp == _REDIM || eOp == _REDIMP) )
335 : {
336 : // compare the attributes at a REDIM
337 : SbxDataType eDefType;
338 1 : bool bError_ = false;
339 1 : if( pOld->IsStatic() )
340 : {
341 0 : bError_ = true;
342 : }
343 1 : else if( pOld->GetType() != ( eDefType = pDef->GetType() ) )
344 : {
345 0 : if( !( eDefType == SbxVARIANT && !pDef->IsDefinedAs() ) )
346 0 : bError_ = true;
347 : }
348 1 : if( bError_ )
349 0 : Error( SbERR_VAR_DEFINED, pDef->GetName() );
350 : }
351 : else
352 0 : Error( SbERR_VAR_DEFINED, pDef->GetName() );
353 1 : delete pDef; pDef = pOld;
354 : }
355 : else
356 886 : pPool->Add( pDef );
357 :
358 : // #36374: Create the variable in front of the distinction IsNew()
359 : // Otherwise error at Dim Identifier As New Type and option explicit
360 2660 : if( !bDefined && !(eOp == _REDIM || eOp == _REDIMP)
361 1773 : && ( !bConst || pDef->GetScope() == SbGLOBAL ) )
362 : {
363 : // Declare variable or global constant
364 : SbiOpcode eOp2;
365 851 : switch ( pDef->GetScope() )
366 : {
367 136 : case SbGLOBAL: eOp2 = bPersistantGlobal ? _GLOBAL_P : _GLOBAL;
368 136 : goto global;
369 130 : case SbPUBLIC: eOp2 = bPersistantGlobal ? _PUBLIC_P : _PUBLIC;
370 : // #40689, no own Opcode anymore
371 130 : if( bVBASupportOn && bStatic )
372 : {
373 0 : eOp2 = _STATIC;
374 0 : break;
375 : }
376 266 : global: aGen.BackChain( nGblChain );
377 266 : nGblChain = 0;
378 266 : bGblDefs = bNewGblDefs = true;
379 266 : break;
380 585 : default: eOp2 = _LOCAL;
381 : }
382 851 : sal_uInt32 nOpnd2 = sal::static_int_cast< sal_uInt16 >( pDef->GetType() );
383 851 : if( pDef->IsWithEvents() )
384 0 : nOpnd2 |= SBX_TYPE_WITH_EVENTS_FLAG;
385 :
386 851 : if( bCompatible && pDef->IsNew() )
387 1 : nOpnd2 |= SBX_TYPE_DIM_AS_NEW_FLAG;
388 :
389 851 : short nFixedStringLength = pDef->GetFixedStringLength();
390 851 : if( nFixedStringLength >= 0 )
391 0 : nOpnd2 |= (SBX_FIXED_LEN_STRING_FLAG + (sal_uInt32(nFixedStringLength) << 17)); // len = all bits above 0x10000
392 :
393 851 : if( pDim != NULL && pDim->GetDims() > 0 )
394 25 : nOpnd2 |= SBX_TYPE_VAR_TO_DIM_FLAG;
395 :
396 851 : aGen.Gen( eOp2, pDef->GetId(), nOpnd2 );
397 : }
398 :
399 : // Initialising for self-defined daty types
400 : // and per NEW created variable
401 1774 : if( pDef->GetType() == SbxOBJECT
402 887 : && pDef->GetTypeId() )
403 : {
404 131 : if( !bCompatible && !pDef->IsNew() )
405 : {
406 0 : OUString aTypeName( aGblStrings.Find( pDef->GetTypeId() ) );
407 0 : if( rTypeArray->Find( aTypeName, SbxCLASS_OBJECT ) == NULL )
408 : {
409 0 : if( CodeCompleteOptions::IsExtendedTypeDeclaration() )
410 : {
411 0 : if(!IsUnoInterface(aTypeName))
412 0 : Error( SbERR_UNDEF_TYPE, aTypeName );
413 : }
414 : else
415 0 : Error( SbERR_UNDEF_TYPE, aTypeName );
416 0 : }
417 : }
418 :
419 131 : if( bConst )
420 : {
421 0 : Error( SbERR_SYNTAX );
422 : }
423 :
424 131 : if( pDim )
425 : {
426 4 : if( eOp == _REDIMP )
427 : {
428 0 : SbiExpression aExpr( this, *pDef, NULL );
429 0 : aExpr.Gen();
430 0 : aGen.Gen( _REDIMP_ERASE );
431 :
432 0 : pDef->SetDims( pDim->GetDims() );
433 0 : SbiExpression aExpr2( this, *pDef, pDim );
434 0 : aExpr2.Gen();
435 0 : aGen.Gen( _DCREATE_REDIMP, pDef->GetId(), pDef->GetTypeId() );
436 : }
437 : else
438 : {
439 4 : pDef->SetDims( pDim->GetDims() );
440 4 : SbiExpression aExpr( this, *pDef, pDim );
441 4 : aExpr.Gen();
442 4 : aGen.Gen( _DCREATE, pDef->GetId(), pDef->GetTypeId() );
443 : }
444 : }
445 : else
446 : {
447 127 : SbiExpression aExpr( this, *pDef );
448 127 : aExpr.Gen();
449 127 : SbiOpcode eOp_ = pDef->IsNew() ? _CREATE : _TCREATE;
450 127 : aGen.Gen( eOp_, pDef->GetId(), pDef->GetTypeId() );
451 127 : if ( bVBASupportOn )
452 104 : aGen.Gen( _VBASET );
453 : else
454 23 : aGen.Gen( _SET );
455 : }
456 : }
457 : else
458 : {
459 756 : if( bConst )
460 : {
461 : // Definition of the constants
462 122 : if( pDim )
463 : {
464 0 : Error( SbERR_SYNTAX );
465 0 : delete pDim;
466 : }
467 122 : SbiExpression aVar( this, *pDef );
468 122 : if( !TestToken( EQ ) )
469 0 : goto MyBreak; // (see below)
470 244 : SbiConstExpression aExpr( this );
471 122 : if( !bDefined && aExpr.IsValid() )
472 : {
473 122 : if( pDef->GetScope() == SbGLOBAL )
474 : {
475 : // Create code only for the global constant!
476 87 : aVar.Gen();
477 87 : aExpr.Gen();
478 87 : aGen.Gen( _PUTC );
479 : }
480 122 : SbiConstDef* pConst = pDef->GetConstDef();
481 122 : if( aExpr.GetType() == SbxSTRING )
482 62 : pConst->Set( aExpr.GetString() );
483 : else
484 60 : pConst->Set( aExpr.GetValue(), aExpr.GetType() );
485 122 : }
486 : }
487 634 : else if( pDim )
488 : {
489 : // Dimension the variable
490 : // Delete the var at REDIM beforehand
491 41 : if( eOp == _REDIM )
492 : {
493 1 : SbiExpression aExpr( this, *pDef, NULL );
494 1 : aExpr.Gen();
495 1 : if ( bVBASupportOn )
496 : // delete the array but
497 : // clear the variable ( this
498 : // allows the processing of
499 : // the param to happen as normal without errors ( ordinary ERASE just clears the array )
500 1 : aGen.Gen( _ERASE_CLEAR );
501 : else
502 0 : aGen.Gen( _ERASE );
503 : }
504 40 : else if( eOp == _REDIMP )
505 : {
506 0 : SbiExpression aExpr( this, *pDef, NULL );
507 0 : aExpr.Gen();
508 0 : aGen.Gen( _REDIMP_ERASE );
509 : }
510 41 : pDef->SetDims( pDim->GetDims() );
511 41 : if( bPersistantGlobal )
512 2 : pDef->SetGlobal( true );
513 41 : SbiExpression aExpr( this, *pDef, pDim );
514 41 : aExpr.Gen();
515 41 : pDef->SetGlobal( false );
516 41 : aGen.Gen( (eOp == _STATIC) ? _DIM : eOp );
517 : }
518 : }
519 887 : if( !TestComma() )
520 792 : goto MyBreak;
521 :
522 : // Implementation of bSwitchPool (see above): pPool must not be set to &aGlobals
523 : // at the VarDecl-Call.
524 : // Apart from that the behavior should be absolutely identical,
525 : // i.e., pPool had to be reset always at the end of the loop.
526 : // also at a break
527 95 : pPool = pOldPool;
528 95 : continue; // Skip MyBreak
529 : MyBreak:
530 792 : pPool = pOldPool;
531 792 : break;
532 : }
533 :
534 : // #40689, finalize the jump over statics declarations
535 792 : if( !bVBASupportOn && bStatic )
536 : {
537 : // maintain the global chain
538 0 : nGblChain = aGen.Gen( _JUMP, 0 );
539 0 : bGblDefs = bNewGblDefs = true;
540 :
541 : // Register for Sub a jump to the end of statics
542 0 : aGen.BackChain( nEndOfStaticLbl );
543 : }
544 :
545 : }
546 :
547 : // Here were Arrays redimensioned.
548 :
549 1 : void SbiParser::ReDim()
550 : {
551 1 : DefVar( _REDIM, pProc && bVBASupportOn && pProc->IsStatic() );
552 1 : }
553 :
554 : // ERASE array, ...
555 :
556 0 : void SbiParser::Erase()
557 : {
558 0 : while( !bAbort )
559 : {
560 0 : SbiExpression aExpr( this, SbLVALUE );
561 0 : aExpr.Gen();
562 0 : aGen.Gen( _ERASE );
563 0 : if( !TestComma() ) break;
564 0 : }
565 0 : }
566 :
567 : // Declaration of a data type
568 :
569 0 : void SbiParser::Type()
570 : {
571 0 : DefType( false );
572 0 : }
573 :
574 1 : void SbiParser::DefType( bool bPrivate )
575 : {
576 : // TODO: Use bPrivate
577 : (void)bPrivate;
578 :
579 : // Read the new Token lesen. It had to be a symbol
580 1 : if (!TestSymbol())
581 0 : return;
582 :
583 1 : if (rTypeArray->Find(aSym,SbxCLASS_OBJECT))
584 : {
585 0 : Error( SbERR_VAR_DEFINED, aSym );
586 0 : return;
587 : }
588 :
589 1 : SbxObject *pType = new SbxObject(aSym);
590 :
591 1 : boost::scoped_ptr<SbiSymDef> pElem;
592 1 : SbiDimList* pDim = NULL;
593 1 : bool bDone = false;
594 :
595 8 : while( !bDone && !IsEof() )
596 : {
597 6 : switch( Peek() )
598 : {
599 : case ENDTYPE :
600 1 : bDone = true;
601 1 : Next();
602 1 : break;
603 :
604 : case EOLN :
605 : case REM :
606 3 : Next();
607 3 : break;
608 :
609 : default:
610 2 : pElem.reset(VarDecl(&pDim, false, false));
611 2 : if( !pElem )
612 0 : bDone = true; // Error occurred
613 : }
614 6 : if( pElem )
615 : {
616 2 : SbxArray *pTypeMembers = pType->GetProperties();
617 2 : OUString aElemName = pElem->GetName();
618 2 : if( pTypeMembers->Find( aElemName, SbxCLASS_DONTCARE) )
619 : {
620 0 : Error (SbERR_VAR_DEFINED);
621 : }
622 : else
623 : {
624 2 : SbxDataType eElemType = pElem->GetType();
625 2 : SbxProperty *pTypeElem = new SbxProperty( aElemName, eElemType );
626 2 : if( pDim )
627 : {
628 0 : SbxDimArray* pArray = new SbxDimArray( pElem->GetType() );
629 0 : if ( pDim->GetSize() )
630 : {
631 : // Dimension the target array
632 :
633 0 : for ( short i=0; i<pDim->GetSize();++i )
634 : {
635 0 : sal_Int32 lb = nBase;
636 0 : SbiExprNode* pNode = pDim->Get(i)->GetExprNode();
637 0 : sal_Int32 ub = pNode->GetNumber();
638 0 : if ( !pDim->Get( i )->IsBased() ) // each dim is low/up
639 : {
640 0 : if ( ++i >= pDim->GetSize() ) // trouble
641 0 : StarBASIC::FatalError( SbERR_INTERNAL_ERROR );
642 0 : pNode = pDim->Get(i)->GetExprNode();
643 0 : lb = ub;
644 0 : ub = pNode->GetNumber();
645 : }
646 0 : else if ( !bCompatible )
647 0 : ub += nBase;
648 0 : pArray->AddDim32( lb, ub );
649 : }
650 0 : pArray->setHasFixedSize( true );
651 : }
652 : else
653 0 : pArray->unoAddDim( 0, -1 ); // variant array
654 0 : SbxFlagBits nSavFlags = pTypeElem->GetFlags();
655 : // need to reset the FIXED flag
656 : // when calling PutObject ( because the type will not match Object )
657 0 : pTypeElem->ResetFlag( SBX_FIXED );
658 0 : pTypeElem->PutObject( pArray );
659 0 : pTypeElem->SetFlags( nSavFlags );
660 : }
661 : // Nested user type?
662 2 : if( eElemType == SbxOBJECT )
663 : {
664 0 : sal_uInt16 nElemTypeId = pElem->GetTypeId();
665 0 : if( nElemTypeId != 0 )
666 : {
667 0 : OUString aTypeName( aGblStrings.Find( nElemTypeId ) );
668 0 : SbxObject* pTypeObj = static_cast< SbxObject* >( rTypeArray->Find( aTypeName, SbxCLASS_OBJECT ) );
669 0 : if( pTypeObj != NULL )
670 : {
671 0 : SbxObject* pCloneObj = cloneTypeObjectImpl( *pTypeObj );
672 0 : pTypeElem->PutObject( pCloneObj );
673 0 : }
674 : }
675 : }
676 2 : pTypeMembers->Insert( pTypeElem, pTypeMembers->Count() );
677 : }
678 2 : delete pDim, pDim = NULL;
679 2 : pElem.reset();
680 : }
681 : }
682 :
683 1 : pType->Remove( OUString("Name"), SbxCLASS_DONTCARE );
684 1 : pType->Remove( OUString("Parent"), SbxCLASS_DONTCARE );
685 :
686 1 : rTypeArray->Insert (pType,rTypeArray->Count());
687 : }
688 :
689 :
690 : // Declaration of Enum type
691 :
692 0 : void SbiParser::Enum()
693 : {
694 0 : DefEnum( false );
695 0 : }
696 :
697 0 : void SbiParser::DefEnum( bool bPrivate )
698 : {
699 : // Read a the new Token. It had to be a symbol
700 0 : if (!TestSymbol())
701 0 : return;
702 :
703 0 : OUString aEnumName = aSym;
704 0 : if( rEnumArray->Find(aEnumName,SbxCLASS_OBJECT) )
705 : {
706 0 : Error( SbERR_VAR_DEFINED, aSym );
707 0 : return;
708 : }
709 :
710 0 : SbxObject *pEnum = new SbxObject( aEnumName );
711 0 : if( bPrivate )
712 : {
713 0 : pEnum->SetFlag( SBX_PRIVATE );
714 : }
715 : SbiSymDef* pElem;
716 : SbiDimList* pDim;
717 0 : bool bDone = false;
718 :
719 : // Starting with -1 to make first default value 0 after ++
720 0 : sal_Int32 nCurrentEnumValue = -1;
721 0 : while( !bDone && !IsEof() )
722 : {
723 0 : switch( Peek() )
724 : {
725 : case ENDENUM :
726 0 : pElem = NULL;
727 0 : bDone = true;
728 0 : Next();
729 0 : break;
730 :
731 : case EOLN :
732 : case REM :
733 0 : pElem = NULL;
734 0 : Next();
735 0 : break;
736 :
737 : default:
738 : {
739 : // TODO: Check existing!
740 0 : pDim = NULL;
741 0 : pElem = VarDecl( &pDim, false, true );
742 0 : if( !pElem )
743 : {
744 0 : bDone = true; // Error occurred
745 0 : break;
746 : }
747 0 : else if( pDim )
748 : {
749 0 : delete pDim;
750 0 : Error( SbERR_SYNTAX );
751 0 : bDone = true; // Error occurred
752 0 : break;
753 : }
754 :
755 0 : SbiExpression aVar( this, *pElem );
756 0 : if( Peek() == EQ )
757 : {
758 0 : Next();
759 :
760 0 : SbiConstExpression aExpr( this );
761 0 : if( aExpr.IsValid() )
762 : {
763 0 : SbxVariableRef xConvertVar = new SbxVariable();
764 0 : if( aExpr.GetType() == SbxSTRING )
765 0 : xConvertVar->PutString( aExpr.GetString() );
766 : else
767 0 : xConvertVar->PutDouble( aExpr.GetValue() );
768 :
769 0 : nCurrentEnumValue = xConvertVar->GetLong();
770 0 : }
771 : }
772 : else
773 0 : nCurrentEnumValue++;
774 :
775 0 : SbiSymPool* pPoolToUse = bPrivate ? pPool : &aGlobals;
776 :
777 0 : SbiSymDef* pOld = pPoolToUse->Find( pElem->GetName() );
778 0 : if( pOld )
779 : {
780 0 : Error( SbERR_VAR_DEFINED, pElem->GetName() );
781 0 : bDone = true; // Error occurred
782 0 : break;
783 : }
784 :
785 0 : pPool->Add( pElem );
786 :
787 0 : if( !bPrivate )
788 : {
789 0 : SbiOpcode eOp = _GLOBAL;
790 0 : aGen.BackChain( nGblChain );
791 0 : nGblChain = 0;
792 0 : bGblDefs = bNewGblDefs = true;
793 : aGen.Gen(
794 0 : eOp, pElem->GetId(),
795 0 : sal::static_int_cast< sal_uInt16 >( pElem->GetType() ) );
796 :
797 0 : aVar.Gen();
798 0 : sal_uInt16 nStringId = aGen.GetParser()->aGblStrings.Add( nCurrentEnumValue, SbxLONG );
799 0 : aGen.Gen( _NUMBER, nStringId );
800 0 : aGen.Gen( _PUTC );
801 : }
802 :
803 0 : SbiConstDef* pConst = pElem->GetConstDef();
804 0 : pConst->Set( nCurrentEnumValue, SbxLONG );
805 : }
806 : }
807 0 : if( pElem )
808 : {
809 0 : SbxArray *pEnumMembers = pEnum->GetProperties();
810 0 : SbxProperty *pEnumElem = new SbxProperty( pElem->GetName(), SbxLONG );
811 0 : pEnumElem->PutLong( nCurrentEnumValue );
812 0 : pEnumElem->ResetFlag( SBX_WRITE );
813 0 : pEnumElem->SetFlag( SBX_CONST );
814 0 : pEnumMembers->Insert( pEnumElem, pEnumMembers->Count() );
815 : }
816 : }
817 :
818 0 : pEnum->Remove( OUString("Name"), SbxCLASS_DONTCARE );
819 0 : pEnum->Remove( OUString("Parent"), SbxCLASS_DONTCARE );
820 :
821 0 : rEnumArray->Insert( pEnum, rEnumArray->Count() );
822 : }
823 :
824 :
825 : // Procedure-Declaration
826 : // the first Token is already read in (SUB/FUNCTION)
827 : // xxx Name [LIB "name"[ALIAS "name"]][(Parameter)][AS TYPE]
828 :
829 419 : SbiProcDef* SbiParser::ProcDecl( bool bDecl )
830 : {
831 419 : bool bFunc = ( eCurTok == FUNCTION );
832 419 : bool bProp = ( eCurTok == GET || eCurTok == SET || eCurTok == LET );
833 419 : if( !TestSymbol() ) return NULL;
834 419 : OUString aName( aSym );
835 419 : SbxDataType eType = eScanType;
836 419 : SbiProcDef* pDef = new SbiProcDef( this, aName, true );
837 419 : pDef->SetType( eType );
838 419 : if( Peek() == _CDECL_ )
839 : {
840 0 : Next(); pDef->SetCdecl();
841 : }
842 419 : if( Peek() == LIB )
843 : {
844 4 : Next();
845 4 : if( Next() == FIXSTRING )
846 : {
847 4 : pDef->GetLib() = aSym;
848 : }
849 : else
850 : {
851 0 : Error( SbERR_SYNTAX );
852 : }
853 : }
854 419 : if( Peek() == ALIAS )
855 : {
856 0 : Next();
857 0 : if( Next() == FIXSTRING )
858 : {
859 0 : pDef->GetAlias() = aSym;
860 : }
861 : else
862 : {
863 0 : Error( SbERR_SYNTAX );
864 : }
865 : }
866 419 : if( !bDecl )
867 : {
868 : // CDECL, LIB and ALIAS are invalid
869 415 : if( !pDef->GetLib().isEmpty() )
870 : {
871 0 : Error( SbERR_UNEXPECTED, LIB );
872 : }
873 415 : if( !pDef->GetAlias().isEmpty() )
874 : {
875 0 : Error( SbERR_UNEXPECTED, ALIAS );
876 : }
877 415 : if( pDef->IsCdecl() )
878 : {
879 0 : Error( SbERR_UNEXPECTED, _CDECL_ );
880 : }
881 415 : pDef->SetCdecl( false );
882 415 : pDef->GetLib().clear();
883 415 : pDef->GetAlias().clear();
884 : }
885 4 : else if( pDef->GetLib().isEmpty() )
886 : {
887 : // ALIAS and CDECL only together with LIB
888 0 : if( !pDef->GetAlias().isEmpty() )
889 : {
890 0 : Error( SbERR_UNEXPECTED, ALIAS );
891 : }
892 0 : if( pDef->IsCdecl() )
893 : {
894 0 : Error( SbERR_UNEXPECTED, _CDECL_ );
895 : }
896 0 : pDef->SetCdecl( false );
897 0 : pDef->GetAlias().clear();
898 : }
899 : // Brackets?
900 419 : if( Peek() == LPAREN )
901 : {
902 364 : Next();
903 364 : if( Peek() == RPAREN )
904 : {
905 265 : Next();
906 : }
907 : else
908 : {
909 : for(;;)
910 : {
911 220 : bool bByVal = false;
912 220 : bool bOptional = false;
913 220 : bool bParamArray = false;
914 492 : while( Peek() == BYVAL || Peek() == BYREF || Peek() == _OPTIONAL_ )
915 : {
916 52 : if( Peek() == BYVAL )
917 : {
918 4 : bByVal = true;
919 : }
920 48 : else if ( Peek() == BYREF )
921 : {
922 2 : bByVal = false;
923 : }
924 46 : else if ( Peek() == _OPTIONAL_ )
925 : {
926 46 : bOptional = true;
927 : }
928 52 : Next();
929 : }
930 220 : if( bCompatible && Peek() == PARAMARRAY )
931 : {
932 0 : if( bByVal || bOptional )
933 : {
934 0 : Error( SbERR_UNEXPECTED, PARAMARRAY );
935 : }
936 0 : Next();
937 0 : bParamArray = true;
938 : }
939 220 : SbiSymDef* pPar = VarDecl( NULL, false, false );
940 220 : if( !pPar )
941 : {
942 0 : break;
943 : }
944 220 : if( bByVal )
945 : {
946 4 : pPar->SetByVal();
947 : }
948 220 : if( bOptional )
949 : {
950 46 : pPar->SetOptional();
951 : }
952 220 : if( bParamArray )
953 : {
954 0 : pPar->SetParamArray();
955 : }
956 220 : pDef->GetParams().Add( pPar );
957 220 : SbiToken eTok = Next();
958 220 : if( eTok != COMMA && eTok != RPAREN )
959 : {
960 0 : bool bError2 = true;
961 0 : if( bOptional && bCompatible && eTok == EQ )
962 : {
963 0 : boost::scoped_ptr<SbiConstExpression> pDefaultExpr(new SbiConstExpression( this ));
964 0 : SbxDataType eType2 = pDefaultExpr->GetType();
965 :
966 : sal_uInt16 nStringId;
967 0 : if( eType2 == SbxSTRING )
968 : {
969 0 : nStringId = aGblStrings.Add( pDefaultExpr->GetString() );
970 : }
971 : else
972 : {
973 0 : nStringId = aGblStrings.Add( pDefaultExpr->GetValue(), eType2 );
974 : }
975 0 : pPar->SetDefaultId( nStringId );
976 0 : pDefaultExpr.reset();
977 :
978 0 : eTok = Next();
979 0 : if( eTok == COMMA || eTok == RPAREN )
980 : {
981 0 : bError2 = false;
982 0 : }
983 : }
984 0 : if( bError2 )
985 : {
986 0 : Error( SbERR_EXPECTED, RPAREN );
987 0 : break;
988 : }
989 : }
990 220 : if( eTok == RPAREN )
991 : {
992 99 : break;
993 : }
994 121 : }
995 : }
996 : }
997 419 : TypeDecl( *pDef );
998 419 : if( eType != SbxVARIANT && pDef->GetType() != eType )
999 : {
1000 0 : Error( SbERR_BAD_DECLARATION, aName );
1001 : }
1002 419 : if( pDef->GetType() == SbxVARIANT && !( bFunc || bProp ) )
1003 : {
1004 271 : pDef->SetType( SbxEMPTY );
1005 : }
1006 419 : return pDef;
1007 : }
1008 :
1009 : // DECLARE
1010 :
1011 0 : void SbiParser::Declare()
1012 : {
1013 0 : DefDeclare( false );
1014 0 : }
1015 :
1016 4 : void SbiParser::DefDeclare( bool bPrivate )
1017 : {
1018 4 : Next();
1019 4 : if( eCurTok != SUB && eCurTok != FUNCTION )
1020 : {
1021 0 : Error( SbERR_UNEXPECTED, eCurTok );
1022 : }
1023 : else
1024 : {
1025 4 : bool bFunction = (eCurTok == FUNCTION);
1026 :
1027 4 : SbiProcDef* pDef = ProcDecl( true );
1028 4 : if( pDef )
1029 : {
1030 4 : if( pDef->GetLib().isEmpty() )
1031 : {
1032 0 : Error( SbERR_EXPECTED, LIB );
1033 : }
1034 : // Is it already there?
1035 4 : SbiSymDef* pOld = aPublics.Find( pDef->GetName() );
1036 4 : if( pOld )
1037 : {
1038 0 : SbiProcDef* p = pOld->GetProcDef();
1039 0 : if( !p )
1040 : {
1041 : // Declared as a variable
1042 0 : Error( SbERR_BAD_DECLARATION, pDef->GetName() );
1043 0 : delete pDef;
1044 0 : pDef = NULL;
1045 : }
1046 : else
1047 : {
1048 0 : pDef->Match( p );
1049 : }
1050 : }
1051 : else
1052 : {
1053 4 : aPublics.Add( pDef );
1054 : }
1055 4 : if ( pDef )
1056 : {
1057 4 : pDef->SetPublic( !bPrivate );
1058 :
1059 : // New declare handling
1060 4 : if( !pDef->GetLib().isEmpty())
1061 : {
1062 4 : if( bNewGblDefs && nGblChain == 0 )
1063 : {
1064 2 : nGblChain = aGen.Gen( _JUMP, 0 );
1065 2 : bNewGblDefs = false;
1066 : }
1067 :
1068 4 : sal_uInt16 nSavLine = nLine;
1069 4 : aGen.Statement();
1070 4 : pDef->Define();
1071 4 : pDef->SetLine1( nSavLine );
1072 4 : pDef->SetLine2( nSavLine );
1073 :
1074 4 : SbiSymPool& rPool = pDef->GetParams();
1075 4 : sal_uInt16 nParCount = rPool.GetSize();
1076 :
1077 4 : SbxDataType eType = pDef->GetType();
1078 4 : if( bFunction )
1079 : {
1080 4 : aGen.Gen( _PARAM, 0, sal::static_int_cast< sal_uInt16 >( eType ) );
1081 : }
1082 4 : if( nParCount > 1 )
1083 : {
1084 4 : aGen.Gen( _ARGC );
1085 :
1086 8 : for( sal_uInt16 i = 1 ; i < nParCount ; ++i )
1087 : {
1088 4 : SbiSymDef* pParDef = rPool.Get( i );
1089 4 : SbxDataType eParType = pParDef->GetType();
1090 :
1091 4 : aGen.Gen( _PARAM, i, sal::static_int_cast< sal_uInt16 >( eParType ) );
1092 4 : aGen.Gen( _ARGV );
1093 :
1094 4 : sal_uInt16 nTyp = sal::static_int_cast< sal_uInt16 >( pParDef->GetType() );
1095 4 : if( pParDef->IsByVal() )
1096 : {
1097 : // Reset to avoid additional byval in call to wrapper function
1098 0 : pParDef->SetByVal( false );
1099 0 : nTyp |= 0x8000;
1100 : }
1101 4 : aGen.Gen( _ARGTYP, nTyp );
1102 : }
1103 : }
1104 :
1105 4 : aGen.Gen( _LIB, aGblStrings.Add( pDef->GetLib() ) );
1106 :
1107 4 : SbiOpcode eOp = pDef->IsCdecl() ? _CALLC : _CALL;
1108 4 : sal_uInt16 nId = pDef->GetId();
1109 4 : if( !pDef->GetAlias().isEmpty() )
1110 : {
1111 0 : nId = ( nId & 0x8000 ) | aGblStrings.Add( pDef->GetAlias() );
1112 : }
1113 4 : if( nParCount > 1 )
1114 : {
1115 4 : nId |= 0x8000;
1116 : }
1117 4 : aGen.Gen( eOp, nId, sal::static_int_cast< sal_uInt16 >( eType ) );
1118 :
1119 4 : if( bFunction )
1120 : {
1121 4 : aGen.Gen( _PUT );
1122 : }
1123 4 : aGen.Gen( _LEAVE );
1124 : }
1125 : }
1126 : }
1127 : }
1128 4 : }
1129 :
1130 0 : void SbiParser::Attribute()
1131 : {
1132 : // TODO: Need to implement the method as an attributed object.
1133 0 : while( Next() != EQ )
1134 : {
1135 0 : if( Next() != DOT)
1136 : {
1137 0 : break;
1138 : }
1139 : }
1140 :
1141 0 : if( eCurTok != EQ )
1142 : {
1143 0 : Error( SbERR_SYNTAX );
1144 : }
1145 : else
1146 : {
1147 0 : SbiExpression aValue( this );
1148 : }
1149 : // Don't generate any code - just discard it.
1150 0 : }
1151 :
1152 : // Call of a SUB or a FUNCTION
1153 :
1154 375 : void SbiParser::Call()
1155 : {
1156 375 : SbiExpression aVar( this, SbSYMBOL );
1157 375 : aVar.Gen( FORCE_CALL );
1158 375 : aGen.Gen( _GET );
1159 375 : }
1160 :
1161 : // SUB/FUNCTION
1162 :
1163 383 : void SbiParser::SubFunc()
1164 : {
1165 383 : DefProc( false, false );
1166 383 : }
1167 :
1168 : // Read in of a procedure
1169 :
1170 415 : void SbiParser::DefProc( bool bStatic, bool bPrivate )
1171 : {
1172 415 : sal_uInt16 l1 = nLine;
1173 415 : bool bSub = ( eCurTok == SUB );
1174 415 : bool bProperty = ( eCurTok == PROPERTY );
1175 415 : PropertyMode ePropertyMode = PropertyMode::NONE;
1176 415 : if( bProperty )
1177 : {
1178 0 : Next();
1179 0 : if( eCurTok == GET )
1180 : {
1181 0 : ePropertyMode = PropertyMode::Get;
1182 : }
1183 0 : else if( eCurTok == LET )
1184 : {
1185 0 : ePropertyMode = PropertyMode::Let;
1186 : }
1187 0 : else if( eCurTok == SET )
1188 : {
1189 0 : ePropertyMode = PropertyMode::Set;
1190 : }
1191 : else
1192 : {
1193 0 : Error( SbERR_EXPECTED, "Get or Let or Set" );
1194 : }
1195 : }
1196 :
1197 415 : SbiToken eExit = eCurTok;
1198 415 : SbiProcDef* pDef = ProcDecl( false );
1199 415 : if( !pDef )
1200 : {
1201 0 : return;
1202 : }
1203 415 : pDef->setPropertyMode( ePropertyMode );
1204 :
1205 : // Is the Proc already declared?
1206 415 : SbiSymDef* pOld = aPublics.Find( pDef->GetName() );
1207 415 : if( pOld )
1208 : {
1209 217 : bool bError_ = false;
1210 :
1211 217 : pProc = pOld->GetProcDef();
1212 217 : if( !pProc )
1213 : {
1214 : // Declared as a variable
1215 0 : Error( SbERR_BAD_DECLARATION, pDef->GetName() );
1216 0 : delete pDef;
1217 0 : pProc = NULL;
1218 0 : bError_ = true;
1219 : }
1220 : // #100027: Multiple declaration -> Error
1221 : // #112787: Not for setup, REMOVE for 8
1222 217 : else if( pProc->IsUsedForProcDecl() )
1223 : {
1224 0 : PropertyMode ePropMode = pDef->getPropertyMode();
1225 0 : if( ePropMode == PropertyMode::NONE || ePropMode == pProc->getPropertyMode() )
1226 : {
1227 0 : Error( SbERR_PROC_DEFINED, pDef->GetName() );
1228 0 : delete pDef;
1229 0 : pProc = NULL;
1230 0 : bError_ = true;
1231 : }
1232 : }
1233 :
1234 217 : if( !bError_ )
1235 : {
1236 217 : pDef->Match( pProc );
1237 217 : pProc = pDef;
1238 : }
1239 : }
1240 : else
1241 : {
1242 198 : aPublics.Add( pDef ), pProc = pDef;
1243 : }
1244 415 : if( !pProc )
1245 : {
1246 0 : return;
1247 : }
1248 415 : pProc->SetPublic( !bPrivate );
1249 :
1250 : // Now we set the search hierarchy for symbols as well as the
1251 : // current procedure.
1252 415 : aPublics.SetProcId( pProc->GetId() );
1253 415 : pProc->GetParams().SetParent( &aPublics );
1254 415 : if( bStatic )
1255 : {
1256 0 : if ( bVBASupportOn )
1257 : {
1258 0 : pProc->SetStatic( true );
1259 : }
1260 : else
1261 : {
1262 0 : Error( SbERR_NOT_IMPLEMENTED ); // STATIC SUB ...
1263 : }
1264 : }
1265 : else
1266 : {
1267 415 : pProc->SetStatic( false );
1268 : }
1269 : // Normal case: Local variable->parameter->global variable
1270 415 : pProc->GetLocals().SetParent( &pProc->GetParams() );
1271 415 : pPool = &pProc->GetLocals();
1272 :
1273 415 : pProc->Define();
1274 415 : OpenBlock( eExit );
1275 415 : StmntBlock( bSub ? ENDSUB : (bProperty ? ENDPROPERTY : ENDFUNC) );
1276 415 : sal_uInt16 l2 = nLine;
1277 415 : pProc->SetLine1( l1 );
1278 415 : pProc->SetLine2( l2 );
1279 415 : pPool = &aPublics;
1280 415 : aPublics.SetProcId( 0 );
1281 : // Open labels?
1282 415 : pProc->GetLabels().CheckRefs();
1283 415 : CloseBlock();
1284 415 : aGen.Gen( _LEAVE );
1285 415 : pProc = NULL;
1286 : }
1287 :
1288 : // STATIC variable|procedure
1289 :
1290 0 : void SbiParser::Static()
1291 : {
1292 0 : DefStatic( false );
1293 0 : }
1294 :
1295 0 : void SbiParser::DefStatic( bool bPrivate )
1296 : {
1297 : SbiSymPool* p;
1298 :
1299 0 : switch( Peek() )
1300 : {
1301 : case SUB:
1302 : case FUNCTION:
1303 : case PROPERTY:
1304 : // End global chain if necessary (not done in
1305 : // SbiParser::Parse() under these conditions
1306 0 : if( bNewGblDefs && nGblChain == 0 )
1307 : {
1308 0 : nGblChain = aGen.Gen( _JUMP, 0 );
1309 0 : bNewGblDefs = false;
1310 : }
1311 0 : Next();
1312 0 : DefProc( true, bPrivate );
1313 0 : break;
1314 : default:
1315 0 : if( !pProc )
1316 : {
1317 0 : Error( SbERR_NOT_IN_SUBR );
1318 : }
1319 : // Reset the Pool, so that STATIC-Declarations go into the
1320 : // global Pool
1321 0 : p = pPool;
1322 0 : pPool = &aPublics;
1323 0 : DefVar( _STATIC, true );
1324 0 : pPool = p;
1325 0 : break;
1326 : }
1327 0 : }
1328 :
1329 0 : bool SbiParser::IsUnoInterface(const OUString& sTypeName)
1330 : {
1331 : try
1332 : {
1333 : return css::reflection::theCoreReflection::get(
1334 0 : comphelper::getProcessComponentContext())->forName(sTypeName).is();
1335 : }
1336 0 : catch(const Exception&)
1337 : {
1338 : OSL_FAIL("Could not create reflection.CoreReflection.");
1339 : }
1340 0 : return false;
1341 : }
1342 :
1343 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
