/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 192, column 9 Use of memory after it is freed

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 baside2.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 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/basctl/inc -I /home/maarten/src/libreoffice/core/basctl/sdi -I /home/maarten/src/libreoffice/core/basctl/source/inc -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/workdir/SdiTarget/basctl/sdi -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 -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/basctl/source/basicide/baside2.cxx

/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.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 "baside2.hxx"
21#include <baside3.hxx>
22#include <basobj.hxx>
23#include <basidesh.hxx>
24#include "brkdlg.hxx"
25#include <iderdll.hxx>
26#include <iderid.hxx>
27#include "moduldlg.hxx"
28#include <docsignature.hxx>
29#include <officecfg/Office/BasicIDE.hxx>

31#include <helpids.h>
32#include <strings.hrc>

34#include <basic/basmgr.hxx>
35#include <basic/basrdll.hxx>
36#include <basic/sbmeth.hxx>
37#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
38#include <com/sun/star/script/ModuleType.hpp>
39#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
40#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
41#include <com/sun/star/ui/dialogs/FilePicker.hpp>
42#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
43#include <comphelper/SetFlagContextHelper.hxx>
44#include <comphelper/string.hxx>
45#include <svl/srchdefs.hxx>
46#include <sfx2/bindings.hxx>
47#include <sfx2/docfile.hxx>
48#include <sfx2/request.hxx>
49#include <sfx2/viewfrm.hxx>
50#include <sot/exchange.hxx>
51#include <svl/eitem.hxx>
52#include <svl/srchitem.hxx>
53#include <svl/stritem.hxx>
54#include <svl/visitem.hxx>
55#include <svl/whiter.hxx>
56#include <svx/svxids.hrc>
57#include <tools/debug.hxx>
58#include <vcl/waitobj.hxx>
59#include <vcl/errinf.hxx>
60#include <vcl/event.hxx>
61#include <vcl/print.hxx>
62#include <vcl/svapp.hxx>
63#include <vcl/textview.hxx>
64#include <vcl/weld.hxx>
65#include <vcl/xtextedt.hxx>
66#include <toolkit/helper/vclunohelper.hxx>
67#include <cassert>
68#include <osl/diagnose.h>
69#include <officecfg/Office/Common.hxx>

71namespace basctl
72{

74namespace
75{

77namespace Print
78{
  long const nLeftMargin = 1700;
  long const nRightMargin = 900;
  long const nTopMargin = 2000;
  long const nBottomMargin = 1000;
  long const nBorder = 300;
84}

86short const ValidWindow = 0x1234;

88// What (who) are OW and MTF? Compare to baside3.cxx where an
89// identically named variable, used in the same way, has the value
90// "*.*" on Windows, "*" otherwise. Is that what should be done here,
91// too?

93#if defined(OW) || defined(MTF)
94char const FilterMask_All[] = "*";
95#else
96char const FilterMask_All[] = "*.*";
97#endif

99} // end anonymous namespace

101using namespace ::com::sun::star;
102using namespace ::com::sun::star::uno;
103using namespace ::com::sun::star::ui::dialogs;
104using namespace utl;
105using namespace comphelper;

107namespace
108{

110void lcl_PrintHeader( Printer* pPrinter, sal_uInt16 nPages, sal_uInt16 nCurPage, const OUString& rTitle, bool bOutput )
111{
  Size const aSz = pPrinter->GetOutputSize();

  const Color aOldLineColor( pPrinter->GetLineColor() );
  const Color aOldFillColor( pPrinter->GetFillColor() );
  const vcl::Font aOldFont( pPrinter->GetFont() );

  pPrinter->SetLineColor( COL_BLACK );
  pPrinter->SetFillColor();

  vcl::Font aFont( aOldFont );
  aFont.SetWeight( WEIGHT_BOLD );
  aFont.SetAlignment( ALIGN_BOTTOM );
  pPrinter->SetFont( aFont );

  long nFontHeight = pPrinter->GetTextHeight();

  // 1st Border => line, 2+3 Border = free space
  long nYTop = Print::nTopMargin - 3*Print::nBorder - nFontHeight;

  long nXLeft = Print::nLeftMargin - Print::nBorder;
  long nXRight = aSz.Width() - Print::nRightMargin + Print::nBorder;

  if( bOutput )
      pPrinter->DrawRect(tools::Rectangle(
          Point(nXLeft, nYTop),
          Size(nXRight - nXLeft, aSz.Height() - nYTop - Print::nBottomMargin + Print::nBorder)
      ));


  long nY = Print::nTopMargin - 2*Print::nBorder;
  Point aPos(Print::nLeftMargin, nY);
  if( bOutput )
      pPrinter->DrawText( aPos, rTitle );
  if ( nPages != 1 )
  {
      aFont.SetWeight( WEIGHT_NORMAL );
      pPrinter->SetFont( aFont );
      aPos.AdjustX(pPrinter->GetTextWidth( rTitle ) );

      if( bOutput )
      {
          OUString aPageStr = " [" + IDEResId(RID_STR_PAGEreinterpret_cast<char const *>("RID_STR_PAGE" "\004" u8"Page"
)) + " " + OUString::number( nCurPage ) + "]";
          pPrinter->DrawText( aPos, aPageStr );
      }
  }

  nY = Print::nTopMargin - Print::nBorder;

  if( bOutput )
      pPrinter->DrawLine( Point( nXLeft, nY ), Point( nXRight, nY ) );

  pPrinter->SetFont( aOldFont );
  pPrinter->SetFillColor( aOldFillColor );
  pPrinter->SetLineColor( aOldLineColor );
166}

168void lcl_ConvertTabsToSpaces( OUString& rLine )
169{
  if ( rLine.isEmpty() )
      return;

  OUStringBuffer aResult( rLine );
  sal_Int32 nPos = 0;
  sal_Int32 nMax = aResult.getLength();
  while ( nPos < nMax )
  {
      if ( aResult[nPos] == '\t' )
      {
          // not 4 Blanks, but at 4 TabPos:
          OUStringBuffer aBlanker;
          string::padToLength(aBlanker, ( 4 - ( nPos % 4 ) ), ' ');
          aResult.remove( nPos, 1 );
          aResult.insert( nPos, aBlanker.makeStringAndClear() );
          nMax = aResult.getLength();
      }
      ++nPos;
  }
  rLine = aResult.makeStringAndClear();
190}

192} // namespace

194ModulWindow::ModulWindow (ModulWindowLayout* pParent, ScriptDocument const& rDocument,
                        const OUString& aLibName, const OUString& aName, OUString const & aModule)
  : BaseWindow(pParent, rDocument, aLibName, aName)
  , m_rLayout(*pParent)
  , m_nValid(ValidWindow)
  , m_aXEditorWindow(VclPtr<ComplexEditorWindow>::Create(this))
  , m_aModule(aModule)
201{
  m_aXEditorWindow->Show();
  SetBackground();
204}

206SbModuleRef const & ModulWindow::XModule()
207{
  // ModuleWindows can now be created as a result of the
  // modules getting created via the api. This is a result of an
  // elementInserted event from the BasicLibrary container.
  // However the SbModule is also created from a different listener to
  // the same event ( in basmgr ) Therefore it is possible when we look
  // for m_xModule it may not yet be available, here we keep trying to access
  // the module until such time as it exists

  if ( !m_xModule.is() )
  {
      BasicManager* pBasMgr = GetDocument().getBasicManager();
      if ( pBasMgr )
      {
          StarBASIC* pBasic = pBasMgr->GetLib( GetLibName() );
          if ( pBasic )
          {
              m_xBasic = pBasic;
              m_xModule = pBasic->FindModule( GetName() );
          }
      }
  }
  return m_xModule;
230}

232ModulWindow::~ModulWindow()
233{
  disposeOnce();
235}

237void ModulWindow::dispose()
238{
  m_nValid = 0;
  StarBASIC::Stop();
  m_aXEditorWindow.disposeAndClear();
  BaseWindow::dispose();
243}


246void ModulWindow::GetFocus()
247{
  if (m_nValid != ValidWindow)
      return;
  m_aXEditorWindow->GetEdtWindow().GrabFocus();
  // don't call basic calls because focus is somewhere else...
252}

254void ModulWindow::DoInit()
255{
  if (GetVScrollBar())
      GetVScrollBar()->Hide();
  GetHScrollBar()->Show();
  GetEditorWindow().InitScrollBars();
260}

262void ModulWindow::Paint(vcl::RenderContext& /*rRenderContext*/, const tools::Rectangle&)
263{
264}

266void ModulWindow::Resize()
267{
  m_aXEditorWindow->SetPosSizePixel( Point( 0, 0 ), GetOutputSizePixel() );
269}

271void ModulWindow::CheckCompileBasic()
272{
  if ( !XModule().is() )
      return;

  // never compile while running!
  bool const bRunning = StarBASIC::IsRunning();
  bool const bModified = ( !m_xModule->IsCompiled() ||
      ( GetEditEngine() && GetEditEngine()->IsModified() ) );

  if ( bRunning || !bModified )
      return;

  bool bDone = false;

  GetShell()->GetViewFrame()->GetWindow().EnterWait();

  AssertValidEditEngine();
  GetEditorWindow().SetSourceInBasic();

  bool bWasModified = GetBasic()->IsModified();

  {
      // tdf#106529: only use strict compilation mode when compiling from the IDE
      css::uno::ContextLayer layer(comphelper::NewFlagContext("BasicStrict"));
      bDone = m_xModule->Compile();
  }
  if ( !bWasModified )
      GetBasic()->SetModified(false);

  if ( bDone )
  {
      GetBreakPoints().SetBreakPointsInBasic( m_xModule.get() );
  }

  GetShell()->GetViewFrame()->GetWindow().LeaveWait();

  m_aStatus.bError = !bDone;
  m_aStatus.bIsRunning = false;
310}

312void ModulWindow::BasicExecute()
313{
  // #116444# check security settings before macro execution
  ScriptDocument aDocument( GetDocument() );
  bool bMacrosDisabled = officecfg::Office::Common::Security::Scripting::DisableMacrosExecution::get();
  if (bMacrosDisabled || (aDocument.isDocument() && !aDocument.allowMacros()))
  {
      std::unique_ptr<weld::MessageDialog> xBox(
          Application::CreateMessageDialog(GetFrameWeld(), VclMessageType::Warning,
                                           VclButtonsType::Ok, IDEResId(RID_STR_CANNOTRUNMACROreinterpret_cast<char const *>("RID_STR_CANNOTRUNMACRO"
 "\004" u8"For security reasons, you cannot run this macro.\n\nFor more information, check the security settings."
))));
      xBox->run();
      return;
  }

  CheckCompileBasic();

  if ( !XModule().is() || !m_xModule->IsCompiled() || m_aStatus.bError )
      return;

  if ( GetBreakPoints().size() )
      m_aStatus.nBasicFlags = m_aStatus.nBasicFlags | BasicDebugFlags::Break;

  if ( !m_aStatus.bIsRunning )
  {
      DBG_ASSERT( m_xModule.is(), "No Module!" )do { if (true && (!(m_xModule.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
 ":" "336" ": "), "%s", "No Module!"); } } while (false);
      AddStatus( BASWIN_RUNNINGBASIC );
      sal_uInt16 nStart, nEnd;
      TextSelection aSel = GetEditView()->GetSelection();
      // Init cursor to top
      const sal_uInt32 nCurMethodStart = aSel.GetStart().GetPara() + 1;
      SbMethod* pMethod = nullptr;
      // first Macro, else blind "Main" (ExtSearch?)
      for ( sal_uInt32 nMacro = 0; nMacro < m_xModule->GetMethods()->Count32(); nMacro++ )
      {
          SbMethod* pM = static_cast<SbMethod*>(m_xModule->GetMethods()->Get32( nMacro ));
          assert(pM && "Method?")(static_cast <bool> (pM && "Method?") ? void (0
) : __assert_fail ("pM && \"Method?\"", "/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
, 347, __extension__ __PRETTY_FUNCTION__));
          pM->GetLineRange( nStart, nEnd );
          if (  nCurMethodStart >= nStart && nCurMethodStart <= nEnd )
          {
              // matched a method to the cursor position
              pMethod = pM;
              break;
          }
      }
      if ( !pMethod )
      {
          // If not in a method then prompt the user
          ChooseMacro(GetFrameWeld(), uno::Reference<frame::XModel>());
          return;
      }
      pMethod->SetDebugFlags(m_aStatus.nBasicFlags);
      BasicDLL::SetDebugMode(true);
      RunMethod(pMethod);
      BasicDLL::SetDebugMode(false);
      // if cancelled during Interactive=false
      BasicDLL::EnableBreak(true);
      ClearStatus( BASWIN_RUNNINGBASIC );
  }
  else
      m_aStatus.bIsRunning = false; // cancel of Reschedule()
372}

374void ModulWindow::CompileBasic()
375{
  CheckCompileBasic();

  XModule().is() && m_xModule->IsCompiled();
379}

381void ModulWindow::BasicRun()
382{
  m_aStatus.nBasicFlags = BasicDebugFlags::NONE;
  BasicExecute();
385}

387void ModulWindow::BasicStepOver()
388{
  m_aStatus.nBasicFlags = BasicDebugFlags::StepInto | BasicDebugFlags::StepOver;
  BasicExecute();
391}


394void ModulWindow::BasicStepInto()
395{
  m_aStatus.nBasicFlags = BasicDebugFlags::StepInto;
  BasicExecute();
398}

400void ModulWindow::BasicStepOut()
401{
  m_aStatus.nBasicFlags = BasicDebugFlags::StepOut;
  BasicExecute();
404}


407void ModulWindow::BasicStop()
408{
  StarBASIC::Stop();
  m_aStatus.bIsRunning = false;
411}

413void ModulWindow::LoadBasic()
414{
  Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
  Reference < XFilePicker3 > xFP = FilePicker::createWithMode(xContext, TemplateDescription::FILEOPEN_SIMPLE);

  if ( !m_sCurPath.isEmpty() )
      xFP->setDisplayDirectory ( m_sCurPath );

  xFP->appendFilter( "BASIC" , "*.bas" );
  xFP->appendFilter( IDEResId(RID_STR_FILTER_ALLFILESreinterpret_cast<char const *>("RID_STR_FILTER_ALLFILES"
 "\004" u8"<All>")), FilterMask_All );
  xFP->setCurrentFilter( "BASIC" );

  if( xFP->execute() != RET_OK )
      return;

  Sequence< OUString > aPaths = xFP->getSelectedFiles();
  m_sCurPath = aPaths[0];
  SfxMedium aMedium( m_sCurPath, StreamMode::READ | StreamMode::SHARE_DENYWRITE | StreamMode::NOCREATE );
  SvStream* pStream = aMedium.GetInStream();
  if ( pStream )
  {
      AssertValidEditEngine();
      sal_uInt32 nLines = CalcLineCount( *pStream );
      // nLines*4: ReadText/Formatting/Highlighting/Formatting
      GetEditorWindow().CreateProgress( IDEResId(RID_STR_GENERATESOURCEreinterpret_cast<char const *>("RID_STR_GENERATESOURCE"
 "\004" u8"Generating source")), nLines*4 );
      GetEditEngine()->SetUpdateMode( false );
      GetEditView()->Read( *pStream );
      GetEditEngine()->SetUpdateMode( true );
      GetEditorWindow().PaintImmediately();
      GetEditorWindow().ForceSyntaxTimeout();
      GetEditorWindow().DestroyProgress();
      ErrCode nError = aMedium.GetError();
      if ( nError )
          ErrorHandler::HandleError( nError );
  }
  else
  {
      std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrameWeld(),
                                                VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_COULDNTREADreinterpret_cast<char const *>("RID_STR_COULDNTREAD" "\004"
 u8"The file could not be read"))));
      xBox->run();
  }
454}


457void ModulWindow::SaveBasicSource()
458{
  Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
  Reference < XFilePicker3 > xFP = FilePicker::createWithMode(xContext, TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD);

  Reference< XFilePickerControlAccess > xFPControl(xFP, UNO_QUERY);
  xFPControl->enableControl(ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, false);
  Any aValue;
  aValue <<= true;
  xFPControl->setValue(ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0, aValue);

  if ( !m_sCurPath.isEmpty() )
      xFP->setDisplayDirectory ( m_sCurPath );

  xFP->appendFilter( "BASIC", "*.bas" );
  xFP->appendFilter( IDEResId(RID_STR_FILTER_ALLFILESreinterpret_cast<char const *>("RID_STR_FILTER_ALLFILES"
 "\004" u8"<All>")), FilterMask_All );
  xFP->setCurrentFilter( "BASIC" );

  if( xFP->execute() != RET_OK )
      return;

  Sequence< OUString > aPaths = xFP->getSelectedFiles();
  m_sCurPath = aPaths[0];
  SfxMedium aMedium( m_sCurPath, StreamMode::WRITE | StreamMode::SHARE_DENYWRITE | StreamMode::TRUNC );
  SvStream* pStream = aMedium.GetOutStream();
  if ( pStream )
  {
      EnterWait();
      AssertValidEditEngine();
      GetEditEngine()->Write( *pStream );
      aMedium.Commit();
      LeaveWait();
      ErrCode nError = aMedium.GetError();
      if ( nError )
          ErrorHandler::HandleError( nError );
  }
  else
  {
      std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(GetFrameWeld(),
                                                     VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_COULDNTWRITEreinterpret_cast<char const *>("RID_STR_COULDNTWRITE" "\004"
 u8"The file could not be saved"))));
      xErrorBox->run();
  }
499}

501void ModulWindow::ImportDialog()
502{
  const ScriptDocument& rDocument = GetDocument();
  OUString aLibName = GetLibName();
  implImportDialog(GetFrameWeld(), m_sCurPath, rDocument, aLibName);
506}

508void ModulWindow::ToggleBreakPoint( sal_uInt16 nLine )
509{
  DBG_ASSERT( XModule().is(), "No Module!" )do { if (true && (!(XModule().is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
 ":" "510" ": "), "%s", "No Module!"); } } while (false);

  if ( !XModule().is() )
      return;

  CheckCompileBasic();
  if ( m_aStatus.bError )
  {
      return;
  }

  BreakPoint* pBrk = GetBreakPoints().FindBreakPoint( nLine );
  if ( pBrk ) // remove
  {
      m_xModule->ClearBP( nLine );
      GetBreakPoints().remove( pBrk );
  }
  else // create one
  {
      if ( m_xModule->SetBP( nLine ))
      {
          GetBreakPoints().InsertSorted( BreakPoint( nLine ) );
          if ( StarBASIC::IsRunning() )
          {
              for ( sal_uInt32 nMethod = 0; nMethod < m_xModule->GetMethods()->Count32(); nMethod++ )
              {
                  SbMethod* pMethod = static_cast<SbMethod*>(m_xModule->GetMethods()->Get32( nMethod ));
                  assert(pMethod && "Method not found! (NULL)")(static_cast <bool> (pMethod && "Method not found! (NULL)"
) ? void (0) : __assert_fail ("pMethod && \"Method not found! (NULL)\""
, "/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
, 537, __extension__ __PRETTY_FUNCTION__));
                  pMethod->SetDebugFlags( pMethod->GetDebugFlags() | BasicDebugFlags::Break );
              }
          }
      }
  }
543}

545void ModulWindow::UpdateBreakPoint( const BreakPoint& rBrk )
546{
  DBG_ASSERT( XModule().is(), "No Module!" )do { if (true && (!(XModule().is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
 ":" "547" ": "), "%s", "No Module!"); } } while (false);

  if ( XModule().is() )
  {
      CheckCompileBasic();

      if ( rBrk.bEnabled )
          m_xModule->SetBP( rBrk.nLine );
      else
          m_xModule->ClearBP( rBrk.nLine );
  }
558}


561void ModulWindow::BasicToggleBreakPoint()
562{
  AssertValidEditEngine();

  TextSelection aSel = GetEditView()->GetSelection();
  aSel.GetStart().GetPara()++;    // Basic lines start at 1!
  aSel.GetEnd().GetPara()++;

  for ( sal_uInt32 nLine = aSel.GetStart().GetPara(); nLine <= aSel.GetEnd().GetPara(); ++nLine )
  {
      ToggleBreakPoint( nLine );
  }

  m_aXEditorWindow->GetBrkWindow().Invalidate();
575}


578void ModulWindow::BasicToggleBreakPointEnabled()
579{
  AssertValidEditEngine();

  TextView* pView = GetEditView();
  if ( !pView )
      return;

  TextSelection aSel = pView->GetSelection();
  BreakPointList& rList = GetBreakPoints();

  for ( sal_uInt32 nLine = ++aSel.GetStart().GetPara(), nEnd = ++aSel.GetEnd().GetPara(); nLine <= nEnd; ++nLine )
  {
      BreakPoint* pBrk = rList.FindBreakPoint( nLine );
      if ( pBrk )
      {
          pBrk->bEnabled = !pBrk->bEnabled;
          UpdateBreakPoint( *pBrk );
      }
  }

  GetBreakPointWindow().Invalidate();
600}

602void ModulWindow::ManageBreakPoints()
603{
  BreakPointWindow& rBrkWin = GetBreakPointWindow();
  BreakPointDialog aBrkDlg(rBrkWin.GetFrameWeld(), GetBreakPoints());
  aBrkDlg.run();
  rBrkWin.Invalidate();
608}

610void ModulWindow::BasicErrorHdl( StarBASIC const * pBasic )
611{
  GetShell()->GetViewFrame()->ToTop();

  // Return value: BOOL
  //  FALSE:  cancel
  //  TRUE:   go on...
  sal_uInt16 nErrorLine = StarBASIC::GetLine() - 1;
  sal_uInt16 nErrCol1 = StarBASIC::GetCol1();
  sal_uInt16 nErrCol2 = StarBASIC::GetCol2();
  if ( nErrCol2 != 0xFFFF )
      nErrCol2++;

  AssertValidEditEngine();
  GetEditView()->SetSelection( TextSelection( TextPaM( nErrorLine, nErrCol1 ), TextPaM( nErrorLine, nErrCol2 ) ) );

  // if other basic, the IDE should try to display the correct module
  bool const bMarkError = pBasic == GetBasic();
  if ( bMarkError )
      m_aXEditorWindow->GetBrkWindow().SetMarkerPos(nErrorLine, true);

  // #i47002#
  Reference< awt::XWindow > xWindow = VCLUnoHelper::GetInterface( this );

  // tdf#118572 make a currently running dialog, regardless of what its modal
  // to, insensitive to user input until after this error dialog goes away.
  TopLevelWindowLocker aBusy;
  aBusy.incBusy(nullptr);

  ErrorHandler::HandleError(StarBASIC::GetErrorCode(), GetFrameWeld());

  aBusy.decBusy();

  // #i47002#
  VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
  if ( !pWindow )
      return;

  if ( bMarkError )
      m_aXEditorWindow->GetBrkWindow().SetNoMarker();
  return;
651}

653BasicDebugFlags ModulWindow::BasicBreakHdl()
654{
  // Return value: sal_uInt16 => see SB-Debug-Flags
  sal_uInt16 nErrorLine = StarBASIC::GetLine();


  BreakPoint* pBrk = GetBreakPoints().FindBreakPoint( nErrorLine );
  if ( pBrk )
  {
      pBrk->nHitCount++;
      if ( pBrk->nHitCount <= pBrk->nStopAfter && GetBasic()->IsBreak() )
          return m_aStatus.nBasicFlags; // go on...
  }

  nErrorLine--;   // EditEngine starts at 0, Basic at 1

  AssertValidEditEngine();
  GetEditView()->SetSelection( TextSelection( TextPaM( nErrorLine, 0 ), TextPaM( nErrorLine, 0 ) ) );
  m_aXEditorWindow->GetBrkWindow().SetMarkerPos( nErrorLine );

  m_rLayout.UpdateDebug(false);

  m_aStatus.bIsInReschedule = true;
  m_aStatus.bIsRunning = true;

  AddStatus( BASWIN_INRESCHEDULE );

  InvalidateDebuggerSlots();

  while( m_aStatus.bIsRunning )
      Application::Yield();

  m_aStatus.bIsInReschedule = false;
  m_aXEditorWindow->GetBrkWindow().SetNoMarker();

  ClearStatus( BASWIN_INRESCHEDULE );

  return m_aStatus.nBasicFlags;
691}

693void ModulWindow::BasicAddWatch()
694{
  AssertValidEditEngine();
  bool bAdd = true;
  if ( !GetEditView()->HasSelection() )
  {
      // tdf#57307 - expand selection to include connector punctuations
      TextSelection aSel;
      OUString aWord = GetEditEngine()->GetWord( GetEditView()->GetSelection().GetEnd(), &aSel.GetStart(), &aSel.GetEnd() );
      if ( !aWord.isEmpty() )
          GetEditView()->SetSelection( aSel );
      else
          bAdd = false;
  }
  if ( bAdd )
  {
      TextSelection aSel = GetEditView()->GetSelection();
      if ( aSel.GetStart().GetPara() == aSel.GetEnd().GetPara() ) // single line selection
          m_rLayout.BasicAddWatch(GetEditView()->GetSelected());
  }
713}


716void ModulWindow::EditMacro( const OUString& rMacroName )
717{
  DBG_ASSERT( XModule().is(), "No Module!" )do { if (true && (!(XModule().is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
 ":" "718" ": "), "%s", "No Module!"); } } while (false);

  if ( !XModule().is() )
      return;

  CheckCompileBasic();

  if ( m_aStatus.bError )
      return;

  sal_uInt16 nStart, nEnd;
  SbMethod* pMethod = static_cast<SbMethod*>(m_xModule->Find( rMacroName, SbxClassType::Method ));
  if ( !pMethod )
      return;

  pMethod->GetLineRange( nStart, nEnd );
  if ( nStart )
  {
      nStart--;
      nEnd--;
  }
  TextSelection aSel( TextPaM( nStart, 0 ), TextPaM( nStart, 0 ) );
  AssertValidEditEngine();
  TextView * pView = GetEditView();
  // scroll if applicable so that first line is at the top
  long nVisHeight = GetOutputSizePixel().Height();
  if ( pView->GetTextEngine()->GetTextHeight() > nVisHeight )
  {
      long nMaxY = pView->GetTextEngine()->GetTextHeight() - nVisHeight;
      long nOldStartY = pView->GetStartDocPos().Y();
      long nNewStartY = static_cast<long>(nStart) * pView->GetTextEngine()->GetCharHeight();
      nNewStartY = std::min( nNewStartY, nMaxY );
      pView->Scroll( 0, -(nNewStartY-nOldStartY) );
      pView->ShowCursor( false );
      GetEditVScrollBar().SetThumbPos( pView->GetStartDocPos().Y() );
  }
  pView->SetSelection( aSel );
  pView->ShowCursor();
  pView->GetWindow()->GrabFocus();
757}

759void ModulWindow::StoreData()
760{
  // StoreData is called when the BasicManager is destroyed or
  // this window is closed.
  // => interrupts undesired!
  GetEditorWindow().SetSourceInBasic();
765}

767bool ModulWindow::AllowUndo()
768{
  return GetEditorWindow().CanModify();
770}

772void ModulWindow::UpdateData()
773{
  DBG_ASSERT( XModule().is(), "No Module!" )do { if (true && (!(XModule().is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
 ":" "774" ": "), "%s", "No Module!"); } } while (false);
  // UpdateData is called when the source has changed from outside
  // => interrupts undesired!

  if ( !XModule().is() )
      return;

  SetModule( m_xModule->GetSource32() );

  if ( GetEditView() )
  {
      TextSelection aSel = GetEditView()->GetSelection();
      setTextEngineText(*GetEditEngine(), m_xModule->GetSource32());
      GetEditView()->SetSelection( aSel );
      GetEditEngine()->SetModified( false );
      MarkDocumentModified( GetDocument() );
  }
791}

793sal_Int32 ModulWindow::countPages( Printer* pPrinter )
794{
  return FormatAndPrint( pPrinter, -1 );
796}

798void ModulWindow::printPage( sal_Int32 nPage, Printer* pPrinter )
799{
  FormatAndPrint( pPrinter, nPage );
801}

803/* implementation note: this is totally inefficient for the XRenderable interface
 usage since the whole "document" will be format for every page. Should this ever
 become a problem we should
 - format only once for every new printer
 - keep an index list for each page which is the starting paragraph
808*/
809sal_Int32 ModulWindow::FormatAndPrint( Printer* pPrinter, sal_Int32 nPrintPage )
810{
  AssertValidEditEngine();

  MapMode eOldMapMode( pPrinter->GetMapMode() );
  vcl::Font aOldFont( pPrinter->GetFont() );

  vcl::Font aFont( GetEditEngine()->GetFont() );
  aFont.SetAlignment( ALIGN_BOTTOM );
  aFont.SetTransparent( true );
  aFont.SetFontSize( Size( 0, 360 ) );
  pPrinter->SetFont( aFont );
  pPrinter->SetMapMode(MapMode(MapUnit::Map100thMM));

  OUString aTitle( CreateQualifiedName() );

  sal_Int32 nLineHeight = pPrinter->GetTextHeight();
  if(nLineHeight == 0)
  {
      nLineHeight = 1;
  }

  Size aPaperSz = pPrinter->GetOutputSize();
  aPaperSz.AdjustWidth( -(Print::nLeftMargin + Print::nRightMargin) );
  aPaperSz.AdjustHeight( -(Print::nTopMargin + Print::nBottomMargin) );

  // nLinepPage is not correct if there's a line break
  sal_Int32 nLinespPage = aPaperSz.Height()/nLineHeight;
  long nXTextWidth = pPrinter->approximate_digit_width();

  sal_Int32 nCharspLine = aPaperSz.Width() / std::max<long>(nXTextWidth, 1);
  const sal_uInt32 nParas = GetEditEngine()->GetParagraphCount();

  sal_Int32 nPages = nParas/nLinespPage+1;
  sal_Int32 nCurPage = 1;

  lcl_PrintHeader( pPrinter, nPages, nCurPage, aTitle, nPrintPage == 0 );
  Point aPos( Print::nLeftMargin, Print::nTopMargin );
  for ( sal_uInt32 nPara = 0; nPara < nParas; ++nPara )
  {
      OUString aLine( GetEditEngine()->GetText( nPara ) );
      lcl_ConvertTabsToSpaces( aLine );
      sal_Int32 nLines = aLine.getLength()/nCharspLine+1;
      for (sal_Int32 nLine = 0; nLine < nLines; ++nLine)
      {
          sal_Int32 nBeginIndex = nLine*nCharspLine;
          sal_Int32 nCopyCount = std::min<sal_Int32>(nCharspLine, aLine.getLength()-nBeginIndex);
          OUString aTmpLine = aLine.copy(nBeginIndex, nCopyCount);
          aPos.AdjustY(nLineHeight );
          if ( aPos.Y() > ( aPaperSz.Height() + Print::nTopMargin ) )
          {
              nCurPage++;
              lcl_PrintHeader( pPrinter, nPages, nCurPage, aTitle, nCurPage-1 == nPrintPage );
              aPos = Point(Print::nLeftMargin, Print::nTopMargin + nLineHeight);
          }
          if( nCurPage-1 == nPrintPage )
              pPrinter->DrawText( aPos, aTmpLine );
      }
      aPos.AdjustY(10 ); // nParaSpace
  }

  pPrinter->SetFont( aOldFont );
  pPrinter->SetMapMode( eOldMapMode );

  return nCurPage;
874}

876void ModulWindow::ExecuteCommand (SfxRequest& rReq)
877{
  AssertValidEditEngine();
  switch (rReq.GetSlot())
  {
      case SID_DELETE(5000 + 713):
      {
          if (!IsReadOnly())
          {
              KeyEvent aFakeDelete(0, KEY_DELETE);
              (void)GetEditView()->KeyInput(aFakeDelete);
          }
          break;
      }
      case SID_SELECTALL(5000 + 723):
      {
          TextSelection aSel( TextPaM( 0, 0 ), TextPaM( TEXT_PARA_ALL((sal_uInt32) 0xFFFFFFFF), TEXT_INDEX_ALL((sal_Int32) 0x7FFFFFFF) ) );
          TextView * pView = GetEditView();
          pView->SetSelection( aSel );
          pView->GetWindow()->GrabFocus();
          break;
      }
      case SID_BASICRUN(5000 + 955):
      {
          BasicRun();
      }
      break;
      case SID_BASICCOMPILE(5000 + 954):
      {
          CompileBasic();
      }
      break;
      case SID_BASICSTEPOVER(5000 + 957):
      {
          BasicStepOver();
      }
      break;
      case SID_BASICSTEPINTO(5000 + 956):
      {
          BasicStepInto();
      }
      break;
      case SID_BASICSTEPOUT(5000 + 963):
      {
          BasicStepOut();
      }
      break;
      case SID_BASICLOAD(5000 + 951):
      {
          LoadBasic();
      }
      break;
      case SID_BASICSAVEAS(5000 + 953):
      {
          SaveBasicSource();
      }
      break;
      case SID_IMPORT_DIALOG(5000 + 966):
      {
          ImportDialog();
      }
      break;
      case SID_BASICIDE_MATCHGROUP( (30000 + 768) + 14 ):
      {
          GetEditView()->MatchGroup();
      }
      break;
      case SID_BASICIDE_TOGGLEBRKPNT( (30000 + 768) + 0 ):
      {
          BasicToggleBreakPoint();
      }
      break;
      case SID_BASICIDE_MANAGEBRKPNTS( (30000 + 768) + 42 ):
      {
          ManageBreakPoints();
      }
      break;
      case SID_BASICIDE_TOGGLEBRKPNTENABLED( (30000 + 768) + 43 ):
      {
          BasicToggleBreakPointEnabled();
      }
      break;
      case SID_BASICIDE_ADDWATCH( (30000 + 768) + 1 ):
      {
          BasicAddWatch();
      }
      break;
      case SID_BASICIDE_REMOVEWATCH( (30000 + 768) + 7 ):
      {
          m_rLayout.BasicRemoveWatch();
      }
      break;
      case SID_CUT(5000 + 710):
      {
          if ( !IsReadOnly() )
          {
              GetEditView()->Cut();
              if (SfxBindings* pBindings = GetBindingsPtr())
                  pBindings->Invalidate( SID_DOC_MODIFIED(5000 + 584) );
          }
      }
      break;
      case SID_COPY(5000 + 711):
      {
          GetEditView()->Copy();
      }
      break;
      case SID_PASTE(5000 + 712):
      {
          if ( !IsReadOnly() )
          {
              GetEditView()->Paste();
              if (SfxBindings* pBindings = GetBindingsPtr())
                  pBindings->Invalidate( SID_DOC_MODIFIED(5000 + 584) );
          }
      }
      break;
      case SID_BASICIDE_BRKPNTSCHANGED( (30000 + 768) + 36 ):
      {
          GetBreakPointWindow().Invalidate();
      }
      break;
      case SID_SHOWLINES(5000 + 1725):
      {
          const SfxBoolItem* pItem = rReq.GetArg<SfxBoolItem>(rReq.GetSlot());
          bool bLineNumbers = pItem && pItem->GetValue();
          m_aXEditorWindow->SetLineNumberDisplay(bLineNumbers);

          std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
          officecfg::Office::BasicIDE::EditorSettings::LineNumbering::set(bLineNumbers, batch);
          batch->commit();
      }
      break;
      case SID_BASICIDE_DELETECURRENT( (30000 + 768) + 22 ):
      {
          if (QueryDelModule(m_aName, GetFrameWeld()))
          {
              // tdf#134551 don't delete the window if last module is removed until this block
              // is complete
              VclPtr<ModulWindow> xKeepRef(this);
              if (m_aDocument.removeModule(m_aLibName, m_aName))
                  MarkDocumentModified(m_aDocument);
          }
      }
      break;
      case FID_SEARCH_OFF((10000 + 500) + 1):
          GrabFocus();
          break;
      case SID_GOTOLINE(5000 + 1724):
      {
          GotoLineDialog aGotoDlg(GetFrameWeld());
          if (aGotoDlg.run() == RET_OK)
          {
              if (sal_Int32 const nLine = aGotoDlg.GetLineNumber())
              {
                  TextSelection const aSel(TextPaM(nLine - 1, 0), TextPaM(nLine - 1, 0));
                  GetEditView()->SetSelection(aSel);
              }
          }
          break;
      }
  }
1038}

1040void ModulWindow::ExecuteGlobal (SfxRequest& rReq)
1041{
  switch (rReq.GetSlot())
  {
      case SID_SIGNATURE(5000 + 1643):
      {
          DocumentSignature aSignature(m_aDocument);
          if (aSignature.supportsSignatures())
          {
              aSignature.signScriptingContent(rReq.GetFrameWeld());
              if (SfxBindings* pBindings = GetBindingsPtr())
                  pBindings->Invalidate(SID_SIGNATURE(5000 + 1643));
          }
      }
      break;
  }
1056}

1058void ModulWindow::GetState( SfxItemSet &rSet )
1059{
  SfxWhichIter aIter(rSet);
  for ( sal_uInt16 nWh = aIter.FirstWhich(); nWh != 0; nWh = aIter.NextWhich() )
  {
      switch ( nWh )
      {
          case SID_CUT(5000 + 710):
          {
              if ( !GetEditView() || !GetEditView()->HasSelection() )
                  rSet.DisableItem( nWh );

              if ( IsReadOnly() )
                  rSet.DisableItem( nWh );
          }
          break;
          case SID_COPY(5000 + 711):
          {
              if ( !GetEditView() || !GetEditView()->HasSelection() )
                  rSet.DisableItem( nWh );
          }
          break;
          case SID_PASTE(5000 + 712):
          {
              if ( !IsPasteAllowed() )
                  rSet.DisableItem( nWh );

              if ( IsReadOnly() )
                  rSet.DisableItem( nWh );
          }
          break;
          case SID_BASICIDE_STAT_POS( (30000 + 768) + 38 ):
          {
              TextView* pView = GetEditView();
              if ( pView )
              {
                  TextSelection aSel = pView->GetSelection();
                  OUString aPos = IDEResId( RID_STR_LINEreinterpret_cast<char const *>("RID_STR_LINE" "\004" u8"Ln"
) ) +
                                 " " +
                                 OUString::number(aSel.GetEnd().GetPara()+1) +
                                 ", " +
                                 IDEResId( RID_STR_COLUMNreinterpret_cast<char const *>("RID_STR_COLUMN" "\004" u8"Col"
) ) +
                                 " " +
                                 OUString::number(aSel.GetEnd().GetIndex()+1);
                  SfxStringItem aItem( SID_BASICIDE_STAT_POS( (30000 + 768) + 38 ), aPos );
                  rSet.Put( aItem );
              }
          }
          break;
          case SID_BASICIDE_STAT_TITLE( (30000 + 768) + 40 ):
          {
              // search for current procedure name (Sub or Function)
              TextView* pView = GetEditView();
              if ( pView )
              {
                  OUString sProcName;

                  TextSelection aSel = pView->GetSelection();

                  sal_uInt32 i = aSel.GetStart().GetPara();
                  do
                  {
                      OUString aCurrLine = GetEditEngine()->GetText( i );
                      OUString sProcType;
                      if (GetEditorWindow().GetProcedureName(aCurrLine, sProcType, sProcName))
                          break;
                  } while (i--);

                  OUString aTitle = CreateQualifiedName();
                  if (!sProcName.isEmpty())
                      aTitle += "." + sProcName;

                  SfxStringItem aTitleItem( SID_BASICIDE_STAT_TITLE( (30000 + 768) + 40 ), aTitle );
                  rSet.Put( aTitleItem );
              }
          }
          break;
          case SID_ATTR_INSERTTypedWhichId<SfxBoolItem>( 10000 + 221 ):
          {
              TextView* pView = GetEditView();
              if ( pView )
              {
                  SfxBoolItem aItem( SID_ATTR_INSERTTypedWhichId<SfxBoolItem>( 10000 + 221 ), pView->IsInsertMode() );
                  rSet.Put( aItem );
              }
          }
          break;
          case SID_SHOWLINES(5000 + 1725):
          {
              bool bLineNumbers = ::officecfg::Office::BasicIDE::EditorSettings::LineNumbering::get();
              rSet.Put(SfxBoolItem(nWh, bLineNumbers));
              break;
          }
          case SID_SELECTALL(5000 + 723):
          {
              if ( !GetEditView() )
                  rSet.DisableItem( nWh );
          }
          break;
      }
  }
1159}

1161void ModulWindow::DoScroll( ScrollBar* pCurScrollBar )
1162{
  if ( ( pCurScrollBar == GetHScrollBar() ) && GetEditView() )
  {
      // don't scroll with the value but rather use the Thumb-Pos for the VisArea:
      long nDiff = GetEditView()->GetStartDocPos().X() - pCurScrollBar->GetThumbPos();
      GetEditView()->Scroll( nDiff, 0 );
      GetEditView()->ShowCursor( false );
      pCurScrollBar->SetThumbPos( GetEditView()->GetStartDocPos().X() );

  }
1172}

1174bool ModulWindow::IsModified()
1175{
  return GetEditEngine() && GetEditEngine()->IsModified();
1177}

1179OUString ModulWindow::GetSbModuleName()
1180{
  OUString aModuleName;
  if ( XModule().is() )
      aModuleName = m_xModule->GetName();
  return aModuleName;
1185}

1187OUString ModulWindow::GetTitle()
1188{
  return GetSbModuleName();
1190}

1192void ModulWindow::ShowCursor( bool bOn )
1193{
  if ( GetEditEngine() )
  {
      TextView* pView = GetEditEngine()->GetActiveView();
      if ( pView )
      {
          if ( bOn )
              pView->ShowCursor();
          else
              pView->HideCursor();
      }
  }
1205}

1207void ModulWindow::AssertValidEditEngine()
1208{
  if ( !GetEditEngine() )
      GetEditorWindow().CreateEditEngine();
1211}

1213void ModulWindow::Activating ()
1214{
  bool bLineNumbers = ::officecfg::Office::BasicIDE::EditorSettings::LineNumbering::get();
  m_aXEditorWindow->SetLineNumberDisplay(bLineNumbers);
  Show();
1218}

1220void ModulWindow::Deactivating()
1221{
  Hide();
1223}

1225sal_uInt16 ModulWindow::StartSearchAndReplace( const SvxSearchItem& rSearchItem, bool bFromStart )
1226{
  if (IsSuspended())
      return 0;

  // one could also relinquish syntaxhighlighting/formatting instead of the stupid replace-everything...
  AssertValidEditEngine();
  TextView* pView = GetEditView();
  TextSelection aSel;
  if ( bFromStart )
  {
      aSel = pView->GetSelection();
      if ( !rSearchItem.GetBackward() )
          pView->SetSelection( TextSelection() );
      else
          pView->SetSelection( TextSelection( TextPaM( TEXT_PARA_ALL((sal_uInt32) 0xFFFFFFFF), TEXT_INDEX_ALL((sal_Int32) 0x7FFFFFFF) ), TextPaM( TEXT_PARA_ALL((sal_uInt32) 0xFFFFFFFF), TEXT_INDEX_ALL((sal_Int32) 0x7FFFFFFF) ) ) );
  }

  bool const bForward = !rSearchItem.GetBackward();
  sal_uInt16 nFound = 0;
  if ( ( rSearchItem.GetCommand() == SvxSearchCmd::FIND ) ||
       ( rSearchItem.GetCommand() == SvxSearchCmd::FIND_ALL ) )
  {
      nFound = pView->Search( rSearchItem.GetSearchOptions() , bForward ) ? 1 : 0;
  }
  else if ( ( rSearchItem.GetCommand() == SvxSearchCmd::REPLACE ) ||
            ( rSearchItem.GetCommand() == SvxSearchCmd::REPLACE_ALL ) )
  {
      if ( !IsReadOnly() )
      {
          bool const bAll = rSearchItem.GetCommand() == SvxSearchCmd::REPLACE_ALL;
          nFound = pView->Replace( rSearchItem.GetSearchOptions() , bAll , bForward );
      }
  }

  if ( bFromStart && !nFound )
      pView->SetSelection( aSel );

  return nFound;
1264}

1266SfxUndoManager* ModulWindow::GetUndoManager()
1267{
  if ( GetEditEngine() )
      return &GetEditEngine()->GetUndoManager();
  return nullptr;
1271}

1273SearchOptionFlags ModulWindow::GetSearchOptions()
1274{
  SearchOptionFlags nOptions = SearchOptionFlags::SEARCH |
                    SearchOptionFlags::WHOLE_WORDS |
                    SearchOptionFlags::BACKWARDS |
                    SearchOptionFlags::REG_EXP |
                    SearchOptionFlags::EXACT |
                    SearchOptionFlags::SELECTION |
                    SearchOptionFlags::SIMILARITY;

  if ( !IsReadOnly() )
  {
      nOptions |= SearchOptionFlags::REPLACE;
      nOptions |= SearchOptionFlags::REPLACE_ALL;
  }

  return nOptions;
1290}

1292void ModulWindow::BasicStarted()
1293{
  if ( !XModule().is() )
      return;

  m_aStatus.bIsRunning = true;
  BreakPointList& rList = GetBreakPoints();
  if ( rList.size() )
  {
      rList.ResetHitCount();
      rList.SetBreakPointsInBasic( m_xModule.get() );
      for ( sal_uInt32 nMethod = 0; nMethod < m_xModule->GetMethods()->Count32(); nMethod++ )
      {
          SbMethod* pMethod = static_cast<SbMethod*>(m_xModule->GetMethods()->Get32( nMethod ));
          assert(pMethod && "Method not found! (NULL)")(static_cast <bool> (pMethod && "Method not found! (NULL)"
) ? void (0) : __assert_fail ("pMethod && \"Method not found! (NULL)\""
, "/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
, 1306, __extension__ __PRETTY_FUNCTION__));
          pMethod->SetDebugFlags( pMethod->GetDebugFlags() | BasicDebugFlags::Break );
      }
  }
1310}

1312void ModulWindow::BasicStopped()
1313{
  m_aStatus.bIsRunning = false;
  GetBreakPointWindow().SetNoMarker();
1316}

1318EntryDescriptor ModulWindow::CreateEntryDescriptor()
1319{
  ScriptDocument aDocument( GetDocument() );
  OUString aLibName( GetLibName() );
  LibraryLocation eLocation = aDocument.getLibraryLocation( aLibName );
  OUString aModName( GetName() );
  OUString aLibSubName;
  if( m_xBasic.is() && aDocument.isInVBAMode() && XModule().is() )
  {
      switch( m_xModule->GetModuleType() )
      {
          case script::ModuleType::DOCUMENT:
          {
              aLibSubName = IDEResId( RID_STR_DOCUMENT_OBJECTSreinterpret_cast<char const *>("RID_STR_DOCUMENT_OBJECTS"
 "\004" u8"Document Objects") );
              uno::Reference< container::XNameContainer > xLib = aDocument.getOrCreateLibrary( E_SCRIPTS, aLibName );
              if( xLib.is() )
              {
                  OUString sObjName;
                  ModuleInfoHelper::getObjectName( xLib, aModName, sObjName );
                  if( !sObjName.isEmpty() )
                  {
                      aModName += " (" + sObjName + ")";
                  }
              }
              break;
          }
          case script::ModuleType::FORM:
              aLibSubName = IDEResId( RID_STR_USERFORMSreinterpret_cast<char const *>("RID_STR_USERFORMS" "\004"
 u8"Forms") );
              break;
          case script::ModuleType::NORMAL:
              aLibSubName = IDEResId( RID_STR_NORMAL_MODULESreinterpret_cast<char const *>("RID_STR_NORMAL_MODULES"
 "\004" u8"Modules") );
              break;
          case script::ModuleType::CLASS:
              aLibSubName = IDEResId( RID_STR_CLASS_MODULESreinterpret_cast<char const *>("RID_STR_CLASS_MODULES" "\004"
 u8"Class Modules") );
              break;
      }
  }
  return EntryDescriptor( aDocument, eLocation, aLibName, aLibSubName, aModName, OBJ_TYPE_MODULE );
1356}

1358void ModulWindow::SetReadOnly (bool b)
1359{
  if ( GetEditView() )
      GetEditView()->SetReadOnly( b );
1362}

1364bool ModulWindow::IsReadOnly()
1365{
  return GetEditView() && GetEditView()->IsReadOnly();
1367}

1369bool ModulWindow::IsPasteAllowed()
1370{
  bool bPaste = false;

  // get clipboard
  Reference< datatransfer::clipboard::XClipboard > xClipboard = GetClipboard();
  if ( xClipboard.is() )
  {

      Reference< datatransfer::XTransferable > xTransf;
      {
          SolarMutexReleaser aReleaser;
          // get clipboard content
          xTransf = xClipboard->getContents();
      }
      if ( xTransf.is() )
      {
          datatransfer::DataFlavor aFlavor;
          SotExchange::GetFormatDataFlavor( SotClipboardFormatId::STRING, aFlavor );
          if ( xTransf->isDataFlavorSupported( aFlavor ) )
              bPaste = true;
      }
  }

  return bPaste;
1394}

1396void ModulWindow::OnNewDocument ()
1397{
  bool bLineNumbers = ::officecfg::Office::BasicIDE::EditorSettings::LineNumbering::get();
  m_aXEditorWindow->SetLineNumberDisplay(bLineNumbers);
1400}

1402char const* ModulWindow::GetHid () const
1403{
  return HID_BASICIDE_MODULWINDOW"BASCTL_HID_BASICIDE_MODULWINDOW";
1405}
1406ItemType ModulWindow::GetType () const
1407{
  return TYPE_MODULE;
1409}

1411bool ModulWindow::HasActiveEditor () const
1412{
  return !IsSuspended();
1414}


1417void ModulWindow::UpdateModule ()
1418{
  OUString const aModule = getTextEngineText(*GetEditEngine());

  // update module in basic
  assert(m_xModule.is())(static_cast <bool> (m_xModule.is()) ? void (0) : __assert_fail
 ("m_xModule.is()", "/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
, 1422, __extension__ __PRETTY_FUNCTION__));

  // update module in module window
  SetModule(aModule);

  // update module in library
  OSL_VERIFY(m_aDocument.updateModule(m_aLibName, m_aName, aModule))do { if (!(m_aDocument.updateModule(m_aLibName, m_aName, aModule
))) do { if (true && (!(0))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
 ":" "1428" ": "), "OSL_ASSERT: %s", "0"); } } while (false);
 } while (0);

  GetEditEngine()->SetModified(false);
  MarkDocumentModified(m_aDocument);
1432}

1434ModulWindowLayout::ModulWindowLayout (vcl::Window* pParent, ObjectCatalog& rObjectCatalog_) :
  Layout(pParent),
  pChild(nullptr),
  aWatchWindow(VclPtr<WatchWindow>::Create(this)),
  aStackWindow(VclPtr<StackWindow>::Create(this)),
  rObjectCatalog(rObjectCatalog_)
1440{ }

1442ModulWindowLayout::~ModulWindowLayout()
1443{
  disposeOnce();
1445}

1447void ModulWindowLayout::dispose()
1448{
  aWatchWindow.disposeAndClear();
  aStackWindow.disposeAndClear();
1
Calling 'VclPtr::disposeAndClear'→
  pChild.clear();
  Layout::dispose();
1453}

1455void ModulWindowLayout::UpdateDebug (bool bBasicStopped)
1456{
  aWatchWindow->UpdateWatches(bBasicStopped);
  aStackWindow->UpdateCalls();
1459}

1461void ModulWindowLayout::Paint (vcl::RenderContext& rRenderContext, tools::Rectangle const&)
1462{
  rRenderContext.DrawText(Point(), IDEResId(RID_STR_NOMODULEreinterpret_cast<char const *>("RID_STR_NOMODULE" "\004"
 u8"< No Module >")));
1464}

1466void ModulWindowLayout::Activating (BaseWindow& rChild)
1467{
  assert(dynamic_cast<ModulWindow*>(&rChild))(static_cast <bool> (dynamic_cast<ModulWindow*>(&
rChild)) ? void (0) : __assert_fail ("dynamic_cast<ModulWindow*>(&rChild)"
, "/home/maarten/src/libreoffice/core/basctl/source/basicide/baside2.cxx"
, 1468, __extension__ __PRETTY_FUNCTION__));
  pChild = &static_cast<ModulWindow&>(rChild);
  aWatchWindow->Show();
  aStackWindow->Show();
  rObjectCatalog.Show();
  rObjectCatalog.SetLayoutWindow(this);
  rObjectCatalog.UpdateEntries();
  Layout::Activating(rChild);
  aSyntaxColors.SetActiveEditor(&pChild->GetEditorWindow());
1477}

1479void ModulWindowLayout::Deactivating ()
1480{
  aSyntaxColors.SetActiveEditor(nullptr);
  Layout::Deactivating();
  aWatchWindow->Hide();
  aStackWindow->Hide();
  rObjectCatalog.Hide();
  pChild = nullptr;
1487}

1489void ModulWindowLayout::GetState (SfxItemSet &rSet, unsigned nWhich)
1490{
  switch (nWhich)
  {
      case SID_SHOW_PROPERTYBROWSER( 10000 + 943 ):
          rSet.Put(SfxVisibilityItem(nWhich, false));
          break;

      case SID_BASICIDE_CHOOSEMACRO( (30000 + 768) + 2 ):
          rSet.Put(SfxVisibilityItem(nWhich, true));
          break;
  }
1501}

1503void ModulWindowLayout::BasicAddWatch (OUString const& rWatchStr)
1504{
  aWatchWindow->AddWatch(rWatchStr);
1506}

1508void ModulWindowLayout::BasicRemoveWatch ()
1509{
  aWatchWindow->RemoveSelectedWatch();
1511}

1513void ModulWindowLayout::OnFirstSize (long const nWidth, long const nHeight)
1514{
  AddToLeft(&rObjectCatalog, Size(nWidth * 0.20, nHeight * 0.75));
  AddToBottom(aWatchWindow.get(), Size(nWidth * 0.67, nHeight * 0.25));
  AddToBottom(aStackWindow.get(), Size(nWidth * 0.33, nHeight * 0.25));
1518}

1520ModulWindowLayout::SyntaxColors::SyntaxColors () :
  pEditor(nullptr)
1522{
  aConfig.AddListener(this);

  NewConfig(true);
1526}

1528ModulWindowLayout::SyntaxColors::~SyntaxColors ()
1529{
  aConfig.RemoveListener(this);
1531}

1533// virtual
1534void ModulWindowLayout::SyntaxColors::ConfigurationChanged (utl::ConfigurationBroadcaster*, ConfigurationHints)
1535{
  NewConfig(false);
1537}

1539// when a new configuration has to be set
1540void ModulWindowLayout::SyntaxColors::NewConfig (bool bFirst)
1541{
  static struct
  {
      TokenType eTokenType;
      svtools::ColorConfigEntry eEntry;
  }
  const vIds[] =
  {
      { TokenType::Unknown,     svtools::FONTCOLOR },
      { TokenType::Identifier,  svtools::BASICIDENTIFIER },
      { TokenType::Whitespace,  svtools::FONTCOLOR },
      { TokenType::Number,      svtools::BASICNUMBER },
      { TokenType::String,      svtools::BASICSTRING },
      { TokenType::EOL,         svtools::FONTCOLOR },
      { TokenType::Comment,     svtools::BASICCOMMENT },
      { TokenType::Error,       svtools::BASICERROR },
      { TokenType::Operator,    svtools::BASICOPERATOR },
      { TokenType::Keywords,    svtools::BASICKEYWORD },
  };

  Color aDocColor = aConfig.GetColorValue(svtools::DOCCOLOR).nColor;
  if (bFirst || aDocColor != m_aBackgroundColor)
  {
      m_aBackgroundColor = aDocColor;
      if (!bFirst && pEditor)
      {
          pEditor->SetBackground(Wallpaper(m_aBackgroundColor));
          pEditor->Invalidate();
      }
  }

  Color aFontColor = aConfig.GetColorValue(svtools::FONTCOLOR).nColor;
  if (bFirst || aFontColor != m_aFontColor)
  {
      m_aFontColor = aFontColor;
      if (!bFirst && pEditor)
          pEditor->ChangeFontColor(m_aFontColor);
  }

  bool bChanged = false;
  for (unsigned i = 0; i != SAL_N_ELEMENTS(vIds)(sizeof(sal_n_array_size(vIds))); ++i)
  {
      Color const aColor = aConfig.GetColorValue(vIds[i].eEntry).nColor;
      Color& rMyColor = aColors[vIds[i].eTokenType];
      if (bFirst || aColor != rMyColor)
      {
          rMyColor = aColor;
          bChanged = true;
      }
  }
  if (bChanged && !bFirst && pEditor)
      pEditor->UpdateSyntaxHighlighting();
1593}

1595} // namespace basctl

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

←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx

→

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#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
  }

  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
    */
  reference_type * get() const
  {
      return m_rInnerRef.get();
  }

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
2
←
Calling copy constructor for 'Reference<basctl::StackWindow>'→
5
←
Returning from copy constructor for 'Reference<basctl::StackWindow>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
6
←
Calling 'Reference::clear'→
13
←
Returning; memory was released→
      if (aTmp.get()) {
14
←
Calling 'Reference::get'→
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

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

←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→

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#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
3
←
Assuming field 'm_pBody' is non-null→
4
←
Taking true branch→
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody6.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
7
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
8
←
Calling 'VclReferenceBase::release'→
12
←
Returning; memory was released→
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
15
←
Use of memory after it is freed
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

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

←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 *   Licensed to the Apache Software Foundation (ASF) under one or more
12 *   contributor license agreements. See the NOTICE file distributed
13 *   with this work for additional information regarding copyright
14 *   ownership. The ASF licenses this file to you under the Apache
15 *   License, Version 2.0 (the "License"); you may not use this file
16 *   except in compliance with the License. You may obtain a copy of
17 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
9
←
Assuming the condition is true→
10
←
Taking true branch→
40            delete this;
11
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif