/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx
Warning:	line 683, column 29 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name runtime.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D BASIC_DLLIMPLEMENTATION -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/basic/inc -I /home/maarten/src/libreoffice/core/basic/source/inc -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <stdlib.h>

22#include <algorithm>
23#include <string_view>
24#include <unordered_map>

26#include <com/sun/star/beans/XPropertySet.hpp>
27#include <com/sun/star/container/XEnumerationAccess.hpp>
28#include <com/sun/star/container/XIndexAccess.hpp>
29#include <com/sun/star/script/XDefaultMethod.hpp>
30#include <com/sun/star/uno/Any.hxx>
31#include <com/sun/star/util/SearchAlgorithms2.hpp>

33#include <comphelper/processfactory.hxx>
34#include <comphelper/string.hxx>
35#include <o3tl/safeint.hxx>
36#include <sal/log.hxx>

38#include <tools/wldcrd.hxx>
39#include <tools/diagnose_ex.h>

41#include <vcl/svapp.hxx>
42#include <vcl/settings.hxx>

44#include <rtl/instance.hxx>
45#include <rtl/math.hxx>
46#include <rtl/ustrbuf.hxx>
47#include <rtl/character.hxx>

49#include <svl/zforlist.hxx>

51#include <i18nutil/searchopt.hxx>
52#include <unotools/syslocale.hxx>
53#include <unotools/textsearch.hxx>

55#include <basic/sbuno.hxx>

57#include <codegen.hxx>
58#include "comenumwrapper.hxx"
59#include "ddectrl.hxx"
60#include "dllmgr.hxx"
61#include <errobject.hxx>
62#include <image.hxx>
63#include <iosys.hxx>
64#include <opcodes.hxx>
65#include <runtime.hxx>
66#include <sb.hxx>
67#include <sbintern.hxx>
68#include <sbprop.hxx>
69#include <sbunoobj.hxx>
70#include <basic/codecompletecache.hxx>
71#include <memory>

73using com::sun::star::uno::Reference;

75using namespace com::sun::star::uno;
76using namespace com::sun::star::container;
77using namespace com::sun::star::lang;
78using namespace com::sun::star::beans;
79using namespace com::sun::star::script;

81using namespace ::com::sun::star;

83static void lcl_clearImpl( SbxVariableRef const & refVar, SbxDataType const & eType );
84static void lcl_eraseImpl( SbxVariableRef const & refVar, bool bVBAEnabled );

86bool SbiRuntime::isVBAEnabled()
87{
  bool bResult = false;
  SbiInstance* pInst = GetSbData()->pInst;
  if ( pInst && GetSbData()->pInst->pRun )
      bResult = pInst->pRun->bVBAEnabled;
  return bResult;
93}

95void StarBASIC::SetVBAEnabled( bool bEnabled )
96{
  if ( bDocBasic )
  {
      bVBAEnabled = bEnabled;
  }
101}

103bool StarBASIC::isVBAEnabled() const
104{
  if ( bDocBasic )
  {
      if( SbiRuntime::isVBAEnabled() )
          return true;
      return bVBAEnabled;
  }
  return false;
112}

114struct SbiArgv {                   // Argv stack:
  SbxArrayRef    refArgv;             // Argv
  short nArgc;                        // Argc

  SbiArgv(SbxArrayRef const & refArgv_, short nArgc_) :
      refArgv(refArgv_),
      nArgc(nArgc_) {}
121};

123struct SbiGosub {              // GOSUB-Stack:
  const sal_uInt8* pCode;         // Return-Pointer
  sal_uInt16 nStartForLvl;        // #118235: For Level in moment of gosub

  SbiGosub(const sal_uInt8* pCode_, sal_uInt16 nStartForLvl_) :
      pCode(pCode_),
      nStartForLvl(nStartForLvl_) {}
130};

132SbiRuntime::pStep0 SbiRuntime::aStep0[] = { // all opcodes without operands
  &SbiRuntime::StepNOP,
  &SbiRuntime::StepEXP,
  &SbiRuntime::StepMUL,
  &SbiRuntime::StepDIV,
  &SbiRuntime::StepMOD,
  &SbiRuntime::StepPLUS,
  &SbiRuntime::StepMINUS,
  &SbiRuntime::StepNEG,
  &SbiRuntime::StepEQ,
  &SbiRuntime::StepNE,
  &SbiRuntime::StepLT,
  &SbiRuntime::StepGT,
  &SbiRuntime::StepLE,
  &SbiRuntime::StepGE,
  &SbiRuntime::StepIDIV,
  &SbiRuntime::StepAND,
  &SbiRuntime::StepOR,
  &SbiRuntime::StepXOR,
  &SbiRuntime::StepEQV,
  &SbiRuntime::StepIMP,
  &SbiRuntime::StepNOT,
  &SbiRuntime::StepCAT,

  &SbiRuntime::StepLIKE,
  &SbiRuntime::StepIS,
  // load/save
  &SbiRuntime::StepARGC,      // establish new Argv
  &SbiRuntime::StepARGV,      // TOS ==> current Argv
  &SbiRuntime::StepINPUT,     // Input ==> TOS
  &SbiRuntime::StepLINPUT,        // Line Input ==> TOS
  &SbiRuntime::StepGET,        // touch TOS
  &SbiRuntime::StepSET,        // save object TOS ==> TOS-1
  &SbiRuntime::StepPUT,       // TOS ==> TOS-1
  &SbiRuntime::StepPUTC,      // TOS ==> TOS-1, then ReadOnly
  &SbiRuntime::StepDIM,       // DIM
  &SbiRuntime::StepREDIM,         // REDIM
  &SbiRuntime::StepREDIMP,        // REDIM PRESERVE
  &SbiRuntime::StepERASE,         // delete TOS
  // branch
  &SbiRuntime::StepSTOP,          // program end
  &SbiRuntime::StepINITFOR,   // initialize FOR-Variable
  &SbiRuntime::StepNEXT,      // increment FOR-Variable
  &SbiRuntime::StepCASE,      // beginning CASE
  &SbiRuntime::StepENDCASE,   // end CASE
  &SbiRuntime::StepSTDERROR,      // standard error handling
  &SbiRuntime::StepNOERROR,   // no error handling
  &SbiRuntime::StepLEAVE,     // leave UP
  // E/A
  &SbiRuntime::StepCHANNEL,   // TOS = channel number
  &SbiRuntime::StepPRINT,     // print TOS
  &SbiRuntime::StepPRINTF,        // print TOS in field
  &SbiRuntime::StepWRITE,     // write TOS
  &SbiRuntime::StepRENAME,        // Rename Tos+1 to Tos
  &SbiRuntime::StepPROMPT,        // define Input Prompt from TOS
  &SbiRuntime::StepRESTART,   // Set restart point
  &SbiRuntime::StepCHANNEL0,  // set E/A-channel 0
  &SbiRuntime::StepEMPTY,     // empty expression on stack
  &SbiRuntime::StepERROR,     // TOS = error code
  &SbiRuntime::StepLSET,      // save object TOS ==> TOS-1
  &SbiRuntime::StepRSET,      // save object TOS ==> TOS-1
  &SbiRuntime::StepREDIMP_ERASE,// Copy array object for REDIMP
  &SbiRuntime::StepINITFOREACH,// Init for each loop
  &SbiRuntime::StepVBASET,// vba-like set statement
  &SbiRuntime::StepERASE_CLEAR,// vba-like set statement
  &SbiRuntime::StepARRAYACCESS,// access TOS as array
  &SbiRuntime::StepBYVAL,     // access TOS as array
199};

201SbiRuntime::pStep1 SbiRuntime::aStep1[] = { // all opcodes with one operand
  &SbiRuntime::StepLOADNC,        // loading a numeric constant (+ID)
  &SbiRuntime::StepLOADSC,        // loading a string constant (+ID)
  &SbiRuntime::StepLOADI,     // Immediate Load (+value)
  &SbiRuntime::StepARGN,      // save a named Args in Argv (+StringID)
  &SbiRuntime::StepPAD,       // bring string to a definite length (+length)
  // branches
  &SbiRuntime::StepJUMP,      // jump (+Target)
  &SbiRuntime::StepJUMPT,     // evaluate TOS, conditional jump (+Target)
  &SbiRuntime::StepJUMPF,     // evaluate TOS, conditional jump (+Target)
  &SbiRuntime::StepONJUMP,        // evaluate TOS, jump into JUMP-table (+MaxVal)
  &SbiRuntime::StepGOSUB,     // UP-call (+Target)
  &SbiRuntime::StepRETURN,        // UP-return (+0 or Target)
  &SbiRuntime::StepTESTFOR,   // check FOR-variable, increment (+Endlabel)
  &SbiRuntime::StepCASETO,        // Tos+1 <= Case <= Tos), 2xremove (+Target)
  &SbiRuntime::StepERRHDL,        // error handler (+Offset)
  &SbiRuntime::StepRESUME,        // resume after errors (+0 or 1 or Label)
  // E/A
  &SbiRuntime::StepCLOSE,     // (+channel/0)
  &SbiRuntime::StepPRCHAR,        // (+char)
  // management
  &SbiRuntime::StepSETCLASS,  // check set + class names (+StringId)
  &SbiRuntime::StepTESTCLASS, // Check TOS class (+StringId)
  &SbiRuntime::StepLIB,       // lib for declare-call (+StringId)
  &SbiRuntime::StepBASED,     // TOS is incremented by BASE, BASE is pushed before
  &SbiRuntime::StepARGTYP,        // convert last parameter in Argv (+Type)
  &SbiRuntime::StepVBASETCLASS,// vba-like set statement
228};

230SbiRuntime::pStep2 SbiRuntime::aStep2[] = {// all opcodes with two operands
  &SbiRuntime::StepRTL,       // load from RTL (+StringID+Typ)
  &SbiRuntime::StepFIND,      // load (+StringID+Typ)
  &SbiRuntime::StepELEM,          // load element (+StringID+Typ)
  &SbiRuntime::StepPARAM,     // Parameter (+Offset+Typ)
  // branches
  &SbiRuntime::StepCALL,      // Declare-Call (+StringID+Typ)
  &SbiRuntime::StepCALLC,     // CDecl-Declare-Call (+StringID+Typ)
  &SbiRuntime::StepCASEIS,        // Case-Test (+Test-Opcode+False-Target)
  // management
  &SbiRuntime::StepSTMNT,         // beginning of a statement (+Line+Col)
  // E/A
  &SbiRuntime::StepOPEN,          // (+StreamMode+Flags)
  // Objects
  &SbiRuntime::StepLOCAL,     // define local variable (+StringId+Typ)
  &SbiRuntime::StepPUBLIC,        // module global variable (+StringID+Typ)
  &SbiRuntime::StepGLOBAL,        // define global variable (+StringID+Typ)
  &SbiRuntime::StepCREATE,        // create object (+StringId+StringId)
  &SbiRuntime::StepSTATIC,     // static variable (+StringId+StringId)
  &SbiRuntime::StepTCREATE,    // user-defined objects (+StringId+StringId)
  &SbiRuntime::StepDCREATE,    // create object-array (+StringID+StringID)
  &SbiRuntime::StepGLOBAL_P,   // define global variable which is not overwritten
                               // by the Basic on a restart (+StringID+Typ)
  &SbiRuntime::StepFIND_G,        // finds global variable with special treatment because of _GLOBAL_P
  &SbiRuntime::StepDCREATE_REDIMP, // redimension object array (+StringID+StringID)
  &SbiRuntime::StepFIND_CM,    // Search inside a class module (CM) to enable global search in time
  &SbiRuntime::StepPUBLIC_P,    // Search inside a class module (CM) to enable global search in time
  &SbiRuntime::StepFIND_STATIC,    // Search inside a class module (CM) to enable global search in time
258};


261//                              SbiRTLData

263SbiRTLData::SbiRTLData()
264{
  nDirFlags   = SbAttributes::NONE;
  nCurDirPos  = 0;
267}

269SbiRTLData::~SbiRTLData()
270{
271}

273//                              SbiInstance

275// 16.10.96: #31460 new concept for StepInto/Over/Out
276// The decision whether StepPoint shall be called is done with the help of
277// the CallLevel. It's stopped when the current CallLevel is <= nBreakCallLvl.
278// The current CallLevel can never be smaller than 1, as it's also incremented
279// during the call of a method (also main). Therefore a BreakCallLvl from 0
280// means that the program isn't stopped at all.
281// (also have a look at: step2.cxx, SbiRuntime::StepSTMNT() )


284void SbiInstance::CalcBreakCallLevel( BasicDebugFlags nFlags )
285{

  nFlags &= ~BasicDebugFlags::Break;

  sal_uInt16 nRet;
  if (nFlags  == BasicDebugFlags::StepInto) {
      nRet = nCallLvl + 1;    // CallLevel+1 is also stopped
  } else if (nFlags == (BasicDebugFlags::StepOver | BasicDebugFlags::StepInto)) {
      nRet = nCallLvl;        // current CallLevel is stopped
  } else if (nFlags == BasicDebugFlags::StepOut) {
      nRet = nCallLvl - 1;    // smaller CallLevel is stopped
  } else {
      // Basic-IDE returns 0 instead of BasicDebugFlags::Continue, so also default=continue
      nRet = 0;               // CallLevel is always > 0 -> no StepPoint
  }
  nBreakCallLvl = nRet;           // take result
301}

303SbiInstance::SbiInstance( StarBASIC* p )
  : pIosys(new SbiIoSystem)
  , pDdeCtrl(new SbiDdeControl)
  , pBasic(p)
  , meFormatterLangType(LANGUAGE_DONTKNOWLanguageType(0x03FF))
  , meFormatterDateOrder(DateOrder::YMD)
  , nStdDateIdx(0)
  , nStdTimeIdx(0)
  , nStdDateTimeIdx(0)
  , nErr(0)
  , nErl(0)
  , bReschedule(true)
  , bCompatibility(false)
  , pRun(nullptr)
  , nCallLvl(0)
  , nBreakCallLvl(0)
319{
320}

322SbiInstance::~SbiInstance()
323{
  while( pRun )
  {
      SbiRuntime* p = pRun->pNext;
      delete pRun;
      pRun = p;
  }

  try
  {
      int nSize = ComponentVector.size();
      if( nSize )
      {
          for( int i = nSize - 1 ; i >= 0 ; --i )
          {
              Reference< XComponent > xDlgComponent = ComponentVector[i];
              if( xDlgComponent.is() )
                  xDlgComponent->dispose();
          }
      }
  }
  catch( const Exception& )
  {
      TOOLS_WARN_EXCEPTION("basic", "SbiInstance::~SbiInstance: caught an exception while disposing the components" )do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "basic")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SbiInstance::~SbiInstance: caught an exception while disposing the components"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"basic"), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "346" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SbiInstance::~SbiInstance: caught an exception while disposing the components"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SbiInstance::~SbiInstance: caught an exception while disposing the components"
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("basic"
), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "346" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SbiInstance::~SbiInstance: caught an exception while disposing the components"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"basic"), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "346" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SbiInstance::~SbiInstance: caught an exception while disposing the components"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SbiInstance::~SbiInstance: caught an exception while disposing the components"
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("basic"
), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "346" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
348}

350SbiDllMgr* SbiInstance::GetDllMgr()
351{
  if( !pDllMgr )
  {
      pDllMgr.reset(new SbiDllMgr);
  }
  return pDllMgr.get();
357}

359// #39629 create NumberFormatter with the help of a static method now
360std::shared_ptr<SvNumberFormatter> const & SbiInstance::GetNumberFormatter()
361{
  LanguageType eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
  SvtSysLocale aSysLocale;
  DateOrder eDate = aSysLocale.GetLocaleData().getDateOrder();
  if( pNumberFormatter )
  {
      if( eLangType != meFormatterLangType ||
          eDate != meFormatterDateOrder )
      {
          pNumberFormatter.reset();
      }
  }
  meFormatterLangType = eLangType;
  meFormatterDateOrder = eDate;
  if( !pNumberFormatter )
  {
      pNumberFormatter = PrepareNumberFormatter( nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx,
              &meFormatterLangType, &meFormatterDateOrder);
  }
  return pNumberFormatter;
381}

383// #39629 offer NumberFormatter static too
384std::shared_ptr<SvNumberFormatter> SbiInstance::PrepareNumberFormatter( sal_uInt32 &rnStdDateIdx,
  sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx,
  LanguageType const * peFormatterLangType, DateOrder const * peFormatterDateOrder )
387{
  LanguageType eLangType;
  if( peFormatterLangType )
  {
      eLangType = *peFormatterLangType;
  }
  else
  {
      eLangType = Application::GetSettings().GetLanguageTag().getLanguageType();
  }
  DateOrder eDate;
  if( peFormatterDateOrder )
  {
      eDate = *peFormatterDateOrder;
  }
  else
  {
      SvtSysLocale aSysLocale;
      eDate = aSysLocale.GetLocaleData().getDateOrder();
  }

  std::shared_ptr<SvNumberFormatter> pNumberFormatter =
          std::make_shared<SvNumberFormatter>( comphelper::getProcessComponentContext(), eLangType );

  // Several parser methods pass SvNumberFormatter::IsNumberFormat() a number
  // format index to parse against. Tell the formatter the proper date
  // evaluation order, which also determines the date acceptance patterns to
  // use if a format was passed. NF_EVALDATEFORMAT_FORMAT restricts to the
  // format's locale's date patterns/order (no init/system locale match
  // tried) and falls back to NF_EVALDATEFORMAT_INTL if no specific (i.e. 0)
  // (or an unknown) format index was passed.
  pNumberFormatter->SetEvalDateFormat( NF_EVALDATEFORMAT_FORMAT);

  sal_Int32 nCheckPos = 0;
  SvNumFormatType nType;
  rnStdTimeIdx = pNumberFormatter->GetStandardFormat( SvNumFormatType::TIME, eLangType );

  // the formatter's standard templates have only got a two-digit date
  // -> registering an own format

  // HACK, because the numberformatter doesn't swap the place holders
  // for month, day and year according to the system setting.
  // Problem: Print Year(Date) under engl. BS
  // also have a look at: basic/source/sbx/sbxdate.cxx

  OUString aDateStr;
  switch( eDate )
  {
      default:
      case DateOrder::MDY: aDateStr = "MM/DD/YYYY"; break;
      case DateOrder::DMY: aDateStr = "DD/MM/YYYY"; break;
      case DateOrder::YMD: aDateStr = "YYYY/MM/DD"; break;
  }
  OUString aStr( aDateStr );      // PutandConvertEntry() modifies string!
  pNumberFormatter->PutandConvertEntry( aStr, nCheckPos, nType,
      rnStdDateIdx, LANGUAGE_ENGLISH_USLanguageType(0x0409), eLangType, true);
  nCheckPos = 0;
  aDateStr += " HH:MM:SS";
  aStr = aDateStr;
  pNumberFormatter->PutandConvertEntry( aStr, nCheckPos, nType,
      rnStdDateTimeIdx, LANGUAGE_ENGLISH_USLanguageType(0x0409), eLangType, true);
  return pNumberFormatter;
449}


452// Let engine run. If Flags == BasicDebugFlags::Continue, take Flags over

454void SbiInstance::Stop()
455{
  for( SbiRuntime* p = pRun; p; p = p->pNext )
  {
      p->Stop();
  }
460}

462// Allows Basic IDE to set watch mode to suppress errors
463static bool bWatchMode = false;

465void setBasicWatchMode( bool bOn )
466{
  bWatchMode = bOn;
468}

470void SbiInstance::Error( ErrCode n )
471{
  Error( n, OUString() );
473}

475void SbiInstance::Error( ErrCode n, const OUString& rMsg )
476{
  if( !bWatchMode )
  {
      aErrorMsg = rMsg;
      pRun->Error( n );
  }
482}

484void SbiInstance::ErrorVB( sal_Int32 nVBNumber, const OUString& rMsg )
485{
  if( !bWatchMode )
  {
      ErrCode n = StarBASIC::GetSfxFromVBError( static_cast< sal_uInt16 >( nVBNumber ) );
      if ( !n )
      {
          n = ErrCode(nVBNumber); // force orig number, probably should have a specific table of vb ( localized ) errors
      }
      aErrorMsg = rMsg;
      SbiRuntime::translateErrorToVba( n, aErrorMsg );

      pRun->Error( ERRCODE_BASIC_COMPATErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 132 ), true/*bVBATranslationAlreadyDone*/ );
  }
498}

500void SbiInstance::setErrorVB( sal_Int32 nVBNumber )
501{
  ErrCode n = StarBASIC::GetSfxFromVBError( static_cast< sal_uInt16 >( nVBNumber ) );
  if( !n )
  {
      n = ErrCode(nVBNumber); // force orig number, probably should have a specific table of vb ( localized ) errors
  }
  aErrorMsg = OUString();
  SbiRuntime::translateErrorToVba( n, aErrorMsg );

  nErr = n;
511}


514void SbiInstance::FatalError( ErrCode n )
515{
  pRun->FatalError( n );
517}

519void SbiInstance::FatalError( ErrCode _errCode, const OUString& _details )
520{
  pRun->FatalError( _errCode, _details );
522}

524void SbiInstance::Abort()
525{
  StarBASIC* pErrBasic = GetCurrentBasic( pBasic );
  pErrBasic->RTError( nErr, aErrorMsg, pRun->nLine, pRun->nCol1, pRun->nCol2 );
  StarBASIC::Stop();
529}

531// can be unequal to pRTBasic
532StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic )
533{
  StarBASIC* pCurBasic = pRTBasic;
  SbModule* pActiveModule = StarBASIC::GetActiveModule();
  if( pActiveModule )
  {
      SbxObject* pParent = pActiveModule->GetParent();
      if (StarBASIC *pBasic = dynamic_cast<StarBASIC*>(pParent))
          pCurBasic = pBasic;
  }
  return pCurBasic;
543}

545SbModule* SbiInstance::GetActiveModule()
546{
  if( pRun )
  {
      return pRun->GetModule();
  }
  else
  {
      return nullptr;
  }
555}

557SbMethod* SbiInstance::GetCaller( sal_uInt16 nLevel )
558{
  SbiRuntime* p = pRun;
  while( nLevel-- && p )
  {
      p = p->pNext;
  }
  return p ? p->GetCaller() : nullptr;
565}

567//                              SbiInstance

569// Attention: pMeth can also be NULL (on a call of the init-code)

571SbiRuntime::SbiRuntime( SbModule* pm, SbMethod* pe, sal_uInt32 nStart )
       : rBasic( *static_cast<StarBASIC*>(pm->pParent) ), pInst( GetSbData()->pInst ),
         pMod( pm ), pMeth( pe ), pImg( pMod->pImage ), mpExtCaller(nullptr), m_nLastTime(0)
574{
  nFlags    = pe ? pe->GetDebugFlags() : BasicDebugFlags::NONE;
1
Assuming 'pe' is non-null→
2
←
'?' condition is true→
  pIosys    = pInst->GetIoSystem();
  pForStk   = nullptr;
  pError    = nullptr;
  pErrCode  =
  pErrStmnt =
  pRestart  = nullptr;
  pNext     = nullptr;
  pCode     =
  pStmnt    = reinterpret_cast<const sal_uInt8*>(pImg->GetCode()) + nStart;
  bRun      =
  bError    = true;
  bInError  = false;
  bBlocked  = false;
  nLine     = 0;
  nCol1     = 0;
  nCol2     = 0;
  nExprLvl  = 0;
  nArgc     = 0;
  nError    = ERRCODE_NONEErrCode(0);
  nForLvl   = 0;
  nOps      = 0;
  refExprStk = new SbxArray;
  SetVBAEnabled( pMod->IsVBACompat() );
  SetParameters( pe2.1
'pe' is non-null
 ? pe->GetParameters() : nullptr );
3
←
'?' condition is true→
4
←
Calling 'SbiRuntime::SetParameters'→
600}

602SbiRuntime::~SbiRuntime()
603{
  ClearArgvStack();
  ClearForStack();
606}

608void SbiRuntime::SetVBAEnabled(bool bEnabled )
609{
  bVBAEnabled = bEnabled;
  if ( bVBAEnabled )
  {
      if ( pMeth )
      {
          mpExtCaller = pMeth->mCaller;
      }
  }
  else
  {
      mpExtCaller = nullptr;
  }
622}

624// tdf#79426, tdf#125180 - adds the information about a missing parameter
625void SbiRuntime::SetIsMissing( SbxVariable* pVar )
626{
  SbxInfo* pInfo = pVar->GetInfo() ? pVar->GetInfo() : new SbxInfo();
  pInfo->AddParam( pVar->GetName(), SbxMISSING, pVar->GetFlags() );
  pVar->SetInfo( pInfo );
630}

632// tdf#79426, tdf#125180 - checks if a variable contains the information about a missing parameter
633bool SbiRuntime::IsMissing( SbxVariable* pVar, sal_uInt16 nIdx )
634{
  return pVar->GetInfo() && pVar->GetInfo()->GetParam( nIdx ) && pVar->GetInfo()->GetParam( nIdx )->eType & SbxMISSING;
636}

638// Construction of the parameter list. All ByRef-parameters are directly
639// taken over; copies of ByVal-parameters are created. If a particular
640// data type is requested, it is converted.

642void SbiRuntime::SetParameters( SbxArray* pParams )
643{
  refParams = new SbxArray;
  // for the return value
  refParams->Put32( pMeth, 0 );

  SbxInfo* pInfo = pMeth4.1
Field 'pMeth' is null
 ? pMeth->GetInfo() : nullptr;
5
←
'?' condition is false→
  sal_uInt32 nParamCount = pParams ? pParams->Count32() : 1;
6
←
Assuming 'pParams' is non-null→
7
←
'?' condition is true→
  assert(nParamCount <= std::numeric_limits<sal_uInt16>::max())(static_cast <bool> (nParamCount <= std::numeric_limits
<sal_uInt16>::max()) ? void (0) : __assert_fail ("nParamCount <= std::numeric_limits<sal_uInt16>::max()"
, "/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
, 650, __extension__ __PRETTY_FUNCTION__));
8
←
Assuming the condition is true→
9
←
'?' condition is true→
  if( nParamCount > 1 )
10
←
Assuming 'nParamCount' is > 1→
11
←
Taking true branch→
  {
      for( sal_uInt32 i = 1 ; i11.1
'i' is < 'nParamCount'
 < nParamCount ; i++ )
12
←
Loop condition is true.  Entering loop body→
      {
          const SbxParamInfo* p = pInfo12.1
'pInfo' is null
 ? pInfo->GetParam( sal::static_int_cast<sal_uInt16>(i) ) : nullptr;
13
←
'?' condition is false→

          // #111897 ParamArray
          if( p13.1
'p' is null
 && (p->nUserData & PARAM_INFO_PARAMARRAY0x0010000) != 0 )
          {
              SbxDimArray* pArray = new SbxDimArray( SbxVARIANT );
              sal_uInt32 nParamArrayParamCount = nParamCount - i;
              pArray->unoAddDim32( 0, nParamArrayParamCount - 1 );
              for (sal_uInt32 j = i; j < nParamCount ; ++j)
              {
                  SbxVariable* v = pParams->Get32( j );
                  sal_Int32 aDimIndex[1];
                  aDimIndex[0] = j - i;
                  pArray->Put32(v, aDimIndex);
              }
              SbxVariable* pArrayVar = new SbxVariable( SbxVARIANT );
              pArrayVar->SetFlag( SbxFlagBits::ReadWrite );
              pArrayVar->PutObject( pArray );
              refParams->Put32( pArrayVar, i );

              // Block ParamArray for missing parameter
              pInfo = nullptr;
              break;
          }

          SbxVariable* v = pParams->Get32( i );
14
←
'v' initialized here→
          // methods are always byval!
          bool bByVal = dynamic_cast<const SbxMethod *>(v) != nullptr;
15
←
Assuming pointer value is null→
          SbxDataType t = v->GetType();
16
←
Called C++ object pointer is null
          bool bTargetTypeIsArray = false;
          if( p )
          {
              bByVal |= ( p->eType & SbxBYREF ) == 0;
              // tdf#79426, tdf#125180 - don't convert missing arguments to the requested parameter type
              if ( !IsMissing( v, 1 ) )
              {
                  t = static_cast<SbxDataType>( p->eType & 0x0FFF );
              }

              if( !bByVal && t != SbxVARIANT &&
                  (!v->IsFixed() || static_cast<SbxDataType>(v->GetType() & 0x0FFF ) != t) )
              {
                  bByVal = true;
              }

              bTargetTypeIsArray = (p->nUserData & PARAM_INFO_WITHBRACKETS0x0020000) != 0;
          }
          if( bByVal )
          {
              // tdf#79426, tdf#125180 - don't convert missing arguments to the requested parameter type
              if( bTargetTypeIsArray && !IsMissing( v, 1 ) )
              {
                  t = SbxOBJECT;
              }
              SbxVariable* v2 = new SbxVariable( t );
              v2->SetFlag( SbxFlagBits::ReadWrite );
              // tdf#79426, tdf#125180 - if parameter was missing, readd additional information about a missing parameter
              if ( IsMissing( v, 1 ) )
              {
                  SetIsMissing( v2 );
              }
              *v2 = *v;
              refParams->Put32( v2, i );
          }
          else
          {
              // tdf#79426, tdf#125180 - don't convert missing arguments to the requested parameter type
              if( t != SbxVARIANT && !IsMissing( v, 1 ) && t != ( v->GetType() & 0x0FFF ) )
              {
                  if( p && (p->eType & SbxARRAY) )
                  {
                      Error( ERRCODE_BASIC_CONVERSIONErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 6) );
                  }
                  else
                  {
                      v->Convert( t );
                  }
              }
              refParams->Put32( v, i );
          }
          if( p )
          {
              refParams->PutAlias32( p->aName, i );
          }
      }
  }

  // ParamArray for missing parameter
  if( !pInfo )
      return;

  // #111897 Check first missing parameter for ParamArray
  const SbxParamInfo* p = pInfo->GetParam(sal::static_int_cast<sal_uInt16>(nParamCount));
  if( p && (p->nUserData & PARAM_INFO_PARAMARRAY0x0010000) != 0 )
  {
      SbxDimArray* pArray = new SbxDimArray( SbxVARIANT );
      pArray->unoAddDim32( 0, -1 );
      SbxVariable* pArrayVar = new SbxVariable( SbxVARIANT );
      pArrayVar->SetFlag( SbxFlagBits::ReadWrite );
      pArrayVar->PutObject( pArray );
      refParams->Put32( pArrayVar, nParamCount );
  }
757}


760// execute a P-Code

762bool SbiRuntime::Step()
763{
  if( bRun )
  {
      // in any case check casually!
      if( !( ++nOps & 0xF ) && pInst->IsReschedule() )
      {
          sal_uInt32 nTime = osl_getGlobalTimer();
          if (nTime - m_nLastTime > 5 ) // 20 ms
          {
              Application::Reschedule();
              m_nLastTime = nTime;
          }
      }

      // #i48868 blocked by next call level?
      while( bBlocked )
      {
          if( pInst->IsReschedule() )
          {
              Application::Reschedule();
          }
      }

      SbiOpcode eOp = static_cast<SbiOpcode>( *pCode++ );
      sal_uInt32 nOp1;
      if (eOp <= SbiOpcode::SbOP0_END)
      {
          (this->*( aStep0[ int(eOp) ] ) )();
      }
      else if (eOp >= SbiOpcode::SbOP1_START && eOp <= SbiOpcode::SbOP1_END)
      {
          nOp1 = *pCode++; nOp1 |= *pCode++ << 8; nOp1 |= *pCode++ << 16; nOp1 |= *pCode++ << 24;

          (this->*( aStep1[ int(eOp) - int(SbiOpcode::SbOP1_START) ] ) )( nOp1 );
      }
      else if (eOp >= SbiOpcode::SbOP2_START && eOp <= SbiOpcode::SbOP2_END)
      {
          nOp1 = *pCode++; nOp1 |= *pCode++ << 8; nOp1 |= *pCode++ << 16; nOp1 |= *pCode++ << 24;
          sal_uInt32 nOp2 = *pCode++; nOp2 |= *pCode++ << 8; nOp2 |= *pCode++ << 16; nOp2 |= *pCode++ << 24;
          (this->*( aStep2[ int(eOp) - int(SbiOpcode::SbOP2_START) ] ) )( nOp1, nOp2 );
      }
      else
      {
          StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
      }

      ErrCode nErrCode = SbxBase::GetError();
      Error( nErrCode.IgnoreWarning() );

      // from 13.2.1997, new error handling:
      // ATTENTION: nError can be set already even if !nErrCode
      // since nError can now also be set from other RT-instances

      if( nError )
      {
          SbxBase::ResetError();
      }

      // from 15.3.96: display errors only if BASIC is still active
      // (especially not after compiler errors at the runtime)
      if( nError && bRun )
      {
          ErrCode err = nError;
          ClearExprStack();
          nError = ERRCODE_NONEErrCode(0);
          pInst->nErr = err;
          pInst->nErl = nLine;
          pErrCode    = pCode;
          pErrStmnt   = pStmnt;
          // An error occurred in an error handler
          // force parent handler ( if there is one )
          // to handle the error
          bool bLetParentHandleThis = false;

          // in the error handler? so std-error
          if ( !bInError )
          {
              bInError = true;

              if( !bError )           // On Error Resume Next
              {
                  StepRESUME( 1 );
              }
              else if( pError )       // On Error Goto ...
              {
                  pCode = pError;
              }
              else
              {
                  bLetParentHandleThis = true;
              }
          }
          else
          {
              bLetParentHandleThis = true;
              pError = nullptr; //terminate the handler
          }
          if ( bLetParentHandleThis )
          {
              // from 13.2.1997, new error handling:
              // consider superior error handlers

              // there's no error handler -> find one farther above
              SbiRuntime* pRtErrHdl = nullptr;
              SbiRuntime* pRt = this;
              while( (pRt = pRt->pNext) != nullptr )
              {
                  if( !pRt->bError || pRt->pError != nullptr )
                  {
                      pRtErrHdl = pRt;
                      break;
                  }
              }


              if( pRtErrHdl )
              {
                  // manipulate all the RTs that are below in the call-stack
                  pRt = this;
                  do
                  {
                      pRt->nError = err;
                      if( pRt != pRtErrHdl )
                      {
                          pRt->bRun = false;
                      }
                      else
                      {
                          break;
                      }
                      pRt = pRt->pNext;
                  }
                  while( pRt );
              }
              // no error-hdl found -> old behaviour
              else
              {
                  pInst->Abort();
              }
          }
      }
  }
  return bRun;
906}

908void SbiRuntime::Error( ErrCode n, bool bVBATranslationAlreadyDone )
909{
  if( !n )
      return;

  nError = n;
  if( !isVBAEnabled() || bVBATranslationAlreadyDone )
      return;

  OUString aMsg = pInst->GetErrorMsg();
  sal_Int32 nVBAErrorNumber = translateErrorToVba( nError, aMsg );
  SbxVariable* pSbxErrObjVar = SbxErrObject::getErrObject().get();
  SbxErrObject* pGlobErr = static_cast< SbxErrObject* >( pSbxErrObjVar );
  if( pGlobErr != nullptr )
  {
      pGlobErr->setNumberAndDescription( nVBAErrorNumber, aMsg );
  }
  pInst->aErrorMsg = aMsg;
  nError = ERRCODE_BASIC_COMPATErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 132 );
927}

929void SbiRuntime::Error( ErrCode _errCode, const OUString& _details )
930{
  if ( !_errCode )
      return;

  // Not correct for class module usage, remove for now
  //OSL_WARN_IF( pInst->pRun != this, "basic", "SbiRuntime::Error: can't propagate the error message details!" );
  if ( pInst->pRun == this )
  {
      pInst->Error( _errCode, _details );
      //OSL_WARN_IF( nError != _errCode, "basic", "SbiRuntime::Error: the instance is expected to propagate the error code back to me!" );
  }
  else
  {
      nError = _errCode;
  }
945}

947void SbiRuntime::FatalError( ErrCode n )
948{
  StepSTDERROR();
  Error( n );
951}

953void SbiRuntime::FatalError( ErrCode _errCode, const OUString& _details )
954{
  StepSTDERROR();
  Error( _errCode, _details );
957}

959sal_Int32 SbiRuntime::translateErrorToVba( ErrCode nError, OUString& rMsg )
960{
  // If a message is defined use that ( in preference to
  // the defined one for the error ) NB #TODO
  // if there is an error defined it more than likely
  // is not the one you want ( some are the same though )
  // we really need a new vba compatible error list
  if ( rMsg.isEmpty() )
  {
      StarBASIC::MakeErrorText( nError, rMsg );
      rMsg = StarBASIC::GetErrorText();
      if ( rMsg.isEmpty() ) // no message for err no, need localized resource here
      {
          rMsg = "Internal Object Error:";
      }
  }
  // no num? most likely then it *is* really a vba err
  sal_uInt16 nVBErrorCode = StarBASIC::GetVBErrorCode( nError );
  sal_Int32 nVBAErrorNumber = ( nVBErrorCode == 0 ) ? sal_uInt32(nError) : nVBErrorCode;
  return nVBAErrorNumber;
979}

981//  Stacks

983// The expression-stack is available for the continuous evaluation
984// of expressions.

986void SbiRuntime::PushVar( SbxVariable* pVar )
987{
  if( pVar )
  {
      refExprStk->Put32( pVar, nExprLvl++ );
  }
992}

994SbxVariableRef SbiRuntime::PopVar()
995{
996#ifdef DBG_UTIL
  if( !nExprLvl )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
      return new SbxVariable;
  }
1002#endif
  SbxVariableRef xVar = refExprStk->Get32( --nExprLvl );
  SAL_INFO_IF( xVar->GetName() == "Cells", "basic", "PopVar: Name equals 'Cells'" )do { if (true && (xVar->GetName() == "Cells")) { switch
 (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO, "basic")
) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "PopVar: Name equals 'Cells'") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("basic"), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "1004" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "PopVar: Name equals 'Cells'"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "PopVar: Name equals 'Cells'"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("basic"), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "1004" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "PopVar: Name equals 'Cells'") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("basic"), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "1004" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "PopVar: Name equals 'Cells'"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "PopVar: Name equals 'Cells'"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("basic"), ("/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
 ":" "1004" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  // methods hold themselves in parameter 0
  if( dynamic_cast<const SbxMethod *>(xVar.get()) != nullptr )
  {
      xVar->SetParameters(nullptr);
  }
  return xVar;
1011}

1013void SbiRuntime::ClearExprStack()
1014{
  // Attention: Clear() doesn't suffice as methods must be deleted
  while ( nExprLvl )
  {
      PopVar();
  }
  refExprStk->Clear();
1021}

1023// Take variable from the expression-stack without removing it
1024// n counts from 0

1026SbxVariable* SbiRuntime::GetTOS()
1027{
  short n = nExprLvl - 1;
1029#ifdef DBG_UTIL
  if( n < 0 )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
      return new SbxVariable;
  }
1035#endif
  return refExprStk->Get32( static_cast<sal_uInt32>(n) );
1037}


1040void SbiRuntime::TOSMakeTemp()
1041{
  SbxVariable* p = refExprStk->Get32( nExprLvl - 1 );
  if ( p->GetType() == SbxEMPTY )
  {
      p->Broadcast( SfxHintId::BasicDataWanted );
  }

  SbxVariable* pDflt = nullptr;
  if ( bVBAEnabled &&  ( p->GetType() == SbxOBJECT || p->GetType() == SbxVARIANT  ) && ((pDflt = getDefaultProp(p)) != nullptr) )
  {
      pDflt->Broadcast( SfxHintId::BasicDataWanted );
      // replacing new p on stack causes object pointed by
      // pDft->pParent to be deleted, when p2->Compute() is
      // called below pParent is accessed (but it's deleted)
      // so set it to NULL now
      pDflt->SetParent( nullptr );
      p = new SbxVariable( *pDflt );
      p->SetFlag( SbxFlagBits::ReadWrite );
      refExprStk->Put32( p, nExprLvl - 1 );
  }
  else if( p->GetRefCount() != 1 )
  {
      SbxVariable* pNew = new SbxVariable( *p );
      pNew->SetFlag( SbxFlagBits::ReadWrite );
      refExprStk->Put32( pNew, nExprLvl - 1 );
  }
1067}

1069// the GOSUB-stack collects return-addresses for GOSUBs
1070void SbiRuntime::PushGosub( const sal_uInt8* pc )
1071{
  if( pGosubStk.size() >= MAXRECURSION500 )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_STACK_OVERFLOWErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 38 ) );
  }
  pGosubStk.emplace_back(pc, nForLvl);
1077}

1079void SbiRuntime::PopGosub()
1080{
  if( pGosubStk.empty() )
  {
      Error( ERRCODE_BASIC_NO_GOSUBErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 30 ) );
  }
  else
  {
      pCode = pGosubStk.back().pCode;
      pGosubStk.pop_back();
  }
1090}

1092// the Argv-stack collects current argument-vectors

1094void SbiRuntime::PushArgv()
1095{
  pArgvStk.emplace_back(refArgv, nArgc);
  nArgc = 1;
  refArgv.clear();
1099}

1101void SbiRuntime::PopArgv()
1102{
  if( !pArgvStk.empty() )
  {
      refArgv = pArgvStk.back().refArgv;
      nArgc = pArgvStk.back().nArgc;
      pArgvStk.pop_back();
  }
1109}


1112void SbiRuntime::ClearArgvStack()
1113{
  while( !pArgvStk.empty() )
  {
      PopArgv();
  }
1118}

1120// Push of the for-stack. The stack has increment, end, begin and variable.
1121// After the creation of the stack-element the stack's empty.

1123void SbiRuntime::PushFor()
1124{
  SbiForStack* p = new SbiForStack;
  p->eForType = ForType::To;
  p->pNext = pForStk;
  pForStk = p;

  p->refInc = PopVar();
  p->refEnd = PopVar();
  SbxVariableRef xBgn = PopVar();
  p->refVar = PopVar();
  *(p->refVar) = *xBgn;
  nForLvl++;
1136}

1138void SbiRuntime::PushForEach()
1139{
  SbiForStack* p = new SbiForStack;
  // Set default value in case of error which is ignored in Resume Next
  p->eForType = ForType::EachArray;
  p->pNext = pForStk;
  pForStk = p;

  SbxVariableRef xObjVar = PopVar();
  SbxBase* pObj = xObjVar && xObjVar->GetFullType() == SbxOBJECT ? xObjVar->GetObject() : nullptr;

  if (SbxDimArray* pArray = dynamic_cast<SbxDimArray*>(pObj))
  {
      p->refEnd = reinterpret_cast<SbxVariable*>(pArray);

      sal_Int32 nDims = pArray->GetDims32();
      p->pArrayLowerBounds.reset( new sal_Int32[nDims] );
      p->pArrayUpperBounds.reset( new sal_Int32[nDims] );
      p->pArrayCurIndices.reset( new sal_Int32[nDims] );
      sal_Int32 lBound, uBound;
      for( sal_Int32 i = 0 ; i < nDims ; i++ )
      {
          pArray->GetDim32( i+1, lBound, uBound );
          p->pArrayCurIndices[i] = p->pArrayLowerBounds[i] = lBound;
          p->pArrayUpperBounds[i] = uBound;
      }
  }
  else if (BasicCollection* pCollection = dynamic_cast<BasicCollection*>(pObj))
  {
      p->eForType = ForType::EachCollection;
      p->refEnd = pCollection;
      p->nCurCollectionIndex = 0;
  }
  else if (SbUnoObject* pUnoObj = dynamic_cast<SbUnoObject*>(pObj))
  {
      // XEnumerationAccess?
      Any aAny = pUnoObj->getUnoAny();
      Reference< XEnumerationAccess > xEnumerationAccess;
      if( aAny >>= xEnumerationAccess )
      {
          p->xEnumeration = xEnumerationAccess->createEnumeration();
          p->eForType = ForType::EachXEnumeration;
      }
      else if ( isVBAEnabled() && pUnoObj->isNativeCOMObject() )
      {
          uno::Reference< script::XInvocation > xInvocation;
          if ( ( aAny >>= xInvocation ) && xInvocation.is() )
          {
              try
              {
                  p->xEnumeration = new ComEnumerationWrapper( xInvocation );
                  p->eForType = ForType::EachXEnumeration;
              }
              catch(const uno::Exception& )
              {}
          }
      }
  }

  // Container variable
  p->refVar = PopVar();
  nForLvl++;
1200}


1203void SbiRuntime::PopFor()
1204{
  if( pForStk )
  {
      SbiForStack* p = pForStk;
      pForStk = p->pNext;
      delete p;
      nForLvl--;
  }
1212}


1215void SbiRuntime::ClearForStack()
1216{
  while( pForStk )
  {
      PopFor();
  }
1221}

1223SbiForStack* SbiRuntime::FindForStackItemForCollection( class BasicCollection const * pCollection )
1224{
  for (SbiForStack *p = pForStk; p; p = p->pNext)
  {
      SbxVariable* pVar = p->refEnd.is() ? p->refEnd.get() : nullptr;
      if( p->eForType == ForType::EachCollection
       && pVar != nullptr
       && dynamic_cast<BasicCollection*>( pVar) == pCollection  )
      {
          return p;
      }
  }

  return nullptr;
1237}


1240//  DLL-calls

1242void SbiRuntime::DllCall
  ( const OUString& aFuncName,
    const OUString& aDLLName,
    SbxArray* pArgs,          // parameter (from index 1, can be NULL)
    SbxDataType eResType,     // return value
    bool bCDecl )         // true: according to C-conventions
1248{
  // NOT YET IMPLEMENTED

  SbxVariable* pRes = new SbxVariable( eResType );
  SbiDllMgr* pDllMgr = pInst->GetDllMgr();
  ErrCode nErr = pDllMgr->Call( aFuncName, aDLLName, pArgs, *pRes, bCDecl );
  if( nErr )
  {
      Error( nErr );
  }
  PushVar( pRes );
1259}

1261bool SbiRuntime::IsImageFlag( SbiImageFlags n ) const
1262{
  return pImg->IsFlag( n );
1264}

1266sal_uInt16 SbiRuntime::GetBase() const
1267{
  return pImg->GetBase();
1269}

1271void SbiRuntime::StepNOP()
1272{}

1274void SbiRuntime::StepArith( SbxOperator eOp )
1275{
  SbxVariableRef p1 = PopVar();
  TOSMakeTemp();
  SbxVariable* p2 = GetTOS();

  p2->ResetFlag( SbxFlagBits::Fixed );
  p2->Compute( eOp, *p1 );

  checkArithmeticOverflow( p2 );
1284}

1286void SbiRuntime::StepUnary( SbxOperator eOp )
1287{
  TOSMakeTemp();
  SbxVariable* p = GetTOS();
  p->Compute( eOp, *p );
1291}

1293void SbiRuntime::StepCompare( SbxOperator eOp )
1294{
  SbxVariableRef p1 = PopVar();
  SbxVariableRef p2 = PopVar();

  // Make sure objects with default params have
  // values ( and type ) set as appropriate
  SbxDataType p1Type = p1->GetType();
  SbxDataType p2Type = p2->GetType();
  if ( p1Type == SbxEMPTY )
  {
      p1->Broadcast( SfxHintId::BasicDataWanted );
      p1Type = p1->GetType();
  }
  if ( p2Type == SbxEMPTY )
  {
      p2->Broadcast( SfxHintId::BasicDataWanted );
      p2Type = p2->GetType();
  }
  if ( p1Type == p2Type )
  {
      // if both sides are an object and have default props
      // then we need to use the default props
      // we don't need to worry if only one side ( lhs, rhs ) is an
      // object ( object side will get coerced to correct type in
      // Compare )
      if ( p1Type ==  SbxOBJECT )
      {
          SbxVariable* pDflt = getDefaultProp( p1.get() );
          if ( pDflt )
          {
              p1 = pDflt;
              p1->Broadcast( SfxHintId::BasicDataWanted );
          }
          pDflt = getDefaultProp( p2.get() );
          if ( pDflt )
          {
              p2 = pDflt;
              p2->Broadcast( SfxHintId::BasicDataWanted );
          }
      }

  }
  static SbxVariable* pTRUE = nullptr;
  static SbxVariable* pFALSE = nullptr;
  // why do this on non-windows ?
  // why do this at all ?
  // I dumbly follow the pattern :-/
  if ( bVBAEnabled && ( p1->IsNull() || p2->IsNull() ) )
  {
      static SbxVariable* pNULL = [&]() {
          SbxVariable* p = new SbxVariable;
          p->PutNull();
          p->AddFirstRef();
          return p;
      }();
      PushVar( pNULL );
  }
  else if( p2->Compare( eOp, *p1 ) )
  {
      if( !pTRUE )
      {
          pTRUE = new SbxVariable;
          pTRUE->PutBool( true );
          pTRUE->AddFirstRef();
      }
      PushVar( pTRUE );
  }
  else
  {
      if( !pFALSE )
      {
          pFALSE = new SbxVariable;
          pFALSE->PutBool( false );
          pFALSE->AddFirstRef();
      }
      PushVar( pFALSE );
  }
1371}

1373void SbiRuntime::StepEXP()      { StepArith( SbxEXP );      }
1374void SbiRuntime::StepMUL()      { StepArith( SbxMUL );      }
1375void SbiRuntime::StepDIV()      { StepArith( SbxDIV );      }
1376void SbiRuntime::StepIDIV()     { StepArith( SbxIDIV );     }
1377void SbiRuntime::StepMOD()      { StepArith( SbxMOD );      }
1378void SbiRuntime::StepPLUS()     { StepArith( SbxPLUS );     }
1379void SbiRuntime::StepMINUS()        { StepArith( SbxMINUS );    }
1380void SbiRuntime::StepCAT()      { StepArith( SbxCAT );      }
1381void SbiRuntime::StepAND()      { StepArith( SbxAND );      }
1382void SbiRuntime::StepOR()       { StepArith( SbxOR );       }
1383void SbiRuntime::StepXOR()      { StepArith( SbxXOR );      }
1384void SbiRuntime::StepEQV()      { StepArith( SbxEQV );      }
1385void SbiRuntime::StepIMP()      { StepArith( SbxIMP );      }

1387void SbiRuntime::StepNEG()      { StepUnary( SbxNEG );      }
1388void SbiRuntime::StepNOT()      { StepUnary( SbxNOT );      }

1390void SbiRuntime::StepEQ()       { StepCompare( SbxEQ );     }
1391void SbiRuntime::StepNE()       { StepCompare( SbxNE );     }
1392void SbiRuntime::StepLT()       { StepCompare( SbxLT );     }
1393void SbiRuntime::StepGT()       { StepCompare( SbxGT );     }
1394void SbiRuntime::StepLE()       { StepCompare( SbxLE );     }
1395void SbiRuntime::StepGE()       { StepCompare( SbxGE );     }

1397namespace
1398{
  bool NeedEsc(sal_Unicode cCode)
  {
      if(!rtl::isAscii(cCode))
      {
          return false;
      }
      switch(cCode)
      {
      case '.':
      case '^':
      case '$':
      case '+':
      case '\\':
      case '|':
      case '{':
      case '}':
      case '(':
      case ')':
          return true;
      default:
          return false;
      }
  }

  OUString VBALikeToRegexp(const OUString &rIn)
  {
      OUStringBuffer sResult;
      const sal_Unicode *start = rIn.getStr();
      const sal_Unicode *end = start + rIn.getLength();

      int seenright = 0;

      sResult.append('^');

      while (start < end)
      {
          switch (*start)
          {
          case '?':
              sResult.append('.');
              start++;
              break;
          case '*':
              sResult.append(".*");
              start++;
              break;
          case '#':
              sResult.append("[0-9]");
              start++;
              break;
          case ']':
              sResult.append('\\');
              sResult.append(*start++);
              break;
          case '[':
              sResult.append(*start++);
              seenright = 0;
              while (start < end && !seenright)
              {
                  switch (*start)
                  {
                  case '[':
                  case '?':
                  case '*':
                      sResult.append('\\');
                      sResult.append(*start);
                      break;
                  case ']':
                      sResult.append(*start);
                      seenright = 1;
                      break;
                  case '!':
                      sResult.append('^');
                      break;
                  default:
                      if (NeedEsc(*start))
                      {
                          sResult.append('\\');
                      }
                      sResult.append(*start);
                      break;
                  }
                  start++;
              }
              break;
          default:
              if (NeedEsc(*start))
              {
                  sResult.append('\\');
              }
              sResult.append(*start++);
          }
      }

      sResult.append('$');

      return sResult.makeStringAndClear();
  }
1497}

1499void SbiRuntime::StepLIKE()
1500{
  SbxVariableRef refVar1 = PopVar();
  SbxVariableRef refVar2 = PopVar();

  OUString pattern = VBALikeToRegexp(refVar1->GetOUString());
  OUString value = refVar2->GetOUString();

  i18nutil::SearchOptions2 aSearchOpt;

  aSearchOpt.AlgorithmType2 = css::util::SearchAlgorithms2::REGEXP;

  aSearchOpt.Locale = Application::GetSettings().GetLanguageTag().getLocale();
  aSearchOpt.searchString = pattern;

  bool bTextMode(true);
  bool bCompatibility = ( GetSbData()->pInst && GetSbData()->pInst->IsCompatibility() );
  if( bCompatibility )
  {
      bTextMode = IsImageFlag( SbiImageFlags::COMPARETEXT );
  }
  if( bTextMode )
  {
      aSearchOpt.transliterateFlags |= TransliterationFlags::IGNORE_CASE;
  }
  SbxVariable* pRes = new SbxVariable;
  utl::TextSearch aSearch( aSearchOpt);
  sal_Int32 nStart=0, nEnd=value.getLength();
  bool bRes = aSearch.SearchForward(value, &nStart, &nEnd);
  pRes->PutBool( bRes );

  PushVar( pRes );
1531}

1533// TOS and TOS-1 are both object variables and contain the same pointer

1535void SbiRuntime::StepIS()
1536{
  SbxVariableRef refVar1 = PopVar();
  SbxVariableRef refVar2 = PopVar();

  SbxDataType eType1 = refVar1->GetType();
  SbxDataType eType2 = refVar2->GetType();
  if ( eType1 == SbxEMPTY )
  {
      refVar1->Broadcast( SfxHintId::BasicDataWanted );
      eType1 = refVar1->GetType();
  }
  if ( eType2 == SbxEMPTY )
  {
      refVar2->Broadcast( SfxHintId::BasicDataWanted );
      eType2 = refVar2->GetType();
  }

  bool bRes = ( eType1 == SbxOBJECT && eType2 == SbxOBJECT );
  if ( bVBAEnabled  && !bRes )
  {
      Error( ERRCODE_BASIC_INVALID_USAGE_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) );
  }
  bRes = ( bRes && refVar1->GetObject() == refVar2->GetObject() );
  SbxVariable* pRes = new SbxVariable;
  pRes->PutBool( bRes );
  PushVar( pRes );
1562}

1564// update the value of TOS

1566void SbiRuntime::StepGET()
1567{
  SbxVariable* p = GetTOS();
  p->Broadcast( SfxHintId::BasicDataWanted );
1570}

1572// #67607 copy Uno-Structs
1573static bool checkUnoStructCopy( bool bVBA, SbxVariableRef const & refVal, SbxVariableRef const & refVar )
1574{
  SbxDataType eVarType = refVar->GetType();
  SbxDataType eValType = refVal->GetType();

  if ( ( bVBA && ( eVarType == SbxEMPTY ) ) || !refVar->CanWrite() )
      return false;

  if ( eValType != SbxOBJECT )
      return false;
  // we seem to be duplicating parts of SbxValue=operator, maybe we should just move this to
  // there :-/ not sure if for every '=' we would want struct handling
  if( eVarType != SbxOBJECT )
  {
      if ( refVar->IsFixed() )
          return false;
  }
  // #115826: Exclude ProcedureProperties to avoid call to Property Get procedure
  else if( dynamic_cast<const SbProcedureProperty*>( refVar.get() ) != nullptr )
      return false;

  SbxObjectRef xValObj = static_cast<SbxObject*>(refVal->GetObject());
  if( !xValObj.is() || dynamic_cast<const SbUnoAnyObject*>( xValObj.get() ) != nullptr )
      return false;

  SbUnoObject* pUnoVal =  dynamic_cast<SbUnoObject*>( xValObj.get() );
  SbUnoStructRefObject* pUnoStructVal = dynamic_cast<SbUnoStructRefObject*>( xValObj.get() );
  Any aAny;
  // make doubly sure value is either a Uno object or
  // a uno struct
  if ( pUnoVal || pUnoStructVal )
      aAny = pUnoVal ? pUnoVal->getUnoAny() : pUnoStructVal->getUnoAny();
  else
      return false;
  if (  aAny.getValueType().getTypeClass() == TypeClass_STRUCT )
  {
      refVar->SetType( SbxOBJECT );
      ErrCode eOldErr = SbxBase::GetError();
      // There are some circumstances when calling GetObject
      // will trigger an error, we need to squash those here.
      // Alternatively it is possible that the same scenario
      // could overwrite and existing error. Lets prevent that
      SbxObjectRef xVarObj = static_cast<SbxObject*>(refVar->GetObject());
      if ( eOldErr != ERRCODE_NONEErrCode(0) )
          SbxBase::SetError( eOldErr );
      else
          SbxBase::ResetError();

      SbUnoStructRefObject* pUnoStructObj = dynamic_cast<SbUnoStructRefObject*>( xVarObj.get() );

      OUString sClassName = pUnoVal ? pUnoVal->GetClassName() : pUnoStructVal->GetClassName();
      OUString sName = pUnoVal ? pUnoVal->GetName() : pUnoStructVal->GetName();

      if ( pUnoStructObj )
      {
          StructRefInfo aInfo = pUnoStructObj->getStructInfo();
          aInfo.setValue( aAny );
      }
      else
      {
          SbUnoObject* pNewUnoObj = new SbUnoObject( sName, aAny );
          // #70324: adopt ClassName
          pNewUnoObj->SetClassName( sClassName );
          refVar->PutObject( pNewUnoObj );
      }
      return true;
  }
  return false;
1641}


1644// laying down TOS in TOS-1

1646void SbiRuntime::StepPUT()
1647{
  SbxVariableRef refVal = PopVar();
  SbxVariableRef refVar = PopVar();
  // store on its own method (inside a function)?
  bool bFlagsChanged = false;
  SbxFlagBits n = SbxFlagBits::NONE;
  if( refVar.get() == pMeth )
  {
      bFlagsChanged = true;
      n = refVar->GetFlags();
      refVar->SetFlag( SbxFlagBits::Write );
  }

  // if left side arg is an object or variant and right handside isn't
  // either an object or a variant then try and see if a default
  // property exists.
  // to use e.g. Range{"A1") = 34
  // could equate to Range("A1").Value = 34
  if ( bVBAEnabled )
  {
      // yet more hacking at this, I feel we don't quite have the correct
      // heuristics for dealing with obj1 = obj2 ( where obj2 ( and maybe
      // obj1 ) has default member/property ) ) It seems that default props
      // aren't dealt with if the object is a member of some parent object
      bool bObjAssign = false;
      if ( refVar->GetType() == SbxEMPTY )
          refVar->Broadcast( SfxHintId::BasicDataWanted );
      if ( refVar->GetType() == SbxOBJECT )
      {
          if  ( dynamic_cast<const SbxMethod *>(refVar.get()) != nullptr || ! refVar->GetParent() )
          {
              SbxVariable* pDflt = getDefaultProp( refVar.get() );

              if ( pDflt )
                  refVar = pDflt;
          }
          else
              bObjAssign = true;
      }
      if (  refVal->GetType() == SbxOBJECT  && !bObjAssign && ( dynamic_cast<const SbxMethod *>(refVal.get()) != nullptr || ! refVal->GetParent() ) )
      {
          SbxVariable* pDflt = getDefaultProp( refVal.get() );
          if ( pDflt )
              refVal = pDflt;
      }
  }

  if ( !checkUnoStructCopy( bVBAEnabled, refVal, refVar ) )
      *refVar = *refVal;

  if( bFlagsChanged )
      refVar->SetFlags( n );
1699}

1701namespace {

1703// VBA Dim As New behavior handling, save init object information
1704struct DimAsNewRecoverItem
1705{
  OUString        m_aObjClass;
  OUString        m_aObjName;
  SbxObject*      m_pObjParent;
  SbModule*       m_pClassModule;

  DimAsNewRecoverItem()
      : m_pObjParent( nullptr )
      , m_pClassModule( nullptr )
  {}

  DimAsNewRecoverItem( const OUString& rObjClass, const OUString& rObjName,
                       SbxObject* pObjParent, SbModule* pClassModule )
          : m_aObjClass( rObjClass )
          , m_aObjName( rObjName )
          , m_pObjParent( pObjParent )
          , m_pClassModule( pClassModule )
  {}

1724};


1727struct SbxVariablePtrHash
1728{
  size_t operator()( SbxVariable* pVar ) const
      { return reinterpret_cast<size_t>(pVar); }
1731};

1733}

1735typedef std::unordered_map< SbxVariable*, DimAsNewRecoverItem,
                            SbxVariablePtrHash >  DimAsNewRecoverHash;

1738namespace {

1740class GaDimAsNewRecoverHash : public rtl::Static<DimAsNewRecoverHash, GaDimAsNewRecoverHash> {};

1742}

1744void removeDimAsNewRecoverItem( SbxVariable* pVar )
1745{
  DimAsNewRecoverHash &rDimAsNewRecoverHash = GaDimAsNewRecoverHash::get();
  DimAsNewRecoverHash::iterator it = rDimAsNewRecoverHash.find( pVar );
  if( it != rDimAsNewRecoverHash.end() )
  {
      rDimAsNewRecoverHash.erase( it );
  }
1752}


1755// saving object variable
1756// not-object variables will cause errors

1758const char pCollectionStr[] = "Collection";

1760void SbiRuntime::StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, bool bHandleDefaultProp )
1761{
  // #67733 types with array-flag are OK too

  // Check var, !object is no error for sure if, only if type is fixed
  SbxDataType eVarType = refVar->GetType();
  if( !bHandleDefaultProp && eVarType != SbxOBJECT && !(eVarType & SbxARRAY) && refVar->IsFixed() )
  {
      Error( ERRCODE_BASIC_INVALID_USAGE_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) );
      return;
  }

  // Check value, !object is no error for sure if, only if type is fixed
  SbxDataType eValType = refVal->GetType();
  if( !bHandleDefaultProp && eValType != SbxOBJECT && !(eValType & SbxARRAY) && refVal->IsFixed() )
  {
      Error( ERRCODE_BASIC_INVALID_USAGE_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) );
      return;
  }

  // Getting in here causes problems with objects with default properties
  // if they are SbxEMPTY I guess
  if ( !bHandleDefaultProp || eValType == SbxOBJECT )
  {
  // activate GetObject for collections on refVal
      SbxBase* pObjVarObj = refVal->GetObject();
      if( pObjVarObj )
      {
          SbxVariableRef refObjVal = dynamic_cast<SbxObject*>( pObjVarObj );

          if( refObjVal.is() )
          {
              refVal = refObjVal;
          }
          else if( !(eValType & SbxARRAY) )
          {
              refVal = nullptr;
          }
      }
  }

  // #52896 refVal can be invalid here, if uno-sequences - or more
  // general arrays - are assigned to variables that are declared
  // as an object!
  if( !refVal.is() )
  {
      Error( ERRCODE_BASIC_INVALID_USAGE_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) );
  }
  else
  {
      bool bFlagsChanged = false;
      SbxFlagBits n = SbxFlagBits::NONE;
      if( refVar.get() == pMeth )
      {
          bFlagsChanged = true;
          n = refVar->GetFlags();
          refVar->SetFlag( SbxFlagBits::Write );
      }
      SbProcedureProperty* pProcProperty = dynamic_cast<SbProcedureProperty*>( refVar.get() );
      if( pProcProperty )
      {
          pProcProperty->setSet( true );
      }
      if ( bHandleDefaultProp )
      {
          // get default properties for lhs & rhs where necessary
          // SbxVariable* defaultProp = NULL; unused variable
          // LHS try determine if a default prop exists
          // again like in StepPUT (see there too ) we are tweaking the
          // heuristics again for when to assign an object reference or
          // use default members if they exist
          // #FIXME we really need to get to the bottom of this mess
          bool bObjAssign = false;
          if ( refVar->GetType() == SbxOBJECT )
          {
              if ( dynamic_cast<const SbxMethod *>(refVar.get()) != nullptr || ! refVar->GetParent() )
              {
                  SbxVariable* pDflt = getDefaultProp( refVar.get() );
                  if ( pDflt )
                  {
                      refVar = pDflt;
                  }
              }
              else
                  bObjAssign = true;
          }
          // RHS only get a default prop is the rhs has one
          if (  refVal->GetType() == SbxOBJECT )
          {
              // check if lhs is a null object
              // if it is then use the object not the default property
              SbxObject* pObj = dynamic_cast<SbxObject*>( refVar.get() );

              // calling GetObject on a SbxEMPTY variable raises
              // object not set errors, make sure it's an Object
              if ( !pObj && refVar->GetType() == SbxOBJECT )
              {
                  SbxBase* pObjVarObj = refVar->GetObject();
                  pObj = dynamic_cast<SbxObject*>( pObjVarObj );
              }
              SbxVariable* pDflt = nullptr;
              if ( pObj && !bObjAssign )
              {
                  // lhs is either a valid object || or has a defaultProp
                  pDflt = getDefaultProp( refVal.get() );
              }
              if ( pDflt )
              {
                  refVal = pDflt;
              }
          }
      }

      // Handle Dim As New
      bool bDimAsNew = bVBAEnabled && refVar->IsSet( SbxFlagBits::DimAsNew );
      SbxBaseRef xPrevVarObj;
      if( bDimAsNew )
      {
          xPrevVarObj = refVar->GetObject();
      }
      // Handle withevents
      bool bWithEvents = refVar->IsSet( SbxFlagBits::WithEvents );
      if ( bWithEvents )
      {
          Reference< XInterface > xComListener;

          SbxBase* pObj = refVal->GetObject();
          SbUnoObject* pUnoObj = dynamic_cast<SbUnoObject*>( pObj );
          if( pUnoObj != nullptr )
          {
              Any aControlAny = pUnoObj->getUnoAny();
              OUString aDeclareClassName = refVar->GetDeclareClassName();
              OUString aPrefix = refVar->GetName();
              SbxObjectRef xScopeObj = refVar->GetParent();
              xComListener = createComListener( aControlAny, aDeclareClassName, aPrefix, xScopeObj );

              refVal->SetDeclareClassName( aDeclareClassName );
              refVal->SetComListener( xComListener, &rBasic );        // Hold reference
          }

      }

      // lhs is a property who's value is currently (Empty e.g. no broadcast yet)
      // in this case if there is a default prop involved the value of the
      // default property may in fact be void so the type will also be SbxEMPTY
      // in this case we do not want to call checkUnoStructCopy 'cause that will
      // cause an error also
      if ( !checkUnoStructCopy( bHandleDefaultProp, refVal, refVar ) )
      {
          *refVar = *refVal;
      }
      if ( bDimAsNew )
      {
          if( dynamic_cast<const SbxObject*>( refVar.get() ) == nullptr )
          {
              SbxBase* pValObjBase = refVal->GetObject();
              if( pValObjBase == nullptr )
              {
                  if( xPrevVarObj.is() )
                  {
                      // Object is overwritten with NULL, instantiate init object
                      DimAsNewRecoverHash &rDimAsNewRecoverHash = GaDimAsNewRecoverHash::get();
                      DimAsNewRecoverHash::iterator it = rDimAsNewRecoverHash.find( refVar.get() );
                      if( it != rDimAsNewRecoverHash.end() )
                      {
                          const DimAsNewRecoverItem& rItem = it->second;
                          if( rItem.m_pClassModule != nullptr )
                          {
                              SbClassModuleObject* pNewObj = new SbClassModuleObject( rItem.m_pClassModule );
                              pNewObj->SetName( rItem.m_aObjName );
                              pNewObj->SetParent( rItem.m_pObjParent );
                              refVar->PutObject( pNewObj );
                          }
                          else if( rItem.m_aObjClass.equalsIgnoreAsciiCase( pCollectionStr ) )
                          {
                              BasicCollection* pNewCollection = new BasicCollection( pCollectionStr );
                              pNewCollection->SetName( rItem.m_aObjName );
                              pNewCollection->SetParent( rItem.m_pObjParent );
                              refVar->PutObject( pNewCollection );
                          }
                      }
                  }
              }
              else
              {
                  // Does old value exist?
                  bool bFirstInit = !xPrevVarObj.is();
                  if( bFirstInit )
                  {
                      // Store information to instantiate object later
                      SbxObject* pValObj = dynamic_cast<SbxObject*>( pValObjBase );
                      if( pValObj != nullptr )
                      {
                          OUString aObjClass = pValObj->GetClassName();

                          SbClassModuleObject* pClassModuleObj = dynamic_cast<SbClassModuleObject*>( pValObjBase );
                          DimAsNewRecoverHash &rDimAsNewRecoverHash = GaDimAsNewRecoverHash::get();
                          if( pClassModuleObj != nullptr )
                          {
                              SbModule* pClassModule = pClassModuleObj->getClassModule();
                              rDimAsNewRecoverHash[refVar.get()] =
                                  DimAsNewRecoverItem( aObjClass, pValObj->GetName(), pValObj->GetParent(), pClassModule );
                          }
                          else if( aObjClass.equalsIgnoreAsciiCase( "Collection" ) )
                          {
                              rDimAsNewRecoverHash[refVar.get()] =
                                  DimAsNewRecoverItem( aObjClass, pValObj->GetName(), pValObj->GetParent(), nullptr );
                          }
                      }
                  }
              }
          }
      }

      if( bFlagsChanged )
      {
          refVar->SetFlags( n );
      }
  }
1979}

1981void SbiRuntime::StepSET()
1982{
  SbxVariableRef refVal = PopVar();
  SbxVariableRef refVar = PopVar();
  StepSET_Impl( refVal, refVar, bVBAEnabled ); // this is really assignment
1986}

1988void SbiRuntime::StepVBASET()
1989{
  SbxVariableRef refVal = PopVar();
  SbxVariableRef refVar = PopVar();
  // don't handle default property
  StepSET_Impl( refVal, refVar ); // set obj = something
1994}


1997void SbiRuntime::StepLSET()
1998{
  SbxVariableRef refVal = PopVar();
  SbxVariableRef refVar = PopVar();
  if( refVar->GetType() != SbxSTRING ||
      refVal->GetType() != SbxSTRING )
  {
      Error( ERRCODE_BASIC_INVALID_USAGE_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) );
  }
  else
  {
      SbxFlagBits n = refVar->GetFlags();
      if( refVar.get() == pMeth )
      {
          refVar->SetFlag( SbxFlagBits::Write );
      }
      OUString aRefVarString = refVar->GetOUString();
      OUString aRefValString = refVal->GetOUString();

      sal_Int32 nVarStrLen = aRefVarString.getLength();
      sal_Int32 nValStrLen = aRefValString.getLength();
      OUString aNewStr;
      if( nVarStrLen > nValStrLen )
      {
          OUStringBuffer buf(aRefValString);
          comphelper::string::padToLength(buf, nVarStrLen, ' ');
          aNewStr = buf.makeStringAndClear();
      }
      else
      {
          aNewStr = aRefValString.copy( 0, nVarStrLen );
      }

      refVar->PutString(aNewStr);
      refVar->SetFlags( n );
  }
2033}

2035void SbiRuntime::StepRSET()
2036{
  SbxVariableRef refVal = PopVar();
  SbxVariableRef refVar = PopVar();
  if( refVar->GetType() != SbxSTRING || refVal->GetType() != SbxSTRING )
  {
      Error( ERRCODE_BASIC_INVALID_USAGE_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) );
  }
  else
  {
      SbxFlagBits n = refVar->GetFlags();
      if( refVar.get() == pMeth )
      {
          refVar->SetFlag( SbxFlagBits::Write );
      }
      OUString aRefVarString = refVar->GetOUString();
      OUString aRefValString = refVal->GetOUString();
      sal_Int32 nVarStrLen = aRefVarString.getLength();
      sal_Int32 nValStrLen = aRefValString.getLength();

      OUStringBuffer aNewStr(nVarStrLen);
      if (nVarStrLen > nValStrLen)
      {
          comphelper::string::padToLength(aNewStr, nVarStrLen - nValStrLen, ' ');
          aNewStr.append(aRefValString);
      }
      else
      {
          aNewStr.append(std::u16string_view(aRefValString).substr(0, nVarStrLen));
      }
      refVar->PutString(aNewStr.makeStringAndClear());

      refVar->SetFlags( n );
  }
2069}

2071// laying down TOS in TOS-1, then set ReadOnly-Bit

2073void SbiRuntime::StepPUTC()
2074{
  SbxVariableRef refVal = PopVar();
  SbxVariableRef refVar = PopVar();
  refVar->SetFlag( SbxFlagBits::Write );
  *refVar = *refVal;
  refVar->ResetFlag( SbxFlagBits::Write );
  refVar->SetFlag( SbxFlagBits::Const );
2081}

2083// DIM
2084// TOS = variable for the array with dimension information as parameter

2086void SbiRuntime::StepDIM()
2087{
  SbxVariableRef refVar = PopVar();
  DimImpl( refVar );
2090}

2092// #56204 swap out DIM-functionality into a help method (step0.cxx)
2093void SbiRuntime::DimImpl(const SbxVariableRef& refVar)
2094{
  // If refDim then this DIM statement is terminating a ReDIM and
  // previous StepERASE_CLEAR for an array, the following actions have
  // been delayed from ( StepERASE_CLEAR ) 'till here
  if ( refRedim.is() )
  {
      if ( !refRedimpArray.is() ) // only erase the array not ReDim Preserve
      {
          lcl_eraseImpl( refVar, bVBAEnabled );
      }
      SbxDataType eType = refVar->GetType();
      lcl_clearImpl( refVar, eType );
      refRedim = nullptr;
  }
  SbxArray* pDims = refVar->GetParameters();
  // must have an even number of arguments
  // have in mind that Arg[0] does not count!
  if( pDims && !( pDims->Count32() & 1 ) )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  }
  else
  {
      SbxDataType eType = refVar->IsFixed() ? refVar->GetType() : SbxVARIANT;
      SbxDimArray* pArray = new SbxDimArray( eType );
      // allow arrays without dimension information, too (VB-compatible)
      if( pDims )
      {
          refVar->ResetFlag( SbxFlagBits::VarToDim );

          for( sal_uInt32 i = 1; i < pDims->Count32(); )
          {
              sal_Int32 lb = pDims->Get32( i++ )->GetLong();
              sal_Int32 ub = pDims->Get32( i++ )->GetLong();
              if( ub < lb )
              {
                  Error( ERRCODE_BASIC_OUT_OF_RANGEErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 4) );
                  ub = lb;
              }
              pArray->AddDim32( lb, ub );
              if ( lb != ub )
              {
                  pArray->setHasFixedSize( true );
              }
          }
      }
      else
      {
          // #62867 On creating an array of the length 0, create
          // a dimension (like for Uno-Sequences of the length 0)
          pArray->unoAddDim32( 0, -1 );
      }
      SbxFlagBits nSavFlags = refVar->GetFlags();
      refVar->ResetFlag( SbxFlagBits::Fixed );
      refVar->PutObject( pArray );
      refVar->SetFlags( nSavFlags );
      refVar->SetParameters( nullptr );
  }
2152}

2154// REDIM
2155// TOS  = variable for the array
2156// argv = dimension information

2158void SbiRuntime::StepREDIM()
2159{
  // Nothing different than dim at the moment because
  // a double dim is already recognized by the compiler.
  StepDIM();
2163}


2166// Helper function for StepREDIMP and StepDCREATE_IMPL / bRedimp = true
2167static void implCopyDimArray( SbxDimArray* pNewArray, SbxDimArray* pOldArray, sal_Int32 nMaxDimIndex,
  sal_Int32 nActualDim, sal_Int32* pActualIndices, sal_Int32* pLowerBounds, sal_Int32* pUpperBounds )
2169{
  sal_Int32& ri = pActualIndices[nActualDim];
  for( ri = pLowerBounds[nActualDim] ; ri <= pUpperBounds[nActualDim] ; ri++ )
  {
      if( nActualDim < nMaxDimIndex )
      {
          implCopyDimArray( pNewArray, pOldArray, nMaxDimIndex, nActualDim + 1,
              pActualIndices, pLowerBounds, pUpperBounds );
      }
      else
      {
          SbxVariable* pSource = pOldArray->Get32( pActualIndices );
          if (pSource && pOldArray->GetRefCount() > 1)
              // tdf#134692: old array will stay alive after the redim - we need to copy deep
              pSource = new SbxVariable(*pSource);
          pNewArray->Put32(pSource, pActualIndices);
      }
  }
2187}

2189// Returns true when actually restored
2190static bool implRestorePreservedArray(SbxDimArray* pNewArray, SbxArrayRef& rrefRedimpArray, bool* pbWasError = nullptr)
2191{
  assert(pNewArray)(static_cast <bool> (pNewArray) ? void (0) : __assert_fail
 ("pNewArray", "/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
, 2192, __extension__ __PRETTY_FUNCTION__));
  bool bResult = false;
  if (pbWasError)
      *pbWasError = false;
  if (rrefRedimpArray)
  {
      SbxDimArray* pOldArray = static_cast<SbxDimArray*>(rrefRedimpArray.get());
      const sal_Int32 nDimsNew = pNewArray->GetDims32();
      const sal_Int32 nDimsOld = pOldArray->GetDims32();

      if (nDimsOld != nDimsNew)
      {
          StarBASIC::Error(ERRCODE_BASIC_OUT_OF_RANGEErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 4));
          if (pbWasError)
              *pbWasError = true;
      }
      else if (nDimsNew > 0)
      {
          // Store dims to use them for copying later
          std::unique_ptr<sal_Int32[]> pLowerBounds(new sal_Int32[nDimsNew]);
          std::unique_ptr<sal_Int32[]> pUpperBounds(new sal_Int32[nDimsNew]);
          std::unique_ptr<sal_Int32[]> pActualIndices(new sal_Int32[nDimsNew]);
          bool bNeedsPreallocation = true;

          // Compare bounds
          for (sal_Int32 i = 1; i <= nDimsNew; i++)
          {
              sal_Int32 lBoundNew, uBoundNew;
              sal_Int32 lBoundOld, uBoundOld;
              pNewArray->GetDim32(i, lBoundNew, uBoundNew);
              pOldArray->GetDim32(i, lBoundOld, uBoundOld);
              lBoundNew = std::max(lBoundNew, lBoundOld);
              uBoundNew = std::min(uBoundNew, uBoundOld);
              sal_Int32 j = i - 1;
              pActualIndices[j] = pLowerBounds[j] = lBoundNew;
              pUpperBounds[j] = uBoundNew;
              if (lBoundNew > uBoundNew) // No elements in the dimension -> no elements to restore
                  bNeedsPreallocation = false;
          }

          // Optimization: pre-allocate underlying container
          if (bNeedsPreallocation)
              pNewArray->Put32(nullptr, pUpperBounds.get());

          // Copy data from old array by going recursively through all dimensions
          // (It would be faster to work on the flat internal data array of an
          // SbyArray but this solution is clearer and easier)
          implCopyDimArray(pNewArray, pOldArray, nDimsNew - 1, 0, pActualIndices.get(),
                           pLowerBounds.get(), pUpperBounds.get());
          bResult = true;
      }

      rrefRedimpArray.clear();
  }
  return bResult;
2247}

2249// REDIM PRESERVE
2250// TOS  = variable for the array
2251// argv = dimension information

2253void SbiRuntime::StepREDIMP()
2254{
  SbxVariableRef refVar = PopVar();
  DimImpl( refVar );

  // Now check, if we can copy from the old array
  if( refRedimpArray.is() )
  {
      if (SbxDimArray* pNewArray = dynamic_cast<SbxDimArray*>(refVar->GetObject()))
          implRestorePreservedArray(pNewArray, refRedimpArray);
  }
2264}

2266// REDIM_COPY
2267// TOS  = Array-Variable, Reference to array is copied
2268//        Variable is cleared as in ERASE

2270void SbiRuntime::StepREDIMP_ERASE()
2271{
  SbxVariableRef refVar = PopVar();
  refRedim = refVar;
  SbxDataType eType = refVar->GetType();
  if( eType & SbxARRAY )
  {
      SbxBase* pElemObj = refVar->GetObject();
      SbxDimArray* pDimArray = dynamic_cast<SbxDimArray*>( pElemObj );
      if( pDimArray )
      {
          refRedimpArray = pDimArray;
      }

  }
  else if( refVar->IsFixed() )
  {
      refVar->Clear();
  }
  else
  {
      refVar->SetType( SbxEMPTY );
  }
2293}

2295static void lcl_clearImpl( SbxVariableRef const & refVar, SbxDataType const & eType )
2296{
  SbxFlagBits nSavFlags = refVar->GetFlags();
  refVar->ResetFlag( SbxFlagBits::Fixed );
  refVar->SetType( SbxDataType(eType & 0x0FFF) );
  refVar->SetFlags( nSavFlags );
  refVar->Clear();
2302}

2304static void lcl_eraseImpl( SbxVariableRef const & refVar, bool bVBAEnabled )
2305{
  SbxDataType eType = refVar->GetType();
  if( eType & SbxARRAY )
  {
      if ( bVBAEnabled )
      {
          SbxBase* pElemObj = refVar->GetObject();
          SbxDimArray* pDimArray = dynamic_cast<SbxDimArray*>( pElemObj );
          if( pDimArray )
          {
              if ( pDimArray->hasFixedSize() )
              {
                  // Clear all Value(s)
                  pDimArray->SbxArray::Clear();
              }
              else
              {
                  pDimArray->Clear(); // clear dims and values
              }
          }
          else
          {
              SbxArray* pArray = dynamic_cast<SbxArray*>( pElemObj );
              if ( pArray )
              {
                  pArray->Clear();
              }
          }
      }
      else
      {
          // Arrays have on an erase to VB quite a complex behaviour. Here are
          // only the type problems at REDIM (#26295) removed at first:
          // Set type hard onto the array-type, because a variable with array is
          // SbxOBJECT. At REDIM there's an SbxOBJECT-array generated then and
          // the original type is lost -> runtime error
          lcl_clearImpl( refVar, eType );
      }
  }
  else if( refVar->IsFixed() )
  {
      refVar->Clear();
  }
  else
  {
      refVar->SetType( SbxEMPTY );
  }
2352}

2354// delete variable
2355// TOS = variable

2357void SbiRuntime::StepERASE()
2358{
  SbxVariableRef refVar = PopVar();
  lcl_eraseImpl( refVar, bVBAEnabled );
2361}

2363void SbiRuntime::StepERASE_CLEAR()
2364{
  refRedim = PopVar();
2366}

2368void SbiRuntime::StepARRAYACCESS()
2369{
  if( !refArgv.is() )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  }
  SbxVariableRef refVar = PopVar();
  refVar->SetParameters( refArgv.get() );
  PopArgv();
  PushVar( CheckArray( refVar.get() ) );
2378}

2380void SbiRuntime::StepBYVAL()
2381{
  // Copy variable on stack to break call by reference
  SbxVariableRef pVar = PopVar();
  SbxDataType t = pVar->GetType();

  SbxVariable* pCopyVar = new SbxVariable( t );
  pCopyVar->SetFlag( SbxFlagBits::ReadWrite );
  *pCopyVar = *pVar;

  PushVar( pCopyVar );
2391}

2393// establishing an argv
2394// nOp1 stays as it is -> 1st element is the return value

2396void SbiRuntime::StepARGC()
2397{
  PushArgv();
  refArgv = new SbxArray;
  nArgc = 1;
2401}

2403// storing an argument in Argv

2405void SbiRuntime::StepARGV()
2406{
  if( !refArgv.is() )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  }
  else
  {
      SbxVariableRef pVal = PopVar();

      // Before fix of #94916:
      if( dynamic_cast<const SbxMethod*>( pVal.get() ) != nullptr
          || dynamic_cast<const SbUnoProperty*>( pVal.get() ) != nullptr
          || dynamic_cast<const SbProcedureProperty*>( pVal.get() ) != nullptr )
      {
          // evaluate methods and properties!
          SbxVariable* pRes = new SbxVariable( *pVal );
          pVal = pRes;
      }
      refArgv->Put32( pVal.get(), nArgc++ );
  }
2426}

2428// Input to Variable. The variable is on TOS and is
2429// is removed afterwards.
2430void SbiRuntime::StepINPUT()
2431{
  OUStringBuffer sin;
  char ch = 0;
  ErrCode err;
  // Skip whitespace
  while( ( err = pIosys->GetError() ) == ERRCODE_NONEErrCode(0) )
  {
      ch = pIosys->Read();
      if( ch != ' ' && ch != '\t' && ch != '\n' )
      {
          break;
      }
  }
  if( !err )
  {
      // Scan until comma or whitespace
      char sep = ( ch == '"' ) ? ch : 0;
      if( sep )
      {
          ch = pIosys->Read();
      }
      while( ( err = pIosys->GetError() ) == ERRCODE_NONEErrCode(0) )
      {
          if( ch == sep )
          {
              ch = pIosys->Read();
              if( ch != sep )
              {
                  break;
              }
          }
          else if( !sep && (ch == ',' || ch == '\n') )
          {
              break;
          }
          sin.append( ch );
          ch = pIosys->Read();
      }
      // skip whitespace
      if( ch == ' ' || ch == '\t' )
      {
          while( ( err = pIosys->GetError() ) == ERRCODE_NONEErrCode(0) )
          {
              if( ch != ' ' && ch != '\t' && ch != '\n' )
              {
                  break;
              }
              ch = pIosys->Read();
          }
      }
  }
  if( !err )
  {
      OUString s = sin.makeStringAndClear();
      SbxVariableRef pVar = GetTOS();
      // try to fill the variable with a numeric value first,
      // then with a string value
      if( !pVar->IsFixed() || pVar->IsNumeric() )
      {
          sal_uInt16 nLen = 0;
          if( !pVar->Scan( s, &nLen ) )
          {
              err = SbxBase::GetError();
              SbxBase::ResetError();
          }
          // the value has to be scanned in completely
          else if( nLen != s.getLength() && !pVar->PutString( s ) )
          {
              err = SbxBase::GetError();
              SbxBase::ResetError();
          }
          else if( nLen != s.getLength() && pVar->IsNumeric() )
          {
              err = SbxBase::GetError();
              SbxBase::ResetError();
              if( !err )
              {
                  err = ERRCODE_BASIC_CONVERSIONErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 6);
              }
          }
      }
      else
      {
          pVar->PutString( s );
          err = SbxBase::GetError();
          SbxBase::ResetError();
      }
  }
  if( err == ERRCODE_BASIC_USER_ABORTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 36 ) )
  {
      Error( err );
  }
  else if( err )
  {
      if( pRestart && !pIosys->GetChannel() )
      {
          pCode = pRestart;
      }
      else
      {
          Error( err );
      }
  }
  else
  {
      PopVar();
  }
2538}

2540// Line Input to Variable. The variable is on TOS and is
2541// deleted afterwards.

2543void SbiRuntime::StepLINPUT()
2544{
  OString aInput;
  pIosys->Read( aInput );
  Error( pIosys->GetError() );
  SbxVariableRef p = PopVar();
  p->PutString(OStringToOUString(aInput, osl_getThreadTextEncoding()));
2550}

2552// end of program

2554void SbiRuntime::StepSTOP()
2555{
  pInst->Stop();
2557}


2560void SbiRuntime::StepINITFOR()
2561{
  PushFor();
2563}

2565void SbiRuntime::StepINITFOREACH()
2566{
  PushForEach();
2568}

2570// increment FOR-variable

2572void SbiRuntime::StepNEXT()
2573{
  if( !pForStk )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
      return;
  }
  if (pForStk->eForType != ForType::To)
      return;
  if (!pForStk->refVar)
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
      return;
  }
  pForStk->refVar->Compute( SbxPLUS, *pForStk->refInc );
2587}

2589// beginning CASE: TOS in CASE-stack

2591void SbiRuntime::StepCASE()
2592{
  if( !refCaseStk.is() )
  {
      refCaseStk = new SbxArray;
  }
  SbxVariableRef xVar = PopVar();
  refCaseStk->Put32( xVar.get(), refCaseStk->Count32() );
2599}

2601// end CASE: free variable

2603void SbiRuntime::StepENDCASE()
2604{
  if( !refCaseStk.is() || !refCaseStk->Count32() )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  }
  else
  {
      refCaseStk->Remove( refCaseStk->Count32() - 1 );
  }
2613}


2616void SbiRuntime::StepSTDERROR()
2617{
  pError = nullptr; bError = true;
  pInst->aErrorMsg.clear();
  pInst->nErr = ERRCODE_NONEErrCode(0);
  pInst->nErl = 0;
  nError = ERRCODE_NONEErrCode(0);
  SbxErrObject::getUnoErrObject()->Clear();
2624}

2626void SbiRuntime::StepNOERROR()
2627{
  pInst->aErrorMsg.clear();
  pInst->nErr = ERRCODE_NONEErrCode(0);
  pInst->nErl = 0;
  nError = ERRCODE_NONEErrCode(0);
  SbxErrObject::getUnoErrObject()->Clear();
  bError = false;
2634}

2636// leave UP

2638void SbiRuntime::StepLEAVE()
2639{
  bRun = false;
      // If VBA and we are leaving an ErrorHandler then clear the error ( it's been processed )
  if ( bInError && pError )
  {
      SbxErrObject::getUnoErrObject()->Clear();
  }
2646}

2648void SbiRuntime::StepCHANNEL()      // TOS = channel number
2649{
  SbxVariableRef pChan = PopVar();
  short nChan = pChan->GetInteger();
  pIosys->SetChannel( nChan );
  Error( pIosys->GetError() );
2654}

2656void SbiRuntime::StepCHANNEL0()
2657{
  pIosys->ResetChannel();
2659}

2661void SbiRuntime::StepPRINT()        // print TOS
2662{
  SbxVariableRef p = PopVar();
  OUString s1 = p->GetOUString();
  OUString s;
  if( p->GetType() >= SbxINTEGER && p->GetType() <= SbxDOUBLE )
  {
      s = " ";    // one blank before
  }
  s += s1;
  pIosys->Write( s );
  Error( pIosys->GetError() );
2673}

2675void SbiRuntime::StepPRINTF()       // print TOS in field
2676{
  SbxVariableRef p = PopVar();
  OUString s1 = p->GetOUString();
  OUStringBuffer s;
  if( p->GetType() >= SbxINTEGER && p->GetType() <= SbxDOUBLE )
  {
      s.append(' ');
  }
  s.append(s1);
  comphelper::string::padToLength(s, 14, ' ');
  pIosys->Write( s.makeStringAndClear() );
  Error( pIosys->GetError() );
2688}

2690void SbiRuntime::StepWRITE()        // write TOS
2691{
  SbxVariableRef p = PopVar();
  // Does the string have to be encapsulated?
  char ch = 0;
  switch (p->GetType() )
  {
  case SbxSTRING: ch = '"'; break;
  case SbxCURRENCY:
  case SbxBOOL:
  case SbxDATE: ch = '#'; break;
  default: break;
  }
  OUString s;
  if( ch )
  {
      s += OUString(ch);
  }
  s += p->GetOUString();
  if( ch )
  {
      s += OUString(ch);
  }
  pIosys->Write( s );
  Error( pIosys->GetError() );
2715}

2717void SbiRuntime::StepRENAME()       // Rename Tos+1 to Tos
2718{
  SbxVariableRef pTos1 = PopVar();
  SbxVariableRef pTos  = PopVar();
  OUString aDest = pTos1->GetOUString();
  OUString aSource = pTos->GetOUString();

  if( hasUno() )
  {
      implStepRenameUCB( aSource, aDest );
  }
  else
  {
      implStepRenameOSL( aSource, aDest );
  }
2732}

2734// TOS = Prompt

2736void SbiRuntime::StepPROMPT()
2737{
  SbxVariableRef p = PopVar();
  OString aStr(OUStringToOString(p->GetOUString(), osl_getThreadTextEncoding()));
  pIosys->SetPrompt( aStr );
2741}

2743// Set Restart point

2745void SbiRuntime::StepRESTART()
2746{
  pRestart = pCode;
2748}

2750// empty expression on stack for missing parameter

2752void SbiRuntime::StepEMPTY()
2753{
  // #57915 The semantics of StepEMPTY() is the representation of a missing argument.
  // This is represented by the value 448 (ERRCODE_BASIC_NAMED_NOT_FOUND) of the type error
  // in VB. StepEmpty should now rather be named StepMISSING() but the name is kept
  // to simplify matters.
  SbxVariableRef xVar = new SbxVariable( SbxVARIANT );
  xVar->PutErr( 448 );
  // tdf#79426, tdf#125180 - add additional information about a missing parameter
  SetIsMissing( xVar.get() );
  PushVar( xVar.get() );
2763}

2765// TOS = error code

2767void SbiRuntime::StepERROR()
2768{
  SbxVariableRef refCode = PopVar();
  sal_uInt16 n = refCode->GetUShort();
  ErrCode error = StarBASIC::GetSfxFromVBError( n );
  if ( bVBAEnabled )
  {
      pInst->Error( error );
  }
  else
  {
      Error( error );
  }
2780}

2782// loading a numeric constant (+ID)

2784void SbiRuntime::StepLOADNC( sal_uInt32 nOp1 )
2785{
  // #57844 use localized function
  OUString aStr = pImg->GetString( static_cast<short>( nOp1 ) );
  // also allow , !!!
  sal_Int32 iComma = aStr.indexOf(',');
  if( iComma >= 0 )
  {
      aStr = aStr.replaceAt(iComma, 1, ".");
  }
  sal_Int32 nParseEnd = 0;
  rtl_math_ConversionStatus eStatus = rtl_math_ConversionStatus_Ok;
  double n = ::rtl::math::stringToDouble( aStr, '.', ',', &eStatus, &nParseEnd );

  // tdf#131296 - retrieve data type put in SbiExprNode::Gen
  SbxDataType eType = SbxDOUBLE;
  if ( nParseEnd < aStr.getLength() )
  {
      switch ( aStr[nParseEnd] )
      {
          // See GetSuffixType in basic/source/comp/scanner.cxx for type characters
          case '%': eType = SbxINTEGER; break;
          case '&': eType = SbxLONG; break;
          case '!': eType = SbxSINGLE; break;
          case '@': eType = SbxCURRENCY; break;
      }
  }
  SbxVariable* p = new SbxVariable( eType );
  p->PutDouble( n );
  // tdf#133913 - create variable with Variant/Type in order to prevent type conversion errors
  p->ResetFlag( SbxFlagBits::Fixed );
  PushVar( p );
2816}

2818// loading a string constant (+ID)

2820void SbiRuntime::StepLOADSC( sal_uInt32 nOp1 )
2821{
  SbxVariable* p = new SbxVariable;
  p->PutString( pImg->GetString( static_cast<short>( nOp1 ) ) );
  PushVar( p );
2825}

2827// Immediate Load (+value)
2828// The opcode is not generated in SbiExprNode::Gen anymore; used for legacy images

2830void SbiRuntime::StepLOADI( sal_uInt32 nOp1 )
2831{
  SbxVariable* p = new SbxVariable;
  p->PutInteger( static_cast<sal_Int16>( nOp1 ) );
  PushVar( p );
2835}

2837// store a named argument in Argv (+Arg-no. from 1!)

2839void SbiRuntime::StepARGN( sal_uInt32 nOp1 )
2840{
  if( !refArgv.is() )
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  else
  {
      OUString aAlias( pImg->GetString( static_cast<short>( nOp1 ) ) );
      SbxVariableRef pVal = PopVar();
      if( bVBAEnabled &&
              ( dynamic_cast<const SbxMethod*>( pVal.get()) != nullptr
                || dynamic_cast<const SbUnoProperty*>( pVal.get()) != nullptr
                || dynamic_cast<const SbProcedureProperty*>( pVal.get()) != nullptr ) )
      {
          // named variables ( that are Any especially properties ) can be empty at this point and need a broadcast
          if ( pVal->GetType() == SbxEMPTY )
              pVal->Broadcast( SfxHintId::BasicDataWanted );
          // evaluate methods and properties!
          SbxVariable* pRes = new SbxVariable( *pVal );
          pVal = pRes;
      }
      refArgv->Put32( pVal.get(), nArgc );
      refArgv->PutAlias32( aAlias, nArgc++ );
  }
2862}

2864// converting the type of an argument in Argv for DECLARE-Fkt. (+type)

2866void SbiRuntime::StepARGTYP( sal_uInt32 nOp1 )
2867{
  if( !refArgv.is() )
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  else
  {
      bool bByVal = (nOp1 & 0x8000) != 0;         // Is BYVAL requested?
      SbxDataType t = static_cast<SbxDataType>(nOp1 & 0x7FFF);
      SbxVariable* pVar = refArgv->Get32( refArgv->Count32() - 1 );   // last Arg

      // check BYVAL
      if( pVar->GetRefCount() > 2 )       // 2 is normal for BYVAL
      {
          // parameter is a reference
          if( bByVal )
          {
              // Call by Value is requested -> create a copy
              pVar = new SbxVariable( *pVar );
              pVar->SetFlag( SbxFlagBits::ReadWrite );
              refExprStk->Put32( pVar, refArgv->Count32() - 1 );
          }
          else
              pVar->SetFlag( SbxFlagBits::Reference );     // Ref-Flag for DllMgr
      }
      else
      {
          // parameter is NO reference
          if( bByVal )
              pVar->ResetFlag( SbxFlagBits::Reference );   // no reference -> OK
          else
              Error( ERRCODE_BASIC_BAD_PARAMETERSErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 110 ) );      // reference needed
      }

      if( pVar->GetType() != t )
      {
          // variant for correct conversion
          // besides error, if SbxBYREF
          pVar->Convert( SbxVARIANT );
          pVar->Convert( t );
      }
  }
2907}

2909// bring string to a definite length (+length)

2911void SbiRuntime::StepPAD( sal_uInt32 nOp1 )
2912{
  SbxVariable* p = GetTOS();
  OUString s = p->GetOUString();
  sal_Int32 nLen(nOp1);
  if( s.getLength() == nLen )
      return;

  OUStringBuffer aBuf(s);
  if (aBuf.getLength() > nLen)
  {
      comphelper::string::truncateToLength(aBuf, nLen);
  }
  else
  {
      comphelper::string::padToLength(aBuf, nLen, ' ');
  }
  s = aBuf.makeStringAndClear();
2929}

2931// jump (+target)

2933void SbiRuntime::StepJUMP( sal_uInt32 nOp1 )
2934{
2935#ifdef DBG_UTIL
  // #QUESTION shouldn't this be
  // if( (sal_uInt8*)( nOp1+pImagGetCode() ) >= pImg->GetCodeSize() )
  if( nOp1 >= pImg->GetCodeSize() )
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
2940#endif
  pCode = reinterpret_cast<const sal_uInt8*>(pImg->GetCode()) + nOp1;
2942}

2944// evaluate TOS, conditional jump (+target)

2946void SbiRuntime::StepJUMPT( sal_uInt32 nOp1 )
2947{
  SbxVariableRef p = PopVar();
  if( p->GetBool() )
      StepJUMP( nOp1 );
2951}

2953// evaluate TOS, conditional jump (+target)

2955void SbiRuntime::StepJUMPF( sal_uInt32 nOp1 )
2956{
  SbxVariableRef p = PopVar();
  // In a test e.g. If Null then
      // will evaluate Null will act as if False
  if( ( bVBAEnabled && p->IsNull() ) || !p->GetBool() )
      StepJUMP( nOp1 );
2962}

2964// evaluate TOS, jump into JUMP-table (+MaxVal)
2965// looks like this:
2966// ONJUMP 2
2967// JUMP target1
2968// JUMP target2

2970// if 0x8000 is set in the operand, push the return address (ON..GOSUB)

2972void SbiRuntime::StepONJUMP( sal_uInt32 nOp1 )
2973{
  SbxVariableRef p = PopVar();
  sal_Int16 n = p->GetInteger();
  if( nOp1 & 0x8000 )
  {
      nOp1 &= 0x7FFF;
      PushGosub( pCode + 5 * nOp1 );
  }
  if( n < 1 || o3tl::make_unsigned(n) > nOp1 )
      n = static_cast<sal_Int16>( nOp1 + 1 );
  nOp1 = static_cast<sal_uInt32>( reinterpret_cast<const char*>(pCode) - pImg->GetCode() ) + 5 * --n;
  StepJUMP( nOp1 );
2985}

2987// UP-call (+target)

2989void SbiRuntime::StepGOSUB( sal_uInt32 nOp1 )
2990{
  PushGosub( pCode );
  if( nOp1 >= pImg->GetCodeSize() )
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  pCode = reinterpret_cast<const sal_uInt8*>(pImg->GetCode()) + nOp1;
2995}

2997// UP-return (+0 or target)

2999void SbiRuntime::StepRETURN( sal_uInt32 nOp1 )
3000{
  PopGosub();
  if( nOp1 )
      StepJUMP( nOp1 );
3004}

3006// check FOR-variable (+Endlabel)

3008void SbiRuntime::StepTESTFOR( sal_uInt32 nOp1 )
3009{
  if( !pForStk )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
      return;
  }

  bool bEndLoop = false;
  switch( pForStk->eForType )
  {
      case ForType::To:
      {
          SbxOperator eOp = ( pForStk->refInc->GetDouble() < 0 ) ? SbxLT : SbxGT;
          if( pForStk->refVar->Compare( eOp, *pForStk->refEnd ) )
              bEndLoop = true;
          if (SbxBase::IsError())
              pForStk->eForType = ForType::Error; // terminate loop at the next iteration
          break;
      }
      case ForType::EachArray:
      {
          SbiForStack* p = pForStk;
          if (!p->refEnd)
          {
              SbxBase::SetError(ERRCODE_BASIC_CONVERSIONErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 6));
              pForStk->eForType = ForType::Error; // terminate loop at the next iteration
          }
          else if (p->pArrayCurIndices == nullptr)
          {
              bEndLoop = true;
          }
          else
          {
              SbxDimArray* pArray = reinterpret_cast<SbxDimArray*>(p->refEnd.get());
              sal_Int32 nDims = pArray->GetDims32();

              // Empty array?
              if( nDims == 1 && p->pArrayLowerBounds[0] > p->pArrayUpperBounds[0] )
              {
                  bEndLoop = true;
                  break;
              }
              SbxVariable* pVal = pArray->Get32( p->pArrayCurIndices.get() );
              *(p->refVar) = *pVal;

              bool bFoundNext = false;
              for(sal_Int32 i = 0 ; i < nDims ; i++ )
              {
                  if( p->pArrayCurIndices[i] < p->pArrayUpperBounds[i] )
                  {
                      bFoundNext = true;
                      p->pArrayCurIndices[i]++;
                      for( sal_Int32 j = i - 1 ; j >= 0 ; j-- )
                          p->pArrayCurIndices[j] = p->pArrayLowerBounds[j];
                      break;
                  }
              }
              if( !bFoundNext )
              {
                  p->pArrayCurIndices.reset();
              }
          }
          break;
      }
      case ForType::EachCollection:
      {
          if (!pForStk->refEnd)
          {
              SbxBase::SetError(ERRCODE_BASIC_CONVERSIONErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 6));
              pForStk->eForType = ForType::Error; // terminate loop at the next iteration
              break;
          }

          BasicCollection* pCollection = static_cast<BasicCollection*>(pForStk->refEnd.get());
          SbxArrayRef xItemArray = pCollection->xItemArray;
          sal_Int32 nCount = xItemArray->Count32();
          if( pForStk->nCurCollectionIndex < nCount )
          {
              SbxVariable* pRes = xItemArray->Get32( pForStk->nCurCollectionIndex );
              pForStk->nCurCollectionIndex++;
              (*pForStk->refVar) = *pRes;
          }
          else
          {
              bEndLoop = true;
          }
          break;
      }
      case ForType::EachXEnumeration:
      {
          SbiForStack* p = pForStk;
          if (!p->xEnumeration)
          {
              SbxBase::SetError(ERRCODE_BASIC_CONVERSIONErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 6));
              pForStk->eForType = ForType::Error; // terminate loop at the next iteration
          }
          else if (p->xEnumeration->hasMoreElements())
          {
              Any aElem = p->xEnumeration->nextElement();
              SbxVariableRef xVar = new SbxVariable( SbxVARIANT );
              unoToSbxValue( xVar.get(), aElem );
              (*pForStk->refVar) = *xVar;
          }
          else
          {
              bEndLoop = true;
          }
          break;
      }
      case ForType::Error:
      {
          // We are in Resume Next mode after failed loop initialization
          bEndLoop = true;
          Error(ERRCODE_BASIC_BAD_PARAMETERErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 7));
          break;
      }
  }
  if( bEndLoop )
  {
      PopFor();
      StepJUMP( nOp1 );
  }
3131}

3133// Tos+1 <= Tos+2 <= Tos, 2xremove (+Target)

3135void SbiRuntime::StepCASETO( sal_uInt32 nOp1 )
3136{
  if( !refCaseStk.is() || !refCaseStk->Count32() )
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  else
  {
      SbxVariableRef xTo   = PopVar();
      SbxVariableRef xFrom = PopVar();
      SbxVariableRef xCase = refCaseStk->Get32( refCaseStk->Count32() - 1 );
      if( *xCase >= *xFrom && *xCase <= *xTo )
          StepJUMP( nOp1 );
  }
3147}


3150void SbiRuntime::StepERRHDL( sal_uInt32 nOp1 )
3151{
  const sal_uInt8* p = pCode;
  StepJUMP( nOp1 );
  pError = pCode;
  pCode = p;
  pInst->aErrorMsg.clear();
  pInst->nErr = ERRCODE_NONEErrCode(0);
  pInst->nErl = 0;
  nError = ERRCODE_NONEErrCode(0);
  SbxErrObject::getUnoErrObject()->Clear();
3161}

3163// Resume after errors (+0=statement, 1=next or Label)

3165void SbiRuntime::StepRESUME( sal_uInt32 nOp1 )
3166{
  // #32714 Resume without error? -> error
  if( !bInError )
  {
      Error( ERRCODE_BASIC_BAD_RESUMEErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 37 ) );
      return;
  }
  if( nOp1 )
  {
      // set Code-pointer to the next statement
      sal_uInt16 n1, n2;
      pCode = pMod->FindNextStmnt( pErrCode, n1, n2, true, pImg );
  }
  else
      pCode = pErrStmnt;
  if ( pError ) // current in error handler ( and got a Resume Next statement )
      SbxErrObject::getUnoErrObject()->Clear();

  if( nOp1 > 1 )
      StepJUMP( nOp1 );
  pInst->aErrorMsg.clear();
  pInst->nErr = ERRCODE_NONEErrCode(0);
  pInst->nErl = 0;
  nError = ERRCODE_NONEErrCode(0);
  bInError = false;
3191}

3193// close channel (+channel, 0=all)
3194void SbiRuntime::StepCLOSE( sal_uInt32 nOp1 )
3195{
  ErrCode err;
  if( !nOp1 )
      pIosys->Shutdown();
  else
  {
      err = pIosys->GetError();
      if( !err )
      {
          pIosys->Close();
      }
  }
  err = pIosys->GetError();
  Error( err );
3209}

3211// output character (+char)

3213void SbiRuntime::StepPRCHAR( sal_uInt32 nOp1 )
3214{
  OUString s(static_cast<sal_Unicode>(nOp1));
  pIosys->Write( s );
  Error( pIosys->GetError() );
3218}

3220// check whether TOS is a certain object class (+StringID)

3222bool SbiRuntime::implIsClass( SbxObject const * pObj, const OUString& aClass )
3223{
  bool bRet = true;

  if( !aClass.isEmpty() )
  {
      bRet = pObj->IsClass( aClass );
      if( !bRet )
          bRet = aClass.equalsIgnoreAsciiCase( "object" );
      if( !bRet )
      {
          const OUString& aObjClass = pObj->GetClassName();
          SbModule* pClassMod = GetSbData()->pClassFac->FindClass( aObjClass );
          if( pClassMod )
          {
              SbClassData* pClassData = pClassMod->pClassData.get();
              if (pClassData != nullptr )
              {
                  SbxVariable* pClassVar = pClassData->mxIfaces->Find( aClass, SbxClassType::DontCare );
                  bRet = (pClassVar != nullptr);
              }
          }
      }
  }
  return bRet;
3247}

3249bool SbiRuntime::checkClass_Impl( const SbxVariableRef& refVal,
  const OUString& aClass, bool bRaiseErrors, bool bDefault )
3251{
  bool bOk = bDefault;

  SbxDataType t = refVal->GetType();
  SbxVariable* pVal = refVal.get();
  // we don't know the type of uno properties that are (maybevoid)
  if ( t == SbxEMPTY )
  {
      if ( auto pProp = dynamic_cast<SbUnoProperty*>( refVal.get() ) )
      {
          t = pProp->getRealType();
      }
  }
  if( t == SbxOBJECT || bVBAEnabled )
  {
      SbxObject* pObj = dynamic_cast<SbxObject*>(pVal);
      if (!pObj)
      {
          pObj = dynamic_cast<SbxObject*>(refVal->GetObject());
      }
      if( pObj )
      {
          if( !implIsClass( pObj, aClass ) )
          {
              SbUnoObject* pUnoObj(nullptr);
              if (bVBAEnabled || CodeCompleteOptions::IsExtendedTypeDeclaration())
              {
                  pUnoObj = dynamic_cast<SbUnoObject*>(pObj);
              }

              if (pUnoObj)
                  bOk = checkUnoObjectType(*pUnoObj, aClass);
              else
                  bOk = false;
              if ( !bOk && bRaiseErrors )
                  Error( ERRCODE_BASIC_INVALID_USAGE_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) );
          }
          else
          {
              bOk = true;

              SbClassModuleObject* pClassModuleObject = dynamic_cast<SbClassModuleObject*>( pObj );
              if( pClassModuleObject != nullptr )
                  pClassModuleObject->triggerInitializeEvent();
          }
      }
  }
  else
  {
      if( bRaiseErrors )
          Error( ERRCODE_BASIC_NEEDS_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 81 ) );
      bOk = false;
  }
  return bOk;
3305}

3307void SbiRuntime::StepSETCLASS_impl( sal_uInt32 nOp1, bool bHandleDflt )
3308{
  SbxVariableRef refVal = PopVar();
  SbxVariableRef refVar = PopVar();
  OUString aClass( pImg->GetString( static_cast<short>( nOp1 ) ) );

  bool bOk = checkClass_Impl( refVal, aClass, true, true );
  if( bOk )
  {
      StepSET_Impl( refVal, refVar, bHandleDflt ); // don't do handle default prop for a "proper" set
  }
3318}

3320void SbiRuntime::StepVBASETCLASS( sal_uInt32 nOp1 )
3321{
  StepSETCLASS_impl( nOp1, false );
3323}

3325void SbiRuntime::StepSETCLASS( sal_uInt32 nOp1 )
3326{
  StepSETCLASS_impl( nOp1, true );
3328}

3330void SbiRuntime::StepTESTCLASS( sal_uInt32 nOp1 )
3331{
  SbxVariableRef xObjVal = PopVar();
  OUString aClass( pImg->GetString( static_cast<short>( nOp1 ) ) );
  bool bDefault = !bVBAEnabled;
  bool bOk = checkClass_Impl( xObjVal, aClass, false, bDefault );

  SbxVariable* pRet = new SbxVariable;
  pRet->PutBool( bOk );
  PushVar( pRet );
3340}

3342// define library for following declare-call

3344void SbiRuntime::StepLIB( sal_uInt32 nOp1 )
3345{
  aLibName = pImg->GetString( static_cast<short>( nOp1 ) );
3347}

3349// TOS is incremented by BASE, BASE is pushed before (+BASE)
3350// This opcode is pushed before DIM/REDIM-commands,
3351// if there's been only one index named.

3353void SbiRuntime::StepBASED( sal_uInt32 nOp1 )
3354{
  SbxVariable* p1 = new SbxVariable;
  SbxVariableRef x2 = PopVar();

  // #109275 Check compatibility mode
  bool bCompatible = ((nOp1 & 0x8000) != 0);
  sal_uInt16 uBase = static_cast<sal_uInt16>(nOp1 & 1);       // Can only be 0 or 1
  p1->PutInteger( uBase );
  if( !bCompatible )
      x2->Compute( SbxPLUS, *p1 );
  PushVar( x2.get() );  // first the Expr
  PushVar( p1 );  // then the Base
3366}

3368// the bits in the String-ID:
3369// 0x8000 - Argv is reserved

3371SbxVariable* SbiRuntime::FindElement( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2,
                                    ErrCode nNotFound, bool bLocal, bool bStatic )
3373{
  bool bIsVBAInterOp = SbiRuntime::isVBAEnabled();
  if( bIsVBAInterOp )
  {
      StarBASIC* pMSOMacroRuntimeLib = GetSbData()->pMSOMacroRuntimLib;
      if( pMSOMacroRuntimeLib != nullptr )
      {
          pMSOMacroRuntimeLib->ResetFlag( SbxFlagBits::ExtSearch );
      }
  }

  SbxVariable* pElem = nullptr;
  if( !pObj )
  {
      Error( ERRCODE_BASIC_NO_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 10) );
      pElem = new SbxVariable;
  }
  else
  {
      bool bFatalError = false;
      SbxDataType t = static_cast<SbxDataType>(nOp2);
      OUString aName( pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) ) );
      // Hacky capture of Evaluate [] syntax
      // this should be tackled I feel at the pcode level
      if ( bIsVBAInterOp && aName.startsWith("[") )
      {
          // emulate pcode here
          StepARGC();
          // pseudo StepLOADSC
          OUString sArg = aName.copy( 1, aName.getLength() - 2 );
          SbxVariable* p = new SbxVariable;
          p->PutString( sArg );
          PushVar( p );
          StepARGV();
          nOp1 = nOp1 | 0x8000; // indicate params are present
          aName = "Evaluate";
      }
      if( bLocal )
      {
          if ( bStatic && pMeth )
          {
              pElem = pMeth->GetStatics()->Find( aName, SbxClassType::DontCare );
          }

          if ( !pElem )
          {
              pElem = refLocals->Find( aName, SbxClassType::DontCare );
          }
      }
      if( !pElem )
      {
          bool bSave = rBasic.bNoRtl;
          rBasic.bNoRtl = true;
          pElem = pObj->Find( aName, SbxClassType::DontCare );

          // #110004, #112015: Make private really private
          if( bLocal && pElem )   // Local as flag for global search
          {
              if( pElem->IsSet( SbxFlagBits::Private ) )
              {
                  SbiInstance* pInst_ = GetSbData()->pInst;
                  if( pInst_ && pInst_->IsCompatibility() && pObj != pElem->GetParent() )
                  {
                      pElem = nullptr;   // Found but in wrong module!
                  }
                  // Interfaces: Use SbxFlagBits::ExtFound
              }
          }
          rBasic.bNoRtl = bSave;

          // is it a global uno-identifier?
          if( bLocal && !pElem )
          {
              bool bSetName = true; // preserve normal behaviour

              // i#i68894# if VBAInterOp favour searching vba globals
              // over searching for uno classes
              if ( bVBAEnabled )
              {
                  // Try Find in VBA symbols space
                  pElem = rBasic.VBAFind( aName, SbxClassType::DontCare );
                  if ( pElem )
                  {
                      bSetName = false; // don't overwrite uno name
                  }
                  else
                  {
                      pElem = VBAConstantHelper::instance().getVBAConstant( aName );
                  }
              }

              if( !pElem )
              {
                  // #72382 ATTENTION! ALWAYS returns a result now
                  // because of unknown modules!
                  SbUnoClass* pUnoClass = findUnoClass( aName );
                  if( pUnoClass )
                  {
                      pElem = new SbxVariable( t );
                      SbxValues aRes( SbxOBJECT );
                      aRes.pObj = pUnoClass;
                      pElem->SbxVariable::Put( aRes );
                  }
              }

              // #62939 If a uno-class has been found, the wrapper
              // object has to be held, because the uno-class, e. g.
              // "stardiv", has to be read out of the registry
              // every time again otherwise
              if( pElem )
              {
                  // #63774 May not be saved too!!!
                  pElem->SetFlag( SbxFlagBits::DontStore );
                  pElem->SetFlag( SbxFlagBits::NoModify);

                  // #72382 save locally, all variables that have been declared
                  // implicit would become global automatically otherwise!
                  if ( bSetName )
                  {
                      pElem->SetName( aName );
                  }
                  refLocals->Put32( pElem, refLocals->Count32() );
              }
          }

          if( !pElem )
          {
              // not there and not in the object?
              // don't establish if that thing has parameters!
              if( nOp1 & 0x8000 )
              {
                  bFatalError = true;
              }

              // else, if there are parameters, use different error code
              if( !bLocal || pImg->IsFlag( SbiImageFlags::EXPLICIT ) )
              {
                  // #39108 if explicit and as ELEM always a fatal error
                  bFatalError = true;


                  if( !( nOp1 & 0x8000 ) && nNotFound == ERRCODE_BASIC_PROC_UNDEFINEDErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 8) )
                  {
                      nNotFound = ERRCODE_BASIC_VAR_UNDEFINEDErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 35 );
                  }
              }
              if( bFatalError )
              {
                  // #39108 use dummy variable instead of fatal error
                  if( !xDummyVar.is() )
                  {
                      xDummyVar = new SbxVariable( SbxVARIANT );
                  }
                  pElem = xDummyVar.get();

                  ClearArgvStack();

                  Error( nNotFound, aName );
              }
              else
              {
                  if ( bStatic )
                  {
                      pElem = StepSTATIC_Impl( aName, t, 0 );
                  }
                  if ( !pElem )
                  {
                      pElem = new SbxVariable( t );
                      if( t != SbxVARIANT )
                      {
                          pElem->SetFlag( SbxFlagBits::Fixed );
                      }
                      pElem->SetName( aName );
                      refLocals->Put32( pElem, refLocals->Count32() );
                  }
              }
          }
      }
      // #39108 Args can already be deleted!
      if( !bFatalError )
      {
          SetupArgs( pElem, nOp1 );
      }
      // because a particular call-type is requested
      if (SbxMethod* pMethod = dynamic_cast<SbxMethod*>(pElem))
      {
          // shall the type be converted?
          SbxDataType t2 = pElem->GetType();
          bool bSet = false;
          if( (pElem->GetFlags() & SbxFlagBits::Fixed) == SbxFlagBits::NONE )
          {
              if( t != SbxVARIANT && t != t2 &&
                  t >= SbxINTEGER && t <= SbxSTRING )
              {
                  pElem->SetType( t );
                  bSet = true;
              }
          }
          // assign pElem to a Ref, to delete a temp-var if applicable
          SbxVariableRef xDeleteRef = pElem;

          // remove potential rests of the last call of the SbxMethod
          // free Write before, so that there's no error
          SbxFlagBits nSavFlags = pElem->GetFlags();
          pElem->SetFlag( SbxFlagBits::ReadWrite | SbxFlagBits::NoBroadcast );
          pElem->SbxValue::Clear();
          pElem->SetFlags( nSavFlags );

          // don't touch before setting, as e. g. LEFT()
          // has to know the difference between Left$() and Left()

          // because the methods' parameters are cut away in PopVar()
          SbxVariable* pNew = new SbxMethod(*pMethod);
          //OLD: SbxVariable* pNew = new SbxVariable( *pElem );

          pElem->SetParameters(nullptr);
          pNew->SetFlag( SbxFlagBits::ReadWrite );

          if( bSet )
          {
              pElem->SetType( t2 );
          }
          pElem = pNew;
      }
      // consider index-access for UnoObjects
      // definitely we want this for VBA where properties are often
      // collections ( which need index access ), but lets only do
      // this if we actually have params following
      else if( bVBAEnabled && dynamic_cast<const SbUnoProperty*>( pElem) != nullptr && pElem->GetParameters() )
      {
          SbxVariableRef xDeleteRef = pElem;

          // dissolve the notify while copying variable
          SbxVariable* pNew = new SbxVariable( *pElem );
          pElem->SetParameters( nullptr );
          pElem = pNew;
      }
  }
  return CheckArray( pElem );
3612}

3614// for current scope (e. g. query from BASIC-IDE)
3615SbxBase* SbiRuntime::FindElementExtern( const OUString& rName )
3616{
  // don't expect pMeth to be != 0, as there are none set
  // in the RunInit yet

  SbxVariable* pElem = nullptr;
  if( !pMod || rName.isEmpty() )
  {
      return nullptr;
  }
  if( refLocals.is() )
  {
      pElem = refLocals->Find( rName, SbxClassType::DontCare );
  }
  if ( !pElem && pMeth )
  {
      // for statics, set the method's name in front
      OUString aMethName = pMeth->GetName() + ":" + rName;
      pElem = pMod->Find(aMethName, SbxClassType::DontCare);
  }

  // search in parameter list
  if( !pElem && pMeth )
  {
      SbxInfo* pInfo = pMeth->GetInfo();
      if( pInfo && refParams.is() )
      {
          sal_uInt32 nParamCount = refParams->Count32();
          assert(nParamCount <= std::numeric_limits<sal_uInt16>::max())(static_cast <bool> (nParamCount <= std::numeric_limits
<sal_uInt16>::max()) ? void (0) : __assert_fail ("nParamCount <= std::numeric_limits<sal_uInt16>::max()"
, "/home/maarten/src/libreoffice/core/basic/source/runtime/runtime.cxx"
, 3643, __extension__ __PRETTY_FUNCTION__));
          sal_uInt16 j = 1;
          const SbxParamInfo* pParam = pInfo->GetParam( j );
          while( pParam )
          {
              if( pParam->aName.equalsIgnoreAsciiCase( rName ) )
              {
                  if( j >= nParamCount )
                  {
                      // Parameter is missing
                      pElem = new SbxVariable( SbxSTRING );
                      pElem->PutString( "<missing parameter>");
                  }
                  else
                  {
                      pElem = refParams->Get32( j );
                  }
                  break;
              }
              pParam = pInfo->GetParam( ++j );
          }
      }
  }

  // search in module
  if( !pElem )
  {
      bool bSave = rBasic.bNoRtl;
      rBasic.bNoRtl = true;
      pElem = pMod->Find( rName, SbxClassType::DontCare );
      rBasic.bNoRtl = bSave;
  }
  return pElem;
3676}


3679void SbiRuntime::SetupArgs( SbxVariable* p, sal_uInt32 nOp1 )
3680{
  if( nOp1 & 0x8000 )
  {
      if( !refArgv.is() )
      {
          StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
      }
      bool bHasNamed = false;
      sal_uInt32 i;
      sal_uInt32 nArgCount = refArgv->Count32();
      for( i = 1 ; i < nArgCount ; i++ )
      {
          if( !refArgv->GetAlias32(i).isEmpty() )
          {
              bHasNamed = true; break;
          }
      }
      if( bHasNamed )
      {
          SbxInfo* pInfo = p->GetInfo();
          if( !pInfo )
          {
              bool bError_ = true;

              SbUnoMethod* pUnoMethod = dynamic_cast<SbUnoMethod*>( p );
              SbUnoProperty* pUnoProperty = dynamic_cast<SbUnoProperty*>( p );
              if( pUnoMethod || pUnoProperty )
              {
                  SbUnoObject* pParentUnoObj = dynamic_cast<SbUnoObject*>( p->GetParent()  );
                  if( pParentUnoObj )
                  {
                      Any aUnoAny = pParentUnoObj->getUnoAny();
                      Reference< XInvocation > xInvocation;
                      aUnoAny >>= xInvocation;
                      if( xInvocation.is() )  // TODO: if( xOLEAutomation.is() )
                      {
                          bError_ = false;

                          sal_uInt32 nCurPar = 1;
                          AutomationNamedArgsSbxArray* pArg =
                              new AutomationNamedArgsSbxArray( nArgCount );
                          OUString* pNames = pArg->getNames().getArray();
                          for( i = 1 ; i < nArgCount ; i++ )
                          {
                              SbxVariable* pVar = refArgv->Get32( i );
                              OUString aName = refArgv->GetAlias32(i);
                              if (!aName.isEmpty())
                              {
                                  pNames[i] = aName;
                              }
                              pArg->Put32( pVar, nCurPar++ );
                          }
                          refArgv = pArg;
                      }
                  }
              }
              else if( bVBAEnabled && p->GetType() == SbxOBJECT && (dynamic_cast<const SbxMethod*>( p) == nullptr || !p->IsBroadcaster()) )
              {
                  // Check for default method with named parameters
                  SbxBaseRef xObj = p->GetObject();
                  if (SbUnoObject* pUnoObj = dynamic_cast<SbUnoObject*>( xObj.get() ))
                  {
                      Any aAny = pUnoObj->getUnoAny();

                      if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE )
                      {
                          Reference< XDefaultMethod > xDfltMethod( aAny, UNO_QUERY );

                          OUString sDefaultMethod;
                          if ( xDfltMethod.is() )
                          {
                              sDefaultMethod = xDfltMethod->getDefaultMethodName();
                          }
                          if ( !sDefaultMethod.isEmpty() )
                          {
                              SbxVariable* meth = pUnoObj->Find( sDefaultMethod, SbxClassType::Method );
                              if( meth != nullptr )
                              {
                                  pInfo = meth->GetInfo();
                              }
                              if( pInfo )
                              {
                                  bError_ = false;
                              }
                          }
                      }
                  }
              }
              if( bError_ )
              {
                  Error( ERRCODE_BASIC_NO_NAMED_ARGSErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 24) );
              }
          }
          else
          {
              sal_uInt32 nCurPar = 1;
              SbxArray* pArg = new SbxArray;
              for( i = 1 ; i < nArgCount ; i++ )
              {
                  SbxVariable* pVar = refArgv->Get32( i );
                  OUString aName = refArgv->GetAlias32(i);
                  if (!aName.isEmpty())
                  {
                      // nCurPar is set to the found parameter
                      sal_uInt16 j = 1;
                      const SbxParamInfo* pParam = pInfo->GetParam( j );
                      while( pParam )
                      {
                          if( pParam->aName.equalsIgnoreAsciiCase( aName ) )
                          {
                              nCurPar = j;
                              break;
                          }
                          pParam = pInfo->GetParam( ++j );
                      }
                      if( !pParam )
                      {
                          Error( ERRCODE_BASIC_NAMED_NOT_FOUNDErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 26) ); break;
                      }
                  }
                  pArg->Put32( pVar, nCurPar++ );
              }
              refArgv = pArg;
          }
      }
      // own var as parameter 0
      refArgv->Put32( p, 0 );
      p->SetParameters( refArgv.get() );
      PopArgv();
  }
  else
  {
      p->SetParameters( nullptr );
  }
3814}

3816// getting an array element

3818SbxVariable* SbiRuntime::CheckArray( SbxVariable* pElem )
3819{
  SbxArray* pPar;
  if( ( pElem->GetType() & SbxARRAY ) && refRedim.get() != pElem )
  {
      SbxBase* pElemObj = pElem->GetObject();
      SbxDimArray* pDimArray = dynamic_cast<SbxDimArray*>( pElemObj );
      pPar = pElem->GetParameters();
      if( pDimArray )
      {
          // parameters may be missing, if an array is
          // passed as an argument
          if( pPar )
              pElem = pDimArray->Get( pPar );
      }
      else
      {
          SbxArray* pArray = dynamic_cast<SbxArray*>( pElemObj );
          if( pArray )
          {
              if( !pPar )
              {
                  Error( ERRCODE_BASIC_OUT_OF_RANGEErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 4) );
                  pElem = new SbxVariable;
              }
              else
              {
                  pElem = pArray->Get32( pPar->Get32( 1 )->GetInteger() );
              }
          }
      }

      // #42940, set parameter 0 to NULL so that var doesn't contain itself
      if( pPar )
      {
          pPar->Put32( nullptr, 0 );
      }
  }
  // consider index-access for UnoObjects
  else if( pElem->GetType() == SbxOBJECT &&
          dynamic_cast<const SbxMethod*>( pElem) == nullptr &&
          ( !bVBAEnabled || dynamic_cast<const SbxProperty*>( pElem) == nullptr ) )
  {
      pPar = pElem->GetParameters();
      if ( pPar )
      {
          // is it a uno-object?
          SbxBaseRef pObj = pElem->GetObject();
          if( pObj.is() )
          {
              if (SbUnoObject* pUnoObj = dynamic_cast<SbUnoObject*>( pObj.get()))
              {
                  Any aAny = pUnoObj->getUnoAny();

                  if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE )
                  {
                      Reference< XIndexAccess > xIndexAccess( aAny, UNO_QUERY );
                      if ( !bVBAEnabled )
                      {
                          if( xIndexAccess.is() )
                          {
                              sal_uInt32 nParamCount = pPar->Count32() - 1;
                              if( nParamCount != 1 )
                              {
                                  StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENTErrCode( ErrCodeArea::Sbx, ErrCodeClass::NotSupported, 2) );
                                  return pElem;
                              }

                              // get index
                              sal_Int32 nIndex = pPar->Get32( 1 )->GetLong();
                              Reference< XInterface > xRet;
                              try
                              {
                                  Any aAny2 = xIndexAccess->getByIndex( nIndex );
                                  aAny2 >>= xRet;
                              }
                              catch (const IndexOutOfBoundsException&)
                              {
                                  // usually expect converting problem
                                  StarBASIC::Error( ERRCODE_BASIC_OUT_OF_RANGEErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 4) );
                              }

                              // #57847 always create a new variable, else error
                              // due to PutObject(NULL) at ReadOnly-properties
                              pElem = new SbxVariable( SbxVARIANT );
                              if( xRet.is() )
                              {
                                  aAny <<= xRet;

                                  // #67173 don't specify a name so that the real class name is entered
                                  SbxObjectRef xWrapper = static_cast<SbxObject*>(new SbUnoObject( OUString(), aAny ));
                                  pElem->PutObject( xWrapper.get() );
                              }
                              else
                              {
                                  pElem->PutObject( nullptr );
                              }
                          }
                      }
                      else
                      {
                          // check if there isn't a default member between the current variable
                          // and the params, e.g.
                          //   Dim rst1 As New ADODB.Recordset
                          //      "
                          //   val = rst1("FirstName")
                          // has the default 'Fields' member between rst1 and '("FirstName")'
                          Any x = aAny;
                          SbxVariable* pDflt = getDefaultProp( pElem );
                          if ( pDflt )
                          {
                              pDflt->Broadcast( SfxHintId::BasicDataWanted );
                              SbxBaseRef pDfltObj = pDflt->GetObject();
                              if( pDfltObj.is() )
                              {
                                  if (SbUnoObject* pSbObj = dynamic_cast<SbUnoObject*>(pDfltObj.get()))
                                  {
                                      pUnoObj = pSbObj;
                                      Any aUnoAny = pUnoObj->getUnoAny();

                                      if( aUnoAny.getValueType().getTypeClass() == TypeClass_INTERFACE )
                                          x = aUnoAny;
                                      pElem = pDflt;
                                  }
                              }
                          }
                          OUString sDefaultMethod;

                          Reference< XDefaultMethod > xDfltMethod( x, UNO_QUERY );

                          if ( xDfltMethod.is() )
                          {
                              sDefaultMethod = xDfltMethod->getDefaultMethodName();
                          }
                          else if( xIndexAccess.is() )
                          {
                              sDefaultMethod = "getByIndex";
                          }
                          if ( !sDefaultMethod.isEmpty() )
                          {
                              SbxVariable* meth = pUnoObj->Find( sDefaultMethod, SbxClassType::Method );
                              SbxVariableRef refTemp = meth;
                              if ( refTemp.is() )
                              {
                                  meth->SetParameters( pPar );
                                  SbxVariable* pNew = new SbxMethod( *static_cast<SbxMethod*>(meth) );
                                  pElem = pNew;
                              }
                          }
                      }
                  }

                  // #42940, set parameter 0 to NULL so that var doesn't contain itself
                  pPar->Put32( nullptr, 0 );
              }
              else if (BasicCollection* pCol = dynamic_cast<BasicCollection*>(pObj.get()))
              {
                  pElem = new SbxVariable( SbxVARIANT );
                  pPar->Put32( pElem, 0 );
                  pCol->CollItem( pPar );
              }
          }
          else if( bVBAEnabled )  // !pObj
          {
              SbxArray* pParam = pElem->GetParameters();
              if( pParam != nullptr && !pElem->IsSet( SbxFlagBits::VarToDim ) )
              {
                  Error( ERRCODE_BASIC_NO_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 10) );
              }
          }
      }
  }

  return pElem;
3992}

3994// loading an element from the runtime-library (+StringID+type)

3996void SbiRuntime::StepRTL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
3997{
  PushVar( FindElement( rBasic.pRtl.get(), nOp1, nOp2, ERRCODE_BASIC_PROC_UNDEFINEDErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 8), false ) );
3999}

4001void SbiRuntime::StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2,
                              ErrCode nNotFound, bool bStatic )
4003{
  if( !refLocals.is() )
  {
      refLocals = new SbxArray;
  }
  PushVar( FindElement( pObj, nOp1, nOp2, nNotFound, true/*bLocal*/, bStatic ) );
4009}
4010// loading a local/global variable (+StringID+type)

4012void SbiRuntime::StepFIND( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4013{
  StepFIND_Impl( pMod, nOp1, nOp2, ERRCODE_BASIC_PROC_UNDEFINEDErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 8) );
4015}

4017// Search inside a class module (CM) to enable global search in time
4018void SbiRuntime::StepFIND_CM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4019{

  SbClassModuleObject* pClassModuleObject = dynamic_cast<SbClassModuleObject*>( pMod );
  if( pClassModuleObject )
  {
      pMod->SetFlag( SbxFlagBits::GlobalSearch );
  }
  StepFIND_Impl( pMod, nOp1, nOp2, ERRCODE_BASIC_PROC_UNDEFINEDErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 8));

  if( pClassModuleObject )
  {
      pMod->ResetFlag( SbxFlagBits::GlobalSearch );
  }
4032}

4034void SbiRuntime::StepFIND_STATIC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4035{
  StepFIND_Impl( pMod, nOp1, nOp2, ERRCODE_BASIC_PROC_UNDEFINEDErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 8), true );
4037}

4039// loading an object-element (+StringID+type)
4040// the object lies on TOS

4042void SbiRuntime::StepELEM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4043{
  SbxVariableRef pObjVar = PopVar();

  SbxObject* pObj = dynamic_cast<SbxObject*>( pObjVar.get() );
  if( !pObj )
  {
      SbxBase* pObjVarObj = pObjVar->GetObject();
      pObj = dynamic_cast<SbxObject*>( pObjVarObj );
  }

  // #56368 save reference at StepElem, otherwise objects could
  // lose their reference too early in qualification chains like
  // ActiveComponent.Selection(0).Text
  // #74254 now per list
  if( pObj )
  {
      aRefSaved.emplace_back(pObj );
  }
  PushVar( FindElement( pObj, nOp1, nOp2, ERRCODE_BASIC_NO_METHODErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 18), false ) );
4062}

4064/** Loading of a parameter (+offset+type)
  If the data type is wrong, create a copy and search for optionals including
  the default value. The data type SbxEMPTY shows that no parameters are given.
  Get( 0 ) may be EMPTY

  @param nOp1
  the index of the current parameter being processed,
  where the entry of the index 0 is for the return value.

  @param nOp2
  the data type of the parameter.
*/
4076void SbiRuntime::StepPARAM( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4077{
  sal_uInt16 nIdx = static_cast<sal_uInt16>( nOp1 & 0x7FFF );
  SbxDataType eType = static_cast<SbxDataType>(nOp2);
  SbxVariable* pVar;

  // #57915 solve missing in a cleaner way
  sal_uInt32 nParamCount = refParams->Count32();
  if( nIdx >= nParamCount )
  {
      sal_uInt16 iLoop = nIdx;
      while( iLoop >= nParamCount )
      {
          pVar = new SbxVariable();
          pVar->PutErr( 448 );       // like in VB: Error-Code 448 (ERRCODE_BASIC_NAMED_NOT_FOUND)
          // tdf#79426, tdf#125180 - add additional information about a missing parameter
          SetIsMissing( pVar );
          refParams->Put32( pVar, iLoop );
          iLoop--;
      }
  }
  pVar = refParams->Get32( nIdx );

  // tdf#79426, tdf#125180 - check for optionals only if the parameter is actually missing
  if( pVar->GetType() == SbxERROR && IsMissing( pVar, 1 ) && nIdx )
  {
      // if there's a parameter missing, it can be OPTIONAL
      bool bOpt = false;
      if( pMeth )
      {
          SbxInfo* pInfo = pMeth->GetInfo();
          if ( pInfo )
          {
              const SbxParamInfo* pParam = pInfo->GetParam( nIdx );
              if( pParam && ( pParam->nFlags & SbxFlagBits::Optional ) )
              {
                  // tdf#136143 - reset SbxFlagBits::Fixed in order to prevent type conversion errors
                  pVar->ResetFlag( SbxFlagBits::Fixed );
                  // Default value?
                  sal_uInt16 nDefaultId = static_cast<sal_uInt16>(pParam->nUserData & 0x0ffff);
                  if( nDefaultId > 0 )
                  {
                      OUString aDefaultStr = pImg->GetString( nDefaultId );
                      pVar = new SbxVariable(pParam-> eType);
                      pVar->PutString( aDefaultStr );
                      refParams->Put32( pVar, nIdx );
                  }
                  else if ( SbiRuntime::isVBAEnabled() && eType != SbxVARIANT )
                  {
                      // tdf#36737 - initialize the parameter with the default value of its type
                      pVar = new SbxVariable( pParam->eType );
                      refParams->Put32( pVar, nIdx );
                  }
                  bOpt = true;
              }
          }
      }
      if( !bOpt )
      {
          Error( ERRCODE_BASIC_NOT_OPTIONALErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 27) );
      }
  }
  else if( eType != SbxVARIANT && static_cast<SbxDataType>(pVar->GetType() & 0x0FFF ) != eType )
  {
      SbxVariable* q = new SbxVariable( eType );
      aRefSaved.emplace_back(q );
      *q = *pVar;
      pVar = q;
      if ( nIdx )
      {
          refParams->Put32( pVar, nIdx );
      }
  }
  SetupArgs( pVar, nOp1 );
  PushVar( CheckArray( pVar ) );
4151}

4153// Case-Test (+True-Target+Test-Opcode)

4155void SbiRuntime::StepCASEIS( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4156{
  if( !refCaseStk.is() || !refCaseStk->Count32() )
  {
      StarBASIC::FatalError( ERRCODE_BASIC_INTERNAL_ERRORErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) );
  }
  else
  {
      SbxVariableRef xComp = PopVar();
      SbxVariableRef xCase = refCaseStk->Get32( refCaseStk->Count32() - 1 );
      if( xCase->Compare( static_cast<SbxOperator>(nOp2), *xComp ) )
      {
          StepJUMP( nOp1 );
      }
  }
4170}

4172// call of a DLL-procedure (+StringID+type)
4173// the StringID's MSB shows that Argv is occupied

4175void SbiRuntime::StepCALL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4176{
  OUString aName = pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) );
  SbxArray* pArgs = nullptr;
  if( nOp1 & 0x8000 )
  {
      pArgs = refArgv.get();
  }
  DllCall( aName, aLibName, pArgs, static_cast<SbxDataType>(nOp2), false );
  aLibName.clear();
  if( nOp1 & 0x8000 )
  {
      PopArgv();
  }
4189}

4191// call of a DLL-procedure after CDecl (+StringID+type)

4193void SbiRuntime::StepCALLC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4194{
  OUString aName = pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) );
  SbxArray* pArgs = nullptr;
  if( nOp1 & 0x8000 )
  {
      pArgs = refArgv.get();
  }
  DllCall( aName, aLibName, pArgs, static_cast<SbxDataType>(nOp2), true );
  aLibName.clear();
  if( nOp1 & 0x8000 )
  {
      PopArgv();
  }
4207}


4210// beginning of a statement (+Line+Col)

4212void SbiRuntime::StepSTMNT( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4213{
  // If the Expr-Stack at the beginning of a statement contains a variable,
  // some fool has called X as a function, although it's a variable!
  bool bFatalExpr = false;
  OUString sUnknownMethodName;
  if( nExprLvl > 1 )
  {
      bFatalExpr = true;
  }
  else if( nExprLvl )
  {
      SbxVariable* p = refExprStk->Get32( 0 );
      if( p->GetRefCount() > 1 &&
          refLocals.is() && refLocals->Find( p->GetName(), p->GetClass() ) )
      {
          sUnknownMethodName = p->GetName();
          bFatalExpr = true;
      }
  }

  ClearExprStack();

  aRefSaved.clear();

  // We have to cancel hard here because line and column
  // would be wrong later otherwise!
  if( bFatalExpr)
  {
      StarBASIC::FatalError( ERRCODE_BASIC_NO_METHODErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 18), sUnknownMethodName );
      return;
  }
  pStmnt = pCode - 9;
  sal_uInt16 nOld = nLine;
  nLine = static_cast<short>( nOp1 );

  // #29955 & 0xFF, to filter out for-loop-level
  nCol1 = static_cast<short>( nOp2 & 0xFF );

  // find the next STMNT-command to set the final column
  // of this statement

  nCol2 = 0xffff;
  sal_uInt16 n1, n2;
  const sal_uInt8* p = pMod->FindNextStmnt( pCode, n1, n2 );
  if( p )
  {
      if( n1 == nOp1 )
      {
          // #29955 & 0xFF, to filter out for-loop-level
          nCol2 = (n2 & 0xFF) - 1;
      }
  }

  // #29955 correct for-loop-level, #67452 NOT in the error-handler
  if( !bInError )
  {
      // (there's a difference here in case of a jump out of a loop)
      sal_uInt16 nExpectedForLevel = static_cast<sal_uInt16>( nOp2 / 0x100 );
      if( !pGosubStk.empty() )
      {
          nExpectedForLevel = nExpectedForLevel + pGosubStk.back().nStartForLvl;
      }

      // if the actual for-level is too small it'd jump out
      // of a loop -> corrected
      while( nForLvl > nExpectedForLevel )
      {
          PopFor();
      }
  }

  // 16.10.96: #31460 new concept for StepInto/Over/Out
  // see explanation at _ImplGetBreakCallLevel
  if( pInst->nCallLvl <= pInst->nBreakCallLvl )
  {
      StarBASIC* pStepBasic = GetCurrentBasic( &rBasic );
      BasicDebugFlags nNewFlags = pStepBasic->StepPoint( nLine, nCol1, nCol2 );

      pInst->CalcBreakCallLevel( nNewFlags );
  }

  // break points only at STMNT-commands in a new line!
  else if( ( nOp1 != nOld )
      && ( nFlags & BasicDebugFlags::Break )
      && pMod->IsBP( static_cast<sal_uInt16>( nOp1 ) ) )
  {
      StarBASIC* pBreakBasic = GetCurrentBasic( &rBasic );
      BasicDebugFlags nNewFlags = pBreakBasic->BreakPoint( nLine, nCol1, nCol2 );

      pInst->CalcBreakCallLevel( nNewFlags );
  }
4304}

4306// (+StreamMode+Flags)
4307// Stack: block length
4308//        channel number
4309//        file name

4311void SbiRuntime::StepOPEN( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4312{
  SbxVariableRef pName = PopVar();
  SbxVariableRef pChan = PopVar();
  SbxVariableRef pLen  = PopVar();
  short nBlkLen = pLen->GetInteger();
  short nChan   = pChan->GetInteger();
  OString aName(OUStringToOString(pName->GetOUString(), osl_getThreadTextEncoding()));
  pIosys->Open( nChan, aName, static_cast<StreamMode>( nOp1 ),
                static_cast<SbiStreamFlags>( nOp2 ), nBlkLen );
  Error( pIosys->GetError() );
4322}

4324// create object (+StringID+StringID)

4326void SbiRuntime::StepCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4327{
  OUString aClass( pImg->GetString( static_cast<short>( nOp2 ) ) );
  SbxObject *pObj = SbxBase::CreateObject( aClass );
  if( !pObj )
  {
      Error( ERRCODE_BASIC_INVALID_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 17) );
  }
  else
  {
      OUString aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
      pObj->SetName( aName );
      // the object must be able to call the BASIC
      pObj->SetParent( &rBasic );
      SbxVariable* pNew = new SbxVariable;
      pNew->PutObject( pObj );
      PushVar( pNew );
  }
4344}

4346void SbiRuntime::StepDCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4347{
  StepDCREATE_IMPL( nOp1, nOp2 );
4349}

4351void SbiRuntime::StepDCREATE_REDIMP( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4352{
  StepDCREATE_IMPL( nOp1, nOp2 );
4354}

4356// #56204 create object array (+StringID+StringID), DCREATE == Dim-Create
4357void SbiRuntime::StepDCREATE_IMPL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4358{
  SbxVariableRef refVar = PopVar();

  DimImpl( refVar );

  // fill the array with instances of the requested class
  SbxBase* pObj = refVar->GetObject();
  if (!pObj)
  {
      StarBASIC::Error( ERRCODE_BASIC_INVALID_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 17) );
      return;
  }

  SbxDimArray* pArray = dynamic_cast<SbxDimArray*>(pObj);
  if (!pArray)
      return;

  const sal_Int32 nDims = pArray->GetDims32();
  sal_Int32 nTotalSize = nDims > 0 ? 1 : 0;

  // must be a one-dimensional array
  sal_Int32 nLower, nUpper;
  for( sal_Int32 i = 0 ; i < nDims ; ++i )
  {
      pArray->GetDim32( i+1, nLower, nUpper );
      const sal_Int32 nSize = nUpper - nLower + 1;
      nTotalSize *= nSize;
  }

  // Optimization: pre-allocate underlying container
  if (nTotalSize > 0)
      pArray->SbxArray::GetRef32(nTotalSize - 1);

  // First, fill those parts of the array that are preserved
  bool bWasError = false;
  const bool bRestored = implRestorePreservedArray(pArray, refRedimpArray, &bWasError);
  if (bWasError)
      nTotalSize = 0; // on error, don't create objects

  // create objects and insert them into the array
  OUString aClass( pImg->GetString( static_cast<short>( nOp2 ) ) );
  OUString aName;
  for( sal_Int32 i = 0 ; i < nTotalSize ; ++i )
  {
      if (!bRestored || !pArray->SbxArray::GetRef32(i)) // For those left unset after preserve
      {
          SbxObject* pClassObj = SbxBase::CreateObject(aClass);
          if (!pClassObj)
          {
              Error(ERRCODE_BASIC_INVALID_OBJECTErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 17));
              break;
          }
          else
          {
              if (aName.isEmpty())
                  aName = pImg->GetString(static_cast<short>(nOp1));
              pClassObj->SetName(aName);
              // the object must be able to call the basic
              pClassObj->SetParent(&rBasic);
              pArray->SbxArray::Put32(pClassObj, i);
          }
      }
  }
4421}

4423void SbiRuntime::StepTCREATE( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4424{
  OUString aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
  OUString aClass( pImg->GetString( static_cast<short>( nOp2 ) ) );

  SbxObject* pCopyObj = createUserTypeImpl( aClass );
  if( pCopyObj )
  {
      pCopyObj->SetName( aName );
  }
  SbxVariable* pNew = new SbxVariable;
  pNew->PutObject( pCopyObj );
  pNew->SetDeclareClassName( aClass );
  PushVar( pNew );
4437}

4439void SbiRuntime::implHandleSbxFlags( SbxVariable* pVar, SbxDataType t, sal_uInt32 nOp2 )
4440{
  bool bWithEvents = ((t & 0xff) == SbxOBJECT && (nOp2 & SBX_TYPE_WITH_EVENTS_FLAG) != 0);
  if( bWithEvents )
  {
      pVar->SetFlag( SbxFlagBits::WithEvents );
  }
  bool bDimAsNew = ((nOp2 & SBX_TYPE_DIM_AS_NEW_FLAG) != 0);
  if( bDimAsNew )
  {
      pVar->SetFlag( SbxFlagBits::DimAsNew );
  }
  bool bFixedString = ((t & 0xff) == SbxSTRING && (nOp2 & SBX_FIXED_LEN_STRING_FLAG) != 0);
  if( bFixedString )
  {
      sal_uInt16 nCount = static_cast<sal_uInt16>( nOp2 >> 17 );      // len = all bits above 0x10000
      OUStringBuffer aBuf;
      comphelper::string::padToLength(aBuf, nCount);
      pVar->PutString(aBuf.makeStringAndClear());
  }

  bool bVarToDim = ((nOp2 & SBX_TYPE_VAR_TO_DIM_FLAG) != 0);
  if( bVarToDim )
  {
      pVar->SetFlag( SbxFlagBits::VarToDim );
  }
4465}

4467// establishing a local variable (+StringID+type)

4469void SbiRuntime::StepLOCAL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4470{
  if( !refLocals.is() )
  {
      refLocals = new SbxArray;
  }
  OUString aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
  if( refLocals->Find( aName, SbxClassType::DontCare ) == nullptr )
  {
      SbxDataType t = static_cast<SbxDataType>(nOp2 & 0xffff);
      SbxVariable* p = new SbxVariable( t );
      p->SetName( aName );
      implHandleSbxFlags( p, t, nOp2 );
      refLocals->Put32( p, refLocals->Count32() );
  }
4484}

4486// establishing a module-global variable (+StringID+type)

4488void SbiRuntime::StepPUBLIC_Impl( sal_uInt32 nOp1, sal_uInt32 nOp2, bool bUsedForClassModule )
4489{
  OUString aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
  SbxDataType t = static_cast<SbxDataType>(nOp2 & 0xffff);
  bool bFlag = pMod->IsSet( SbxFlagBits::NoModify );
  pMod->SetFlag( SbxFlagBits::NoModify );
  SbxVariableRef p = pMod->Find( aName, SbxClassType::Property );
  if( p.is() )
  {
      pMod->Remove (p.get());
  }
  SbProperty* pProp = pMod->GetProperty( aName, t );
  if( !bUsedForClassModule )
  {
      pProp->SetFlag( SbxFlagBits::Private );
  }
  if( !bFlag )
  {
      pMod->ResetFlag( SbxFlagBits::NoModify );
  }
  if( pProp )
  {
      pProp->SetFlag( SbxFlagBits::DontStore );
      // from 2.7.1996: HACK because of 'reference can't be saved'
      pProp->SetFlag( SbxFlagBits::NoModify);

      implHandleSbxFlags( pProp, t, nOp2 );
  }
4516}

4518void SbiRuntime::StepPUBLIC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4519{
  StepPUBLIC_Impl( nOp1, nOp2, false );
4521}

4523void SbiRuntime::StepPUBLIC_P( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4524{
  // Creates module variable that isn't reinitialised when
  // between invocations ( for VBASupport & document basic only )
  if( pMod->pImage->bFirstInit )
  {
      bool bUsedForClassModule = pImg->IsFlag( SbiImageFlags::CLASSMODULE );
      StepPUBLIC_Impl( nOp1, nOp2, bUsedForClassModule );
  }
4532}

4534// establishing a global variable (+StringID+type)

4536void SbiRuntime::StepGLOBAL( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4537{
  if( pImg->IsFlag( SbiImageFlags::CLASSMODULE ) )
  {
      StepPUBLIC_Impl( nOp1, nOp2, true );
  }
  OUString aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
  SbxDataType t = static_cast<SbxDataType>(nOp2 & 0xffff);

  // Store module scope variables at module scope
  // in non vba mode these are stored at the library level :/
  // not sure if this really should not be enabled for ALL basic
  SbxObject* pStorage = &rBasic;
  if ( SbiRuntime::isVBAEnabled() )
  {
      pStorage = pMod;
      pMod->AddVarName( aName );
  }

  bool bFlag = pStorage->IsSet( SbxFlagBits::NoModify );
  rBasic.SetFlag( SbxFlagBits::NoModify );
  SbxVariableRef p = pStorage->Find( aName, SbxClassType::Property );
  if( p.is() )
  {
      pStorage->Remove (p.get());
  }
  p = pStorage->Make( aName, SbxClassType::Property, t );
  if( !bFlag )
  {
      pStorage->ResetFlag( SbxFlagBits::NoModify );
  }
  if( p.is() )
  {
      p->SetFlag( SbxFlagBits::DontStore );
      // from 2.7.1996: HACK because of 'reference can't be saved'
      p->SetFlag( SbxFlagBits::NoModify);
  }
4573}


4576// Creates global variable that isn't reinitialised when
4577// basic is restarted, P=PERSIST (+StringID+Typ)

4579void SbiRuntime::StepGLOBAL_P( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4580{
  if( pMod->pImage->bFirstInit )
  {
      StepGLOBAL( nOp1, nOp2 );
  }
4585}


4588// Searches for global variable, behavior depends on the fact
4589// if the variable is initialised for the first time

4591void SbiRuntime::StepFIND_G( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4592{
  if( pMod->pImage->bFirstInit )
  {
      // Behave like always during first init
      StepFIND( nOp1, nOp2 );
  }
  else
  {
      // Return dummy variable
      SbxDataType t = static_cast<SbxDataType>(nOp2);
      OUString aName( pImg->GetString( static_cast<short>( nOp1 & 0x7FFF ) ) );

      SbxVariable* pDummyVar = new SbxVariable( t );
      pDummyVar->SetName( aName );
      PushVar( pDummyVar );
  }
4608}


4611SbxVariable* SbiRuntime::StepSTATIC_Impl(
  OUString const & aName, SbxDataType t, sal_uInt32 nOp2 )
4613{
  SbxVariable* p = nullptr;
  if ( pMeth )
  {
      SbxArray* pStatics = pMeth->GetStatics();
      if( pStatics && ( pStatics->Find( aName, SbxClassType::DontCare ) == nullptr ) )
      {
          p = new SbxVariable( t );
          if( t != SbxVARIANT )
          {
              p->SetFlag( SbxFlagBits::Fixed );
          }
          p->SetName( aName );
          implHandleSbxFlags( p, t, nOp2 );
          pStatics->Put32( p, pStatics->Count32() );
      }
  }
  return p;
4631}
4632// establishing a static variable (+StringID+type)
4633void SbiRuntime::StepSTATIC( sal_uInt32 nOp1, sal_uInt32 nOp2 )
4634{
  OUString aName( pImg->GetString( static_cast<short>( nOp1 ) ) );
  SbxDataType t = static_cast<SbxDataType>(nOp2 & 0xffff);
  StepSTATIC_Impl( aName, t, nOp2 );
4638}

4640/* vim:set shiftwidth=4 softtabstop=4 expandtab: */