LCOV - code coverage report
Current view: top level - basic/source/inc - runtime.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 59 0.0 %
Date: 2014-04-14 Functions: 0 30 0.0 %
Legend: Lines: hit not hit

          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             : #ifndef INCLUDED_BASIC_SOURCE_INC_RUNTIME_HXX
      21             : #define INCLUDED_BASIC_SOURCE_INC_RUNTIME_HXX
      22             : 
      23             : #include <basic/sbx.hxx>
      24             : 
      25             : #include "sb.hxx"
      26             : 
      27             : #include <rtl/ustring.hxx>
      28             : #include <com/sun/star/uno/Sequence.hxx>
      29             : #include <osl/file.hxx>
      30             : #include <rtl/math.hxx>
      31             : #include <i18nlangtag/lang.h>
      32             : 
      33             : #include <vector>
      34             : #include <com/sun/star/lang/XComponent.hpp>
      35             : #include <com/sun/star/container/XEnumeration.hpp>
      36             : #include <unotools/localedatawrapper.hxx>
      37             : 
      38             : class SbiInstance;                  // active StarBASIC process
      39             : class SbiRuntime;                   // active StarBASIC procedure instance
      40             : 
      41             : struct SbiArgvStack;                // Argv stack element
      42             : struct SbiGosubStack;               // GOSUB stack element
      43             : class  SbiImage;                    // Code-Image
      44             : class  SbiIoSystem;
      45             : class  SbiDdeControl;
      46             : class  SbiDllMgr;
      47             : class  SvNumberFormatter;           // time/date functions
      48             : 
      49             : enum ForType
      50             : {
      51             :     FOR_TO,
      52             :     FOR_EACH_ARRAY,
      53             :     FOR_EACH_COLLECTION,
      54             :     FOR_EACH_XENUMERATION
      55             : };
      56             : 
      57             : struct SbiForStack {                // for/next stack:
      58             :     SbiForStack*    pNext;          // Chain
      59             :     SbxVariableRef  refVar;         // loop variable
      60             :     SbxVariableRef  refEnd;         // end expression / for each: Array/BasicCollection object
      61             :     SbxVariableRef  refInc;         // increment expression
      62             : 
      63             :     // For each support
      64             :     ForType         eForType;
      65             :     sal_Int32           nCurCollectionIndex;
      66             :     sal_Int32*          pArrayCurIndices;
      67             :     sal_Int32*          pArrayLowerBounds;
      68             :     sal_Int32*          pArrayUpperBounds;
      69             :     css::uno::Reference< css::container::XEnumeration > xEnumeration;
      70             : 
      71           0 :     SbiForStack( void )
      72             :         : pNext(NULL)
      73             :         , eForType(FOR_TO)
      74             :         , nCurCollectionIndex(0)
      75             :         , pArrayCurIndices(NULL)
      76             :         , pArrayLowerBounds(NULL)
      77           0 :         , pArrayUpperBounds(NULL)
      78           0 :     {}
      79           0 :     ~SbiForStack()
      80           0 :     {
      81           0 :         delete[] pArrayCurIndices;
      82           0 :         delete[] pArrayLowerBounds;
      83           0 :         delete[] pArrayUpperBounds;
      84           0 :     }
      85             : };
      86             : 
      87             : struct SbiGosubStack {              // GOSUB-Stack:
      88             :     SbiGosubStack* pNext;           // Chain
      89             :     const sal_uInt8* pCode;             // Return-Pointer
      90             :     sal_uInt16 nStartForLvl;            // #118235: For Level in moment of gosub
      91             : };
      92             : 
      93             : #define MAXRECURSION 500
      94             : 
      95             : #define Sb_ATTR_NORMAL      0x0000
      96             : #define Sb_ATTR_READONLY    0x0001
      97             : #define Sb_ATTR_HIDDEN      0x0002
      98             : #define Sb_ATTR_SYSTEM      0x0004
      99             : #define Sb_ATTR_VOLUME      0x0008
     100             : #define Sb_ATTR_DIRECTORY   0x0010
     101             : #define Sb_ATTR_ARCHIVE     0x0020
     102             : 
     103             : 
     104             : class WildCard;
     105             : 
     106             : class SbiRTLData
     107             : {
     108             : public:
     109             : 
     110             :     ::osl::Directory* pDir;
     111             :     sal_Int16   nDirFlags;
     112             :     short   nCurDirPos;
     113             : 
     114             :     OUString sFullNameToBeChecked;
     115             :     WildCard* pWildCard;
     116             : 
     117             :     css::uno::Sequence< OUString > aDirSeq;
     118             : 
     119             :     SbiRTLData();
     120             :     ~SbiRTLData();
     121             : };
     122             : 
     123             : // The instance matches a running StarBASIC. Many basics running at the same
     124             : // time are managed by chained instances. There is all the data that only lives
     125             : // when the BASIC is living too, like the I/O-system.
     126             : 
     127             : typedef ::std::vector
     128             : <
     129             :     ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent >
     130             : >
     131             : ComponentVector_t;
     132             : 
     133             : 
     134             : class SbiInstance
     135             : {
     136             :     friend class SbiRuntime;
     137             : 
     138             :     SbiRTLData      aRTLData;
     139             : 
     140             :     SbiIoSystem*    pIosys;         // file system
     141             :     SbiDdeControl*  pDdeCtrl;       // DDE
     142             :     SbiDllMgr*      pDllMgr;        // DLL-Calls (DECLARE)
     143             :     StarBASIC*      pBasic;
     144             :     SvNumberFormatter* pNumberFormatter;
     145             :     LanguageType    meFormatterLangType;
     146             :     DateFormat      meFormatterDateFormat;
     147             :     sal_uInt32      nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx;
     148             : 
     149             :     SbError         nErr;
     150             :     OUString        aErrorMsg;      // last error message for $ARG
     151             :     sal_Int32       nErl;           // current error line
     152             :     bool        bReschedule;    // Flag: sal_True = Reschedule in main loop
     153             :     bool        bCompatibility; // Flag: sal_True = VBA runtime compatibility mode
     154             : 
     155             :     ComponentVector_t ComponentVector;
     156             : public:
     157             :     SbiRuntime*  pRun;              // Call-Stack
     158             :     SbiInstance* pNext;             // instances chain
     159             : 
     160             :     // #31460 new concept for StepInto/Over/Out,
     161             :     // Explaination see runtime.cxx at SbiInstance::CalcBreakCallLevel()
     162             :     sal_uInt16  nCallLvl;
     163             :     sal_uInt16  nBreakCallLvl;
     164             :     void    CalcBreakCallLevel( sal_uInt16 nFlags );
     165             : 
     166             :     SbiInstance( StarBASIC* );
     167             :    ~SbiInstance();
     168             : 
     169             :     void Error( SbError );                      // trappable Error
     170             :     void Error( SbError, const OUString& rMsg );  // trappable Error with message
     171             :     void ErrorVB( sal_Int32 nVBNumber, const OUString& rMsg );
     172             :     void setErrorVB( sal_Int32 nVBNumber, const OUString& rMsg );
     173             :     void FatalError( SbError );                 // non-trappable Error
     174             :     void FatalError( SbError, const OUString& );  // non-trappable Error
     175             :     void Abort();                               // with current error code
     176             : 
     177             :     void    Stop();
     178           0 :     SbError GetErr()                { return nErr; }
     179           0 :     OUString  GetErrorMsg()           { return aErrorMsg; }
     180           0 :     sal_Int32 GetErl()             { return nErl; }
     181           0 :     void    EnableReschedule( bool bEnable ) { bReschedule = bEnable; }
     182           0 :     bool    IsReschedule( void ) { return bReschedule; }
     183           0 :     void    EnableCompatibility( bool bEnable ) { bCompatibility = bEnable; }
     184           0 :     bool    IsCompatibility( void ) { return bCompatibility; }
     185             : 
     186           0 :     ComponentVector_t& getComponentVector( void )  { return ComponentVector; }
     187             : 
     188             :     SbMethod* GetCaller( sal_uInt16 );
     189             :     SbModule* GetActiveModule();
     190             : 
     191           0 :     SbiIoSystem* GetIoSystem() { return pIosys; }
     192           0 :     SbiDdeControl* GetDdeControl() { return pDdeCtrl; }
     193           0 :     StarBASIC* GetBasic( void ) { return pBasic; }
     194             :     SbiDllMgr* GetDllMgr();
     195           0 :     SbiRTLData* GetRTLData() const { return (SbiRTLData*)&aRTLData; }
     196             : 
     197             :     SvNumberFormatter* GetNumberFormatter();
     198           0 :     sal_uInt32 GetStdDateIdx() const { return nStdDateIdx; }
     199           0 :     sal_uInt32 GetStdTimeIdx() const { return nStdTimeIdx; }
     200           0 :     sal_uInt32 GetStdDateTimeIdx() const { return nStdDateTimeIdx; }
     201             : 
     202             :     // offer NumberFormatter also static
     203             :     static void PrepareNumberFormatter( SvNumberFormatter*& rpNumberFormatter,
     204             :         sal_uInt32 &rnStdDateIdx, sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx,
     205             :         LanguageType* peFormatterLangType=NULL, DateFormat* peFormatterDateFormat=NULL );
     206             : };
     207             : 
     208             : SbiIoSystem* SbGetIoSystem();
     209             : 
     210             : 
     211             : // chainable items to keep references temporary
     212           0 : struct RefSaveItem
     213             : {
     214             :     SbxVariableRef xRef;
     215             :     RefSaveItem* pNext;
     216             : 
     217           0 :     RefSaveItem() { pNext = NULL; }
     218             : };
     219             : 
     220             : 
     221             : // There's one instance of this class for every executed sub-program.
     222             : // This instance is the heart of the BASIC-machine and contains only local data.
     223             : 
     224             : class SbiRuntime
     225             : {
     226             :     friend void SbRtl_CallByName( StarBASIC* pBasic, SbxArray& rPar, bool bWrite );
     227             : 
     228             :     typedef void( SbiRuntime::*pStep0 )();
     229             :     typedef void( SbiRuntime::*pStep1 )( sal_uInt32 nOp1 );
     230             :     typedef void( SbiRuntime::*pStep2 )( sal_uInt32 nOp1, sal_uInt32 nOp2 );
     231             :     static pStep0 aStep0[];         // opcode-table group 0
     232             :     static pStep1 aStep1[];
     233             :     static pStep2 aStep2[];
     234             : 
     235             :     StarBASIC&    rBasic;           // StarBASIC instance
     236             :     SbiInstance*   pInst;           // current thread
     237             :     SbModule*     pMod;             // current module
     238             :     SbMethod*     pMeth;            // method instance
     239             :     SbiIoSystem*   pIosys;          // I/O-System
     240             :     const SbiImage* pImg;           // Code-Image
     241             :     SbxArrayRef   refExprStk;       // expression stack
     242             :     SbxArrayRef   refCaseStk;       // CASE expression stack
     243             :     SbxArrayRef   refRedimpArray;   // Array saved to use for REDIM PRESERVE
     244             :     SbxVariableRef   refRedim;   // Array saved to use for REDIM
     245             :     SbxVariableRef xDummyVar;       // substitute for variables that weren't found
     246             :     SbxVariable* mpExtCaller;       // Caller ( external - e.g. button name, shape, range object etc. - only in vba mode )
     247             :     SbiArgvStack*  pArgvStk;        // ARGV-Stack
     248             :     SbiGosubStack* pGosubStk;       // GOSUB stack
     249             :     SbiForStack*   pForStk;         // FOR/NEXT-Stack
     250             :     sal_uInt16        nExprLvl;         // depth of the expr-stack
     251             :     sal_uInt16        nGosubLvl;        // to prevent dead-recursions
     252             :     sal_uInt16        nForLvl;          // #118235: Maintain for level
     253             :     const sal_uInt8*   pCode;            // current Code-Pointer
     254             :     const sal_uInt8*   pStmnt;           // beginning of the last statement
     255             :     const sal_uInt8*   pError;           // address of the current error handler
     256             :     const sal_uInt8*   pRestart;         // restart-address
     257             :     const sal_uInt8*   pErrCode;         // restart-adresse RESUME NEXT
     258             :     const sal_uInt8*   pErrStmnt;        // Restart-Adresse RESUMT 0
     259             :     OUString        aLibName;         // Lib-name for declare-call
     260             :     SbxArrayRef   refParams;        // current procedure parameters
     261             :     SbxArrayRef   refLocals;        // local variable
     262             :     SbxArrayRef   refArgv;
     263             :     // #74254, one refSaveObj is not enough! new: pRefSaveList (see above)
     264             :     short         nArgc;
     265             :     bool          bRun;
     266             :     bool          bError;           // true: handle errors
     267             :     bool          bInError;         // true: in an error handler
     268             :     bool          bBlocked;         // true: blocked by next call level, #i48868
     269             :     bool          bVBAEnabled;
     270             :     sal_uInt16        nFlags;           // Debugging-Flags
     271             :     SbError       nError;
     272             :     sal_uInt16        nOps;             // opcode counter
     273             :     sal_uInt32    m_nLastTime;
     274             : 
     275             :     RefSaveItem*  pRefSaveList;     // #74254 save temporary references
     276             :     RefSaveItem*  pItemStoreList;   // keep unused items
     277           0 :     void SaveRef( SbxVariable* pVar )
     278             :     {
     279           0 :         RefSaveItem* pItem = pItemStoreList;
     280           0 :         if( pItem )
     281           0 :             pItemStoreList = pItem->pNext;
     282             :         else
     283           0 :             pItem = new RefSaveItem();
     284           0 :         pItem->pNext = pRefSaveList;
     285           0 :         pItem->xRef = pVar;
     286           0 :         pRefSaveList = pItem;
     287           0 :     }
     288           0 :     void ClearRefs( void )
     289             :     {
     290           0 :         while( pRefSaveList )
     291             :         {
     292           0 :             RefSaveItem* pToClearItem = pRefSaveList;
     293           0 :             pRefSaveList = pToClearItem->pNext;
     294           0 :             pToClearItem->xRef = NULL;
     295           0 :             pToClearItem->pNext = pItemStoreList;
     296           0 :             pItemStoreList = pToClearItem;
     297             :         }
     298           0 :     }
     299             : 
     300             :     SbxVariable* FindElement
     301             :     ( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError, bool bLocal, bool bStatic = false );
     302             :     void SetupArgs( SbxVariable*, sal_uInt32 );
     303             :     SbxVariable* CheckArray( SbxVariable* );
     304             : 
     305             :     void PushVar( SbxVariable* );
     306             :     SbxVariableRef PopVar();
     307             :     SbxVariable* GetTOS( short=0 );
     308             :     void TOSMakeTemp();
     309             :     bool ClearExprStack();
     310             : 
     311             :     void PushGosub( const sal_uInt8* );
     312             :     void PopGosub();
     313             :     void ClearGosubStack();
     314             : 
     315             :     void PushArgv();
     316             :     void PopArgv();
     317             :     void ClearArgvStack();
     318             : 
     319             :     void PushFor();
     320             :     void PushForEach();
     321             :     void PopFor();
     322             :     void ClearForStack();
     323             : 
     324             :     void StepArith( SbxOperator );
     325             :     void StepUnary( SbxOperator );
     326             :     void StepCompare( SbxOperator );
     327             : 
     328             :     void SetParameters( SbxArray* );
     329             : 
     330             :     // HAS TO BE IMPLEMENTED SOME TIME
     331             :     void DllCall( const OUString&, const OUString&, SbxArray*, SbxDataType, bool );
     332             : 
     333             :     // #56204 swap out DIM-functionality into help method (step0.cxx)
     334             :     void DimImpl( SbxVariableRef refVar );
     335             : 
     336             :     bool implIsClass( SbxObject* pObj, const OUString& aClass );
     337             : 
     338             :     void StepSETCLASS_impl( sal_uInt32 nOp1, bool bHandleDflt = false );
     339             : 
     340             :     // the following routines are called by the single
     341             :     // stepper and implement the single opcodes
     342             :     void StepNOP(),     StepEXP(),      StepMUL(),      StepDIV();
     343             :     void StepMOD(),     StepPLUS(),     StepMINUS(),    StepNEG();
     344             :     void StepEQ(),      StepNE(),       StepLT(),       StepGT();
     345             :     void StepLE(),      StepGE(),       StepIDIV(),     StepAND();
     346             :     void StepOR(),      StepXOR(),      StepEQV(),      StepIMP();
     347             :     void StepNOT(),     StepCAT(),      StepLIKE(),     StepIS();
     348             :     void StepCLONE(),   StepOLDBASED(), StepARGC();
     349             :     void StepARGV(),    StepINPUT(),    StepLINPUT(),   StepSTOP();
     350             :     void StepGET(),     StepSET(),  StepVBASET(),   StepPUT(),      StepPUTC();
     351             :     void StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, bool bDefaultHandling = false );
     352             :     void StepDIM(),     StepREDIM(),    StepREDIMP(),   StepERASE();
     353             :     void StepINITFOR(), StepNEXT(),     StepERROR(),    StepINITFOREACH();
     354             :     void StepCASE(),    StepENDCASE(),  StepSTDERROR();
     355             :     void StepNOERROR(), StepCHANNEL(),  StepCHANNEL0(), StepPRINT();
     356             :     void StepPRINTF(),  StepWRITE(),    StepRENAME(),   StepPROMPT();
     357             :     void StepRESTART(), StepEMPTY(),    StepLEAVE();
     358             :     void StepLSET(),    StepRSET(),     StepREDIMP_ERASE(),     StepERASE_CLEAR();
     359             :     void StepARRAYACCESS(), StepBYVAL();
     360             :     // all opcodes with one operand
     361             :     void StepLOADNC( sal_uInt32 ),  StepLOADSC( sal_uInt32 ),   StepLOADI( sal_uInt32 );
     362             :     void StepARGN( sal_uInt32 ),    StepBASED( sal_uInt32 ),    StepPAD( sal_uInt32 );
     363             :     void StepJUMP( sal_uInt32 ),    StepJUMPT( sal_uInt32 );
     364             :     void StepJUMPF( sal_uInt32 ),   StepONJUMP( sal_uInt32 );
     365             :     void StepGOSUB( sal_uInt32 ),   StepRETURN( sal_uInt32 );
     366             :     void StepTESTFOR( sal_uInt32 ), StepCASETO( sal_uInt32 ),   StepERRHDL( sal_uInt32 );
     367             :     void StepRESUME( sal_uInt32 ),  StepSETCLASS( sal_uInt32 ), StepVBASETCLASS( sal_uInt32 ),  StepTESTCLASS( sal_uInt32 ), StepLIB( sal_uInt32 );
     368             :     bool checkClass_Impl( const SbxVariableRef& refVal, const OUString& aClass, bool bRaiseErrors, bool bDefault = true );
     369             :     void StepCLOSE( sal_uInt32 ),   StepPRCHAR( sal_uInt32 ),   StepARGTYP( sal_uInt32 );
     370             :     // all opcodes with two operands
     371             :     void StepRTL( sal_uInt32, sal_uInt32 ),     StepPUBLIC( sal_uInt32, sal_uInt32 ),   StepPUBLIC_P( sal_uInt32, sal_uInt32 );
     372             :     void StepPUBLIC_Impl( sal_uInt32, sal_uInt32, bool bUsedForClassModule );
     373             :     void StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, SbError, bool bLocal, bool bStatic = false );
     374             :     void StepFIND( sal_uInt32, sal_uInt32 ),    StepELEM( sal_uInt32, sal_uInt32 );
     375             :     void StepGLOBAL( sal_uInt32, sal_uInt32 ),  StepLOCAL( sal_uInt32, sal_uInt32 );
     376             :     void StepPARAM( sal_uInt32, sal_uInt32),    StepCREATE( sal_uInt32, sal_uInt32 );
     377             :     void StepCALL( sal_uInt32, sal_uInt32 ),    StepCALLC( sal_uInt32, sal_uInt32 );
     378             :     void StepCASEIS( sal_uInt32, sal_uInt32 ),  StepSTMNT( sal_uInt32, sal_uInt32 );
     379             :     SbxVariable* StepSTATIC_Impl( OUString& aName, SbxDataType& t );
     380             :     void StepOPEN( sal_uInt32, sal_uInt32 ),    StepSTATIC( sal_uInt32, sal_uInt32 );
     381             :     void StepTCREATE(sal_uInt32,sal_uInt32),    StepDCREATE(sal_uInt32,sal_uInt32);
     382             :     void StepGLOBAL_P( sal_uInt32, sal_uInt32 ),StepFIND_G( sal_uInt32, sal_uInt32 );
     383             :     void StepDCREATE_REDIMP(sal_uInt32,sal_uInt32), StepDCREATE_IMPL(sal_uInt32,sal_uInt32);
     384             :     void StepFIND_CM( sal_uInt32, sal_uInt32 );
     385             :     void StepFIND_STATIC( sal_uInt32, sal_uInt32 );
     386             :     void implHandleSbxFlags( SbxVariable* pVar, SbxDataType t, sal_uInt32 nOp2 );
     387             : public:
     388             :     void          SetVBAEnabled( bool bEnabled );
     389             :     sal_uInt16      GetImageFlag( sal_uInt16 n ) const;
     390             :     sal_uInt16      GetBase();
     391             :     sal_Int32  nLine,nCol1,nCol2;
     392             :     SbiRuntime* pNext;               // Stack-Chain
     393             : 
     394             :     SbiRuntime( SbModule*, SbMethod*, sal_uInt32 );
     395             :    ~SbiRuntime();
     396             :     void Error( SbError, bool bVBATranslationAlreadyDone = false );     // set error if != 0
     397             :     void Error( SbError, const OUString& );       // set error if != 0
     398             :     void FatalError( SbError );                 // error handling = standard, set error
     399             :     void FatalError( SbError, const OUString& );  // error handling = standard, set error
     400             :     static sal_Int32 translateErrorToVba( SbError nError, OUString& rMsg );
     401             :     void DumpPCode();
     402             :     bool Step();                    // single step (one opcode)
     403           0 :     void Stop()            { bRun = false;   }
     404           0 :     void block( void )     { bBlocked = true; }
     405           0 :     void unblock( void )   { bBlocked = false; }
     406             :     SbMethod* GetMethod()  { return pMeth;   }
     407           0 :     SbModule* GetModule()  { return pMod;    }
     408           0 :     sal_uInt16 GetDebugFlags() { return nFlags;  }
     409           0 :     void SetDebugFlags( sal_uInt16 nFl ) { nFlags = nFl;  }
     410             :     SbMethod* GetCaller();
     411           0 :     SbxVariable* GetExternalCaller(){ return mpExtCaller; }
     412             : 
     413             :     SbiForStack* FindForStackItemForCollection( class BasicCollection* pCollection );
     414             : 
     415             :     SbxBase* FindElementExtern( const OUString& rName );
     416             :     static bool isVBAEnabled();
     417             : 
     418             : };
     419             : 
     420           0 : inline void checkArithmeticOverflow( double d )
     421             : {
     422           0 :     if( !::rtl::math::isFinite( d ) )
     423           0 :         StarBASIC::Error( SbERR_MATH_OVERFLOW );
     424           0 : }
     425             : 
     426           0 : inline void checkArithmeticOverflow( SbxVariable* pVar )
     427             : {
     428           0 :     if( pVar->GetType() == SbxDOUBLE )
     429             :     {
     430           0 :         double d = pVar->GetDouble();
     431           0 :         checkArithmeticOverflow( d );
     432             :     }
     433           0 : }
     434             : 
     435             : 
     436             : StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic );
     437             : 
     438             : // Get information if security restrictions should be
     439             : // used (File IO based on UCB, no RTL function SHELL
     440             : // no DDE functionality, no DLLCALL) in basic because
     441             : // of portal "virtual" users (portal user != UNIX user)
     442             : // (Implemented in iosys.cxx)
     443             : bool needSecurityRestrictions( void );
     444             : 
     445             : // Returns true if UNO is available, otherwise the old
     446             : // file system implementation has to be used
     447             : // (Implemented in iosys.cxx)
     448             : bool hasUno( void );
     449             : 
     450             : // Converts possibly relative paths to absolute paths
     451             : // according to the setting done by ChDir/ChDrive
     452             : // (Implemented in methods.cxx)
     453             : OUString getFullPath( const OUString& aRelPath );
     454             : 
     455             : // Implementation of StepRENAME with UCB
     456             : // (Implemented in methods.cxx, so step0.cxx
     457             : // has not to be infected with UNO)
     458             : void implStepRenameUCB( const OUString& aSource, const OUString& aDest );
     459             : 
     460             : void implStepRenameOSL( const OUString& aSource, const OUString& aDest );
     461             : bool IsBaseIndexOne();
     462             : 
     463             : void removeDimAsNewRecoverItem( SbxVariable* pVar );
     464             : 
     465             : #endif
     466             : 
     467             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10