1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef _SBRUNTIME_HXX
#define _SBRUNTIME_HXX
#ifndef _SBX_HXX
#include <basic/sbx.hxx>
#endif
#include "sb.hxx"
// Define activates class UCBStream in iosys.cxx
#define _USE_UNO
#ifdef _USE_UNO
#include <rtl/ustring.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include <osl/file.hxx>
#include <rtl/math.hxx>
#include <i18npool/lang.h>
#include <vector>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/container/XEnumeration.hpp>
#include <unotools/localedatawrapper.hxx>
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::container;
// Define activates old file implementation
// (only in non UCB case)
// #define _OLD_FILE_IMPL
//#include <sal/types.h>
//#include <rtl/byteseq.hxx>
//#include <rtl/ustring>
namespace basicEncoder
{
// TODO: Use exported functionality (code is copied from deamons2/ucb)
class AsciiEncoder
{
public:
static ::rtl::OUString decodeUnoUrlParamValue(const rtl::OUString & rSource);
//static ::rtl::OUString encodeUnoUrlParamValue(const rtl::OUString & rSource);
//static ::rtl::ByteSequence decode(const ::rtl::OUString & string);
//static ::rtl::OUString encode(const ::rtl::ByteSequence & bytes);
//static void test();
};
}
#endif /* _USE_UNO */
class SbiInstance; // aktiver StarBASIC-Prozess
class SbiRuntime; // aktive StarBASIC-Prozedur-Instanz
struct SbiArgvStack; // Argv stack element
struct SbiGosubStack; // GOSUB stack element
class SbiImage; // Code-Image
class SbiIoSystem; // Dateisystem
class SbiDdeControl; // DDE-Steuerung
class SbiDllMgr; // Aufrufe in DLLs
class SvNumberFormatter; // Zeit/Datumsfunktionen
enum ForType
{
FOR_TO,
FOR_EACH_ARRAY,
FOR_EACH_COLLECTION,
FOR_EACH_XENUMERATION
};
struct SbiForStack { // for/next stack:
SbiForStack* pNext; // Chain
SbxVariableRef refVar; // loop variable
SbxVariableRef refEnd; // end expression / for each: Array/BasicCollection object
SbxVariableRef refInc; // increment expression
// For each support
ForType eForType;
INT32 nCurCollectionIndex;
INT32* pArrayCurIndices;
INT32* pArrayLowerBounds;
INT32* pArrayUpperBounds;
Reference< XEnumeration > xEnumeration;
SbiForStack( void )
: pArrayCurIndices( NULL )
, pArrayLowerBounds( NULL )
, pArrayUpperBounds( NULL )
{}
~SbiForStack()
{
delete[] pArrayCurIndices;
delete[] pArrayLowerBounds;
delete[] pArrayUpperBounds;
}
};
struct SbiGosubStack { // GOSUB-Stack:
SbiGosubStack* pNext; // Chain
const BYTE* pCode; // Return-Pointer
USHORT nStartForLvl; // #118235: For Level in moment of gosub
};
#define MAXRECURSION 500 // max. 500 Rekursionen
#define Sb_ATTR_NORMAL 0x0000
#define Sb_ATTR_HIDDEN 0x0002
#define Sb_ATTR_SYSTEM 0x0004
#define Sb_ATTR_VOLUME 0x0008
#define Sb_ATTR_DIRECTORY 0x0010
#define Sb_ATTR_ARCHIVE 0x0020
class Dir;
class WildCard;
class SbiRTLData
{
public:
#ifdef _OLD_FILE_IMPL
Dir* pDir;
#else
::osl::Directory* pDir;
#endif
INT16 nDirFlags;
short nCurDirPos;
String sFullNameToBeChecked;
WildCard* pWildCard;
#ifdef _USE_UNO
Sequence< ::rtl::OUString > aDirSeq;
#endif /* _USE_UNO */
SbiRTLData();
~SbiRTLData();
};
// Die Instanz entspricht einem laufenden StarBASIC. Mehrere gleichzeitig
// laufende BASICs werden ueber verkettete Instanzen verwaltet. Hier liegen
// alle Daten, die nur leben, wenn BASIC auch lebt, wie z.B. das I/O-System.
typedef ::std::vector
<
::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent >
>
ComponentVector_t;
class SbiInstance
{
friend class SbiRuntime;
SbiRTLData aRTLData;
SbiIoSystem* pIosys; // Dateisystem
SbiDdeControl* pDdeCtrl; // DDE
SbiDllMgr* pDllMgr; // DLL-Calls (DECLARE)
StarBASIC* pBasic;
SvNumberFormatter* pNumberFormatter;
LanguageType meFormatterLangType;
DateFormat meFormatterDateFormat;
sal_uInt32 nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx;
SbError nErr; // aktueller Fehlercode
String aErrorMsg; // letzte Error-Message fuer $ARG
USHORT nErl; // aktuelle Fehlerzeile
BOOL bReschedule; // Flag: TRUE = Reschedule in Hauptschleife
BOOL bCompatibility; // Flag: TRUE = VBA runtime compatibility mode
ComponentVector_t ComponentVector;
public:
SbiRuntime* pRun; // Call-Stack
SbiInstance* pNext; // Instanzen-Chain
// #31460 Neues Konzept fuer StepInto/Over/Out,
// Erklaerung siehe runtime.cxx bei SbiInstance::CalcBreakCallLevel()
USHORT nCallLvl; // Call-Level (wg. Rekursion)
USHORT nBreakCallLvl; // Call-Level zum Anhalten
void CalcBreakCallLevel( USHORT nFlags ); // Gemaess Flags setzen
SbiInstance( StarBASIC* );
~SbiInstance();
void Error( SbError ); // trappable Error
void Error( SbError, const String& rMsg ); // trappable Error mit Message
void FatalError( SbError ); // non-trappable Error
void FatalError( SbError, const String& ); // non-trappable Error
void Abort(); // Abbruch mit aktuellem Fehlercode
void Stop();
SbError GetErr() { return nErr; }
String GetErrorMsg() { return aErrorMsg; }
xub_StrLen GetErl() { return nErl; }
void EnableReschedule( BOOL bEnable ) { bReschedule = bEnable; }
BOOL IsReschedule( void ) { return bReschedule; }
void EnableCompatibility( BOOL bEnable ) { bCompatibility = bEnable; }
BOOL IsCompatibility( void ) { return bCompatibility; }
ComponentVector_t& getComponentVector( void ) { return ComponentVector; }
SbMethod* GetCaller( USHORT );
SbModule* GetActiveModule();
SbxArray* GetLocals( SbMethod* );
SbiIoSystem* GetIoSystem() { return pIosys; }
SbiDdeControl* GetDdeControl() { return pDdeCtrl; }
StarBASIC* GetBasic( void ) { return pBasic; }
SbiDllMgr* GetDllMgr();
SbiRTLData* GetRTLData() const { return (SbiRTLData*)&aRTLData; }
SvNumberFormatter* GetNumberFormatter();
sal_uInt32 GetStdDateIdx() const { return nStdDateIdx; }
sal_uInt32 GetStdTimeIdx() const { return nStdTimeIdx; }
sal_uInt32 GetStdDateTimeIdx() const { return nStdDateTimeIdx; }
// #39629# NumberFormatter auch statisch anbieten
static void PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter,
sal_uInt32 &rnStdDateIdx, sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx,
LanguageType* peFormatterLangType=NULL, DateFormat* peFormatterDateFormat=NULL );
};
SbiIoSystem* SbGetIoSystem(); // das aktuelle I/O-System
// Verkettbare Items, um Referenzen temporaer zu halten
struct RefSaveItem
{
SbxVariableRef xRef;
RefSaveItem* pNext;
RefSaveItem() { pNext = NULL; }
};
// Eine Instanz dieser Klasse wird fuer jedes ausgefuehrte Unterprogramm
// aufgesetzt. Diese Instanz ist das Herz der BASIC-Maschine und enthaelt
// nur lokale Daten.
class SbiRuntime
{
typedef void( SbiRuntime::*pStep0 )();
typedef void( SbiRuntime::*pStep1 )( UINT32 nOp1 );
typedef void( SbiRuntime::*pStep2 )( UINT32 nOp1, UINT32 nOp2 );
static pStep0 aStep0[]; // Opcode-Tabelle Gruppe 0
static pStep1 aStep1[]; // Opcode-Tabelle Gruppe 1
static pStep2 aStep2[]; // Opcode-Tabelle Gruppe 2
StarBASIC& rBasic; // StarBASIC-Instanz
SbiInstance* pInst; // aktiver Thread
SbModule* pMod; // aktuelles Modul
SbMethod* pMeth; // Methoden-Instanz
SbiIoSystem* pIosys; // I/O-System
const SbiImage* pImg; // Code-Image
SbxArrayRef refExprStk; // expression stack
SbxArrayRef refCaseStk; // CASE expression stack
SbxArrayRef refRedimpArray; // Array saved to use for REDIM PRESERVE
SbxVariableRef xDummyVar; // Ersatz fuer nicht gefundene Variablen
SbiArgvStack* pArgvStk; // ARGV-Stack
SbiGosubStack* pGosubStk; // GOSUB stack
SbiForStack* pForStk; // FOR/NEXT-Stack
USHORT nExprLvl; // Tiefe des Expr-Stacks
USHORT nGosubLvl; // Zum Vermeiden von Tot-Rekursionen
USHORT nForLvl; // #118235: Maintain for level
const BYTE* pCode; // aktueller Code-Pointer
const BYTE* pStmnt; // Beginn des lezten Statements
const BYTE* pError; // Adresse des aktuellen Error-Handlers
const BYTE* pRestart; // Restart-Adresse
const BYTE* pErrCode; // Restart-Adresse RESUME NEXT
const BYTE* pErrStmnt; // Restart-Adresse RESUMT 0
String aLibName; // Lib-Name fuer Declare-Call
SbxArrayRef refParams; // aktuelle Prozedur-Parameter
SbxArrayRef refLocals; // lokale Variable
SbxArrayRef refArgv; // aktueller Argv
// AB, 28.3.2000 #74254, Ein refSaveObj reicht nicht! Neu: pRefSaveList (s.u.)
//SbxVariableRef refSaveObj; // #56368 Bei StepElem Referenz sichern
short nArgc; // aktueller Argc
BOOL bRun; // TRUE: Programm ist aktiv
BOOL bError; // TRUE: Fehler behandeln
BOOL bInError; // TRUE: in einem Fehler-Handler
BOOL bBlocked; // TRUE: blocked by next call level, #i48868
BOOL bVBAEnabled;
USHORT nFlags; // Debugging-Flags
SbError nError; // letzter Fehler
USHORT nOps; // Opcode-Zaehler
sal_uInt32 m_nLastTime;
RefSaveItem* pRefSaveList; // #74254 Temporaere Referenzen sichern
RefSaveItem* pItemStoreList; // Unbenutzte Items aufbewahren
void SaveRef( SbxVariable* pVar )
{
RefSaveItem* pItem = pItemStoreList;
if( pItem )
pItemStoreList = pItem->pNext;
else
pItem = new RefSaveItem();
pItem->pNext = pRefSaveList;
pItem->xRef = pVar;
pRefSaveList = pItem;
}
void ClearRefs( void )
{
while( pRefSaveList )
{
RefSaveItem* pToClearItem = pRefSaveList;
pRefSaveList = pToClearItem->pNext;
pToClearItem->xRef = NULL;
pToClearItem->pNext = pItemStoreList;
pItemStoreList = pToClearItem;
}
}
SbxVariable* FindElement
( SbxObject* pObj, UINT32 nOp1, UINT32 nOp2, SbError, BOOL bLocal, BOOL bStatic = FALSE );
void SetupArgs( SbxVariable*, UINT32 );
SbxVariable* CheckArray( SbxVariable* );
void PushVar( SbxVariable* ); // Variable push
SbxVariableRef PopVar(); // Variable pop
SbxVariable* GetTOS( short=0 ); // Variable vom TOS holen
void TOSMakeTemp(); // TOS in temp. Variable wandeln
BOOL ClearExprStack(); // Expr-Stack freigeben
void PushGosub( const BYTE* ); // GOSUB-Element push
void PopGosub(); // GOSUB-Element pop
void ClearGosubStack(); // GOSUB-Stack freigeben
void PushArgv(); // Argv-Element push
void PopArgv(); // Argv-Element pop
void ClearArgvStack(); // Argv-Stack freigeben
void PushFor(); // For-Element push
void PushForEach(); // For-Each-Element push
void PopFor(); // For-Element pop
void ClearForStack(); // For-Stack freigeben
void StepArith( SbxOperator ); // arithmetische Verknuepfungen
void StepUnary( SbxOperator ); // unaere Verknuepfungen
void StepCompare( SbxOperator );// Vergleiche
void SetParameters( SbxArray* );// Parameter uebernehmen
// MUSS NOCH IMPLEMENTIERT WERDEN
void DllCall( const String&, const String&, SbxArray*, SbxDataType, BOOL );
// #56204 DIM-Funktionalitaet in Hilfsmethode auslagern (step0.cxx)
void DimImpl( SbxVariableRef refVar );
// #115829
bool implIsClass( SbxObject* pObj, const String& aClass );
void StepSETCLASS_impl( UINT32 nOp1, bool bHandleDflt = false );
// Die nachfolgenden Routinen werden vom Single Stepper
// gerufen und implementieren die einzelnen Opcodes
void StepNOP(), StepEXP(), StepMUL(), StepDIV();
void StepMOD(), StepPLUS(), StepMINUS(), StepNEG();
void StepEQ(), StepNE(), StepLT(), StepGT();
void StepLE(), StepGE(), StepIDIV(), StepAND();
void StepOR(), StepXOR(), StepEQV(), StepIMP();
void StepNOT(), StepCAT(), StepLIKE(), StepIS();
void StepCLONE(), StepOLDBASED(), StepARGC();
void StepARGV(), StepINPUT(), StepLINPUT(), StepSTOP();
void StepGET(), StepSET(), StepVBASET(), StepPUT(), StepPUTC();
void StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, bool bDefaultHandling = false );
void StepDIM(), StepREDIM(), StepREDIMP(), StepERASE();
void StepINITFOR(), StepNEXT(), StepERROR(), StepINITFOREACH();
void StepCASE(), StepENDCASE(), StepSTDERROR();
void StepNOERROR(), StepCHANNEL(), StepCHANNEL0(), StepPRINT();
void StepPRINTF(), StepWRITE(), StepRENAME(), StepPROMPT();
void StepRESTART(), StepEMPTY(), StepLEAVE();
void StepLSET(), StepRSET(), StepREDIMP_ERASE(), StepERASE_CLEAR();
void StepARRAYACCESS();
// Alle Opcodes mit einem Operanden
void StepLOADNC( UINT32 ), StepLOADSC( UINT32 ), StepLOADI( UINT32 );
void StepARGN( UINT32 ), StepBASED( UINT32 ), StepPAD( UINT32 );
void StepJUMP( UINT32 ), StepJUMPT( UINT32 );
void StepJUMPF( UINT32 ), StepONJUMP( UINT32 );
void StepGOSUB( UINT32 ), StepRETURN( UINT32 );
void StepTESTFOR( UINT32 ), StepCASETO( UINT32 ), StepERRHDL( UINT32 );
void StepRESUME( UINT32 ), StepSETCLASS( UINT32 ), StepVBASETCLASS( UINT32 ), StepTESTCLASS( UINT32 ), StepLIB( UINT32 );
bool checkClass_Impl( const SbxVariableRef& refVal, const String& aClass, bool bRaiseErrors );
void StepCLOSE( UINT32 ), StepPRCHAR( UINT32 ), StepARGTYP( UINT32 );
// Alle Opcodes mit zwei Operanden
void StepRTL( UINT32, UINT32 ), StepPUBLIC( UINT32, UINT32 ), StepPUBLIC_P( UINT32, UINT32 );
void StepPUBLIC_Impl( UINT32, UINT32, bool bUsedForClassModule );
void StepFIND_Impl( SbxObject* pObj, UINT32 nOp1, UINT32 nOp2, SbError, BOOL bLocal, BOOL bStatic = FALSE );
void StepFIND( UINT32, UINT32 ), StepELEM( UINT32, UINT32 );
void StepGLOBAL( UINT32, UINT32 ), StepLOCAL( UINT32, UINT32 );
void StepPARAM( UINT32, UINT32), StepCREATE( UINT32, UINT32 );
void StepCALL( UINT32, UINT32 ), StepCALLC( UINT32, UINT32 );
void StepCASEIS( UINT32, UINT32 ), StepSTMNT( UINT32, UINT32 );
SbxVariable* StepSTATIC_Impl( String& aName, SbxDataType& t );
void StepOPEN( UINT32, UINT32 ), StepSTATIC( UINT32, UINT32 );
void StepTCREATE(UINT32,UINT32), StepDCREATE(UINT32,UINT32);
void StepGLOBAL_P( UINT32, UINT32 ),StepFIND_G( UINT32, UINT32 );
void StepDCREATE_REDIMP(UINT32,UINT32), StepDCREATE_IMPL(UINT32,UINT32);
void StepFIND_CM( UINT32, UINT32 );
void StepFIND_STATIC( UINT32, UINT32 );
public:
void SetVBAEnabled( bool bEnabled ) { bVBAEnabled = bEnabled; };
USHORT GetImageFlag( USHORT n ) const;
USHORT GetBase();
xub_StrLen nLine,nCol1,nCol2; // aktuelle Zeile, Spaltenbereich
SbiRuntime* pNext; // Stack-Chain
SbiRuntime( SbModule*, SbMethod*, UINT32 );
~SbiRuntime();
void Error( SbError ); // Fehler setzen, falls != 0
void Error( SbError, const String& ); // Fehler setzen, falls != 0
void FatalError( SbError ); // Fehlerbehandlung=Standard, Fehler setzen
void FatalError( SbError, const String& ); // Fehlerbehandlung=Standard, Fehler setzen
void DumpPCode();
BOOL Step(); // Einzelschritt (ein Opcode)
void Stop() { bRun = FALSE; }
BOOL IsRun() { return bRun; }
void block( void ) { bBlocked = TRUE; }
void unblock( void ) { bBlocked = FALSE; }
SbMethod* GetMethod() { return pMeth; }
SbModule* GetModule() { return pMod; }
USHORT GetDebugFlags() { return nFlags; }
void SetDebugFlags( USHORT nFl ) { nFlags = nFl; }
SbMethod* GetCaller();
SbxArray* GetLocals();
SbxArray* GetParams();
SbxBase* FindElementExtern( const String& rName );
static bool isVBAEnabled();
};
inline void checkArithmeticOverflow( double d )
{
if( !::rtl::math::isFinite( d ) )
StarBASIC::Error( SbERR_MATH_OVERFLOW );
}
inline void checkArithmeticOverflow( SbxVariable* pVar )
{
if( pVar->GetType() == SbxDOUBLE )
{
double d = pVar->GetDouble();
checkArithmeticOverflow( d );
}
}
// Hilfsfunktion, um aktives Basic zu finden
StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic );
// Get information if security restrictions should be
// used (File IO based on UCB, no RTL function SHELL
// no DDE functionality, no DLLCALL) in basic because
// of portal "virtual" users (portal user != UNIX user)
// (Implemented in iosys.cxx)
BOOL needSecurityRestrictions( void );
// Returns TRUE if UNO is available, otherwise the old
// file system implementation has to be used
// (Implemented in iosys.cxx)
BOOL hasUno( void );
// Converts possibly relative paths to absolute paths
// according to the setting done by ChDir/ChDrive
// (Implemented in methods.cxx)
String getFullPath( const String& aRelPath );
// Sets (virtual) current path for UCB file access
void implChDir( const String& aDir );
// Sets (virtual) current drive for UCB file access
void implChDrive( const String& aDrive );
// Returns (virtual) current path for UCB file access
String implGetCurDir( void );
// Implementation of StepRENAME with UCB
// (Implemented in methods.cxx, so step0.cxx
// has not to be infected with UNO)
void implStepRenameUCB( const String& aSource, const String& aDest );
//*** OSL file access ***
// #87427 OSL need File URLs, so map to getFullPath
inline String getFullPathUNC( const String& aRelPath )
{
return getFullPath( aRelPath );
}
void implStepRenameOSL( const String& aSource, const String& aDest );
bool IsBaseIndexOne();
#endif
|
