strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/include/basic/sbx.hxx
Stephan Bergmann 16e3b84d2e Improve loplugin:dyncastvisibility to check for non-inline key functions 
This would have caught the issue discussed in
709b1f3ddb "Make sure VCLXPopupMenu has unique
RTTI".  (The commit message talks about RTTI there, while what Clang actually
compared for an optimized implementation of a dynamic_cast to a final class is
vtable pointers, but the overall picture remains the same.  Both RTTI and
vtables are emitted along the key function, and if that is missing or inline,
they are emitted for each dynamic library individually, and as internal symbols
on macOS.)

This commit also addresses all the issues found by the improved
loplugin:dyncastvisibility on Linux.  See the newly added TODO in
compilerplugins/clang/dyncastvisibility.cxx and
86b86ac87e "Give DocumentEventHolder (aka
EventHolder<DocumentEvent>) a key function" for an issue with key functions for
class template instantiations.

Change-Id: Ia19155efb1d23692c92b9c97ff17f18ae7a1f3ee
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/176576
Reviewed-by: Stephan Bergmann <stephan.bergmann@allotropia.de>
Tested-by: Jenkins
2024-11-14 12:49:22 +01:00

211 lines
7.3 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* 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 .
*/
#pragma once
#include <config_options.h>
#include <tools/ref.hxx>
#include <svl/hint.hxx>
#include <basic/sbxdef.hxx>
#include <basic/sbxobj.hxx>
#include <basic/basicdllapi.h>
#include <utility>
#include <vector>
#include <memory>
class SvStream;
class SfxBroadcaster;
// Parameter information
struct SbxParamInfo
{
const OUString aName; // Name of the parameter
SbxDataType eType; // Data type
SbxFlagBits nFlags; // Flag-Bits
sal_uInt32 nUserData; // IDs etc.
SbxParamInfo( OUString s, SbxDataType t, SbxFlagBits n )
: aName(std::move( s )), eType( t ), nFlags( n ), nUserData( 0 ) {}
};
typedef std::vector<std::unique_ptr<SbxParamInfo>> SbxParams;
class UNLESS_MERGELIBS(BASIC_DLLPUBLIC) SbxInfo final : public SvRefBase
{
friend class SbxVariable;
friend class SbMethod;
OUString aComment;
OUString aHelpFile;
sal_uInt32 nHelpId;
SbxParams m_Params;
SbxInfo(SbxInfo const&) = delete;
void operator=(SbxInfo const&) = delete;
void LoadData( SvStream&, sal_uInt16 );
void StoreData( SvStream& ) const;
virtual ~SbxInfo() override;
public:
SbxInfo();
SbxInfo( OUString , sal_uInt32 );
void AddParam( const OUString&, SbxDataType, SbxFlagBits=SbxFlagBits::Read );
const SbxParamInfo* GetParam( sal_uInt16 n ) const; // index starts with 1!
const OUString& GetComment() const { return aComment; }
const OUString& GetHelpFile() const { return aHelpFile; }
sal_uInt32 GetHelpId() const { return nHelpId; }
void SetComment( const OUString& r ) { aComment = r; }
};
class BASIC_DLLPUBLIC SbxHint final : public SfxHint
{
SbxVariable* pVar;
public:
SbxHint( SfxHintId n, SbxVariable* v ) : SfxHint( n ), pVar( v ) {}
~SbxHint() override;
SbxVariable* GetVar() const { return pVar; }
};
// SbxArray is an unidimensional, dynamic Array
// The variables convert from SbxVariablen. Put()/Insert() into the
// declared datatype, if they are not SbxVARIANT.
struct SbxVarEntry;
class BASIC_DLLPUBLIC SbxArray : public SbxBase
{
// #100883 Method to set method directly to parameter array
friend class SbMethod;
friend class SbClassModuleObject;
friend SbxObjectRef cloneTypeObjectImpl( const SbxObject& rTypeObj );
BASIC_DLLPRIVATE void PutDirect( SbxVariable* pVar, sal_uInt32 nIdx );
std::vector<SbxVarEntry> mVarEntries; // The variables
SbxDataType eType; // Data type of the array
protected:
virtual ~SbxArray() override;
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual std::pair<bool, sal_uInt32> StoreData( SvStream& ) const override;
public:
SBX_DECL_PERSIST_NODATA(SBXID_ARRAY,1);
SbxArray( SbxDataType=SbxVARIANT );
SbxArray( const SbxArray& ) = delete;
SbxArray& operator=( const SbxArray& );
virtual void Clear() override;
sal_uInt32 Count() const;
virtual SbxDataType GetType() const override;
SbxVariableRef& GetRef(sal_uInt32);
SbxVariable* Get(sal_uInt32);
void Put(SbxVariable*, sal_uInt32);
void Insert(SbxVariable*, sal_uInt32);
void Remove( sal_uInt32 );
void Remove( SbxVariable const * );
void Merge( SbxArray* );
const OUString & GetAlias(sal_uInt32);
void PutAlias(const OUString&, sal_uInt32);
SbxVariable* Find( const OUString&, SbxClassType );
};
// SbxDimArray is an array that can dimensioned using BASIC conventions.
struct SbxDim { // an array-dimension:
sal_Int32 nLbound, nUbound; // Limitations
sal_Int32 nSize; // Number of elements
};
class BASIC_DLLPUBLIC SbxDimArray final : public SbxArray
{
std::vector<SbxDim> m_vDimensions; // Dimension table
BASIC_DLLPRIVATE void AddDimImpl(sal_Int32, sal_Int32, bool bAllowSize0);
bool mbHasFixedSize;
sal_uInt32 Offset(const sal_Int32*);
sal_uInt32 Offset(SbxArray*);
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual std::pair<bool, sal_uInt32> StoreData( SvStream& ) const override;
virtual ~SbxDimArray() override;
public:
SBX_DECL_PERSIST_NODATA(SBXID_DIMARRAY,1);
SbxDimArray( SbxDataType=SbxVARIANT );
SbxDimArray( const SbxDimArray& ) = delete;
SbxDimArray& operator=( const SbxDimArray& );
virtual void Clear() override;
SbxVariable* Get( SbxArray* );
using SbxArray::GetRef;
using SbxArray::Get;
SbxVariable* Get(const sal_Int32*);
using SbxArray::Put;
void Put(SbxVariable*, const sal_Int32*);
sal_Int32 GetDims() const { return m_vDimensions.size(); }
void AddDim(sal_Int32, sal_Int32);
void unoAddDim(sal_Int32, sal_Int32);
bool GetDim(sal_Int32, sal_Int32&, sal_Int32&) const;
bool hasFixedSize() const { return mbHasFixedSize; };
void setHasFixedSize( bool bHasFixedSize ) {mbHasFixedSize = bHasFixedSize; };
};
class SbxCollection : public SbxObject
{
void Initialize();
protected:
virtual ~SbxCollection() override;
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
// Overridable methods (why not pure virtual?):
virtual void CollAdd( SbxArray* pPar );
void CollItem( SbxArray* pPar );
virtual void CollRemove( SbxArray* pPar );
public:
SBX_DECL_PERSIST_NODATA(SBXID_COLLECTION,1);
SbxCollection();
SbxCollection( const SbxCollection& );
SbxCollection& operator=( const SbxCollection& );
virtual SbxVariable* Find( const OUString&, SbxClassType ) override;
virtual void Clear() override;
};
class SbxStdCollection final : public SbxCollection
{
OUString aElemClass;
bool bAddRemoveOk;
virtual ~SbxStdCollection() override;
virtual bool LoadData( SvStream&, sal_uInt16 ) override;
virtual std::pair<bool, sal_uInt32> StoreData( SvStream& ) const override;
virtual void CollAdd( SbxArray* pPar ) override;
virtual void CollRemove( SbxArray* pPar ) override;
public:
SBX_DECL_PERSIST_NODATA(SBXID_FIXCOLLECTION,1);
SbxStdCollection();
SbxStdCollection( const SbxStdCollection& );
SbxStdCollection& operator=( const SbxStdCollection& );
virtual void Insert( SbxVariable* ) override;
};
typedef tools::SvRef<SbxArray> SbxArrayRef;
typedef tools::SvRef<SbxInfo> SbxInfoRef;
typedef tools::SvRef<SbxDimArray> SbxDimArrayRef;
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink