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