replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added copy constructors and assignment operators to all lldb::SB* classes 

so we don't end up with weak exports with some compilers.

llvm-svn: 118312
This commit is contained in:
Greg Clayton 2010-11-05 23:17:00 +00:00
parent 2db0ea03ba
commit efabb123af
50 changed files with 585 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lldb/include/lldb/API/SBAddress.h
View File

@ -25,8 +25,8 @@ public:
~SBAddress ();
#ifndef SWIG
const SBAddress &
operator = (const SBAddress &rhs);
const lldb::SBAddress &
operator = (const lldb::SBAddress &rhs);
#endif
bool

7
lldb/include/lldb/API/SBBlock.h
View File

@ -20,8 +20,15 @@ public:
SBBlock ();
SBBlock (const lldb::SBBlock &rhs);
~SBBlock ();
#ifndef SWIG
const lldb::SBBlock &
operator = (const lldb::SBBlock &rhs);
#endif
bool
IsInlined () const;

4
lldb/include/lldb/API/SBBreakpoint.h
View File

@ -31,8 +31,8 @@ public:
~SBBreakpoint();
#ifndef SWIG
const SBBreakpoint &
operator = (const SBBreakpoint& rhs);
const lldb::SBBreakpoint &
operator = (const lldb::SBBreakpoint& rhs);
#endif
break_id_t

7
lldb/include/lldb/API/SBBreakpointLocation.h
View File

@ -21,8 +21,15 @@ public:
SBBreakpointLocation ();
SBBreakpointLocation (const lldb::SBBreakpointLocation &rhs);
~SBBreakpointLocation ();
#ifndef SWIG
const lldb::SBBreakpointLocation &
operator = (const lldb::SBBreakpointLocation &rhs);
#endif
bool
IsValid() const;

12
lldb/include/lldb/API/SBBroadcaster.h
View File

@ -21,6 +21,13 @@ public:
SBBroadcaster (const char *name);
SBBroadcaster (const SBBroadcaster &rhs);
#ifndef SWIG
const SBBroadcaster &
operator = (const SBBroadcaster &rhs);
#endif
~SBBroadcaster();
bool
@ -77,9 +84,8 @@ protected:
#endif
private:
lldb_private::Broadcaster *m_opaque;
bool m_opaque_owned;
lldb::BroadcasterSP m_opaque_sp;
lldb_private::Broadcaster *m_opaque_ptr;
};
} // namespace lldb

6
lldb/include/lldb/API/SBCommandInterpreter.h
View File

@ -24,6 +24,12 @@ public:
eBroadcastBitQuitCommandReceived = (1 << 2) // User entered quit
};
SBCommandInterpreter (const lldb::SBCommandInterpreter &rhs);
#ifndef SWIG
const lldb::SBCommandInterpreter &
operator = (const lldb::SBCommandInterpreter &rhs);
#endif
~SBCommandInterpreter ();

7
lldb/include/lldb/API/SBCommandReturnObject.h
View File

@ -20,6 +20,13 @@ public:
SBCommandReturnObject ();
SBCommandReturnObject (const lldb::SBCommandReturnObject &rhs);
#ifndef SWIG
const lldb::SBCommandReturnObject &
operator = (const lldb::SBCommandReturnObject &rhs);
#endif
~SBCommandReturnObject ();
bool

4
lldb/include/lldb/API/SBCommunication.h
View File

@ -84,8 +84,8 @@ public:
private:
// void
// CreateIfNeeded ();
DISALLOW_COPY_AND_ASSIGN (SBCommunication);
lldb_private::Communication *m_opaque;
bool m_opaque_owned;

7
lldb/include/lldb/API/SBCompileUnit.h
View File

@ -21,8 +21,15 @@ public:
SBCompileUnit ();
SBCompileUnit (const lldb::SBCompileUnit &rhs);
~SBCompileUnit ();
#ifndef SWIG
const lldb::SBCompileUnit &
operator = (const lldb::SBCompileUnit &rhs);
#endif
bool
IsValid () const;

7
lldb/include/lldb/API/SBDebugger.h
View File

@ -30,6 +30,13 @@ public:
SBDebugger();
SBDebugger(const lldb::SBDebugger &rhs);
#ifndef SWIG
lldb::SBDebugger &
operator = (const lldb::SBDebugger &rhs);
#endif
~SBDebugger();
bool

4
lldb/include/lldb/API/SBError.h
View File

@ -18,14 +18,14 @@ class SBError {
public:
SBError ();
SBError (const SBError &rhs);
SBError (const lldb::SBError &rhs);
~SBError();
#ifndef SWIG
const SBError &
operator =(const SBError &rhs);
operator =(const lldb::SBError &rhs);
#endif

9
lldb/include/lldb/API/SBEvent.h
View File

@ -30,6 +30,13 @@ public:
~SBEvent();
SBEvent (const lldb::SBEvent &rhs);
#ifndef SWIG
const SBEvent &
operator = (const lldb::SBEvent &rhs);
#endif
bool
IsValid() const;
@ -88,7 +95,7 @@ protected:
private:
mutable lldb::EventSP m_event_sp;
mutable lldb_private::Event *m_opaque;
mutable lldb_private::Event *m_opaque_ptr;
};
} // namespace lldb

7
lldb/include/lldb/API/SBFrame.h
View File

@ -22,6 +22,13 @@ class SBFrame
public:
SBFrame ();
SBFrame (const lldb::SBFrame &rhs);
#ifndef SWIG
const lldb::SBFrame &
operator =(const lldb::SBFrame &rhs);
#endif
~SBFrame();
bool

8
lldb/include/lldb/API/SBFunction.h
View File

@ -21,6 +21,14 @@ public:
SBFunction ();
SBFunction (const lldb::SBFunction &rhs);
#ifndef SWIG
const lldb::SBFunction &
operator = (const lldb::SBFunction &rhs);
#endif
~SBFunction ();
bool

2
lldb/include/lldb/API/SBInputReader.h
View File

@ -48,7 +48,7 @@ public:
IsValid () const;
#ifndef SWIG
const SBInputReader &
const lldb::SBInputReader &
operator = (const lldb::SBInputReader &rhs);
#endif

7
lldb/include/lldb/API/SBInstruction.h
View File

@ -25,6 +25,13 @@ public:
SBInstruction ();
SBInstruction (const SBInstruction &rhs);
#ifndef SWIG
const SBInstruction &
operator = (const SBInstruction &rhs);
#endif
~SBInstruction ();
bool

7
lldb/include/lldb/API/SBInstructionList.h
View File

@ -22,6 +22,13 @@ public:
SBInstructionList ();
SBInstructionList (const SBInstructionList &rhs);
#ifndef SWIG
const SBInstructionList &
operator = (const SBInstructionList &rhs);
#endif
~SBInstructionList ();
size_t

23
lldb/include/lldb/API/SBListener.h
View File

@ -17,14 +17,19 @@ namespace lldb {
class SBListener
{
public:
SBListener (const char *name);
SBListener (lldb_private::Listener &listener);
SBListener ();
SBListener (const char *name);
SBListener (const SBListener &rhs);
~SBListener ();
#ifndef SWIG
const lldb::SBListener &
operator = (const lldb::SBListener &rhs);
#endif
void
AddEvent (const lldb::SBEvent &event);
@ -85,12 +90,16 @@ public:
bool
HandleBroadcastEvent (const lldb::SBEvent &event);
private:
protected:
friend class SBBroadcaster;
friend class SBCommandInterpreter;
friend class SBDebugger;
friend class SBTarget;
SBListener (lldb_private::Listener &listener);
private:
#ifndef SWIG
lldb_private::Listener *
@ -110,10 +119,8 @@ private:
#endif
lldb::ListenerSP m_opaque_sp;
lldb_private::Listener *m_opaque_ptr;
bool m_opaque_ptr_owned;
};
} // namespace lldb

7
lldb/include/lldb/API/SBModule.h
View File

@ -21,6 +21,13 @@ public:
SBModule ();
SBModule (const SBModule &rhs);
#ifndef SWIG
const SBModule &
operator = (const SBModule &rhs);
#endif
~SBModule ();
bool

5
lldb/include/lldb/API/SBProcess.h
View File

@ -37,6 +37,11 @@ public:
SBProcess (const lldb::SBProcess& rhs);
#ifndef SWIG
const lldb::SBProcess&
operator = (const lldb::SBProcess& rhs);
#endif
~SBProcess();
void

14
lldb/include/lldb/API/SBSourceManager.h
View File

@ -19,8 +19,15 @@ namespace lldb {
class SBSourceManager
{
public:
SBSourceManager (const lldb::SBSourceManager &rhs);
~SBSourceManager();
#ifndef SWIG
const lldb::SBSourceManager &
operator = (const lldb::SBSourceManager &rhs);
#endif
size_t
DisplaySourceLinesWithLineNumbers (const lldb::SBFileSpec &file,
uint32_t line,
@ -34,14 +41,11 @@ protected:
friend class SBCommandInterpreter;
friend class SBDebugger;
SBSourceManager(lldb_private::SourceManager &source_manager);
lldb_private::SourceManager &
GetLLDBManager ();
SBSourceManager(lldb_private::SourceManager *source_manager);
private:
lldb_private::SourceManager &m_opaque_ref;
lldb_private::SourceManager *m_opaque_ptr;
};
} // namespace lldb

17
lldb/include/lldb/API/SBStringList.h
View File

@ -20,9 +20,12 @@ public:
SBStringList ();
SBStringList (const lldb_private::StringList *lldb_strings);
SBStringList (const lldb::SBStringList &rhs);
SBStringList (const lldb::SBStringList &rhs);
#ifndef SWIG
const SBStringList &
operator = (const SBStringList &rhs);
#endif
~SBStringList ();
@ -47,6 +50,11 @@ public:
void
Clear ();
protected:
friend class SBCommandInterpreter;
SBStringList (const lldb_private::StringList *lldb_strings);
#ifndef SWIG
const lldb_private::StringList *
@ -55,9 +63,6 @@ public:
const lldb_private::StringList &
operator*() const;
const lldb::SBStringList &
operator = (const lldb::SBStringList &rhs);
#endif
private:

7
lldb/include/lldb/API/SBSymbol.h
View File

@ -24,6 +24,13 @@ public:
~SBSymbol ();
SBSymbol (const lldb::SBSymbol &rhs);
#ifndef SWIG
const lldb::SBSymbol &
operator = (const lldb::SBSymbol &rhs);
#endif
bool
IsValid () const;

9
lldb/include/lldb/API/SBTarget.h
View File

@ -32,11 +32,16 @@ public:
};
//------------------------------------------------------------------
// Constructors and Destructors
// Constructors
//------------------------------------------------------------------
SBTarget ();
SBTarget (const lldb::SBTarget& rhs);
SBTarget (); // Required for SWIG.
#ifndef SWIG
const lldb::SBTarget&
operator = (const lldb::SBTarget& rhs);
#endif
//------------------------------------------------------------------
// Destructor

14
lldb/include/lldb/API/SBType.h
View File

@ -22,8 +22,15 @@ public:
SBType (void *ast = NULL, void *clang_type = NULL);
SBType (const SBType &rhs);
~SBType ();
#ifndef SWIG
const SBType &
operator =(const SBType &rhs);
#endif
bool
IsValid();
@ -68,6 +75,13 @@ public:
SBTypeMember ();
SBTypeMember (const SBTypeMember &rhs);
#ifndef SWIG
const SBTypeMember&
operator =(const SBTypeMember &rhs);
#endif
~SBTypeMember ();
bool

7
lldb/include/lldb/API/SBValue.h
View File

@ -21,6 +21,13 @@ class SBValue
public:
SBValue ();
SBValue (const SBValue &rhs);
#ifndef SWIG
const SBValue &
operator =(const SBValue &rhs);
#endif
~SBValue ();
bool

19
lldb/lldb.xcodeproj/project.pbxproj
View File

@ -2438,6 +2438,7 @@
isa = PBXProject;
buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "lldb" */;
compatibilityVersion = "Xcode 3.1";
developmentRegion = English;
hasScannedForEncodings = 1;
knownRegions = (
en,
@ -2997,9 +2998,9 @@
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
COPY_PHASE_STRIP = NO;
CURRENT_PROJECT_VERSION = 29;
CURRENT_PROJECT_VERSION = 30;
DYLIB_COMPATIBILITY_VERSION = 1;
DYLIB_CURRENT_VERSION = 29;
DYLIB_CURRENT_VERSION = 30;
EXPORTED_SYMBOLS_FILE = "resources/lldb-framework-exports";
FRAMEWORK_SEARCH_PATHS = (
"$(inherited)",
@ -3050,11 +3051,11 @@
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
COPY_PHASE_STRIP = NO;
CURRENT_PROJECT_VERSION = 29;
CURRENT_PROJECT_VERSION = 30;
DEAD_CODE_STRIPPING = YES;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
DYLIB_COMPATIBILITY_VERSION = 1;
DYLIB_CURRENT_VERSION = 29;
DYLIB_CURRENT_VERSION = 30;
EXPORTED_SYMBOLS_FILE = "resources/lldb-framework-exports";
FRAMEWORK_SEARCH_PATHS = (
"$(inherited)",
@ -3124,7 +3125,7 @@
isa = XCBuildConfiguration;
buildSettings = {
COPY_PHASE_STRIP = YES;
CURRENT_PROJECT_VERSION = 29;
CURRENT_PROJECT_VERSION = 30;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
FRAMEWORK_SEARCH_PATHS = (
"$(inherited)",
@ -3159,11 +3160,11 @@
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
COPY_PHASE_STRIP = YES;
CURRENT_PROJECT_VERSION = 29;
CURRENT_PROJECT_VERSION = 30;
DEAD_CODE_STRIPPING = YES;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
DYLIB_COMPATIBILITY_VERSION = 1;
DYLIB_CURRENT_VERSION = 29;
DYLIB_CURRENT_VERSION = 30;
EXPORTED_SYMBOLS_FILE = "resources/lldb-framework-exports";
FRAMEWORK_SEARCH_PATHS = (
"$(inherited)",
@ -3212,7 +3213,7 @@
buildSettings = {
CODE_SIGN_IDENTITY = lldb_codesign;
COPY_PHASE_STRIP = NO;
CURRENT_PROJECT_VERSION = 29;
CURRENT_PROJECT_VERSION = 30;
FRAMEWORK_SEARCH_PATHS = (
"$(inherited)",
"\"$(SYSTEM_LIBRARY_DIR)/PrivateFrameworks\"",
@ -3251,7 +3252,7 @@
);
CODE_SIGN_IDENTITY = lldb_codesign;
COPY_PHASE_STRIP = YES;
CURRENT_PROJECT_VERSION = 29;
CURRENT_PROJECT_VERSION = 30;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
FRAMEWORK_SEARCH_PATHS = (
"$(inherited)",

2
lldb/resources/LLDB-Info.plist
View File

@ -17,7 +17,7 @@
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleVersion</key>
<string>29</string>
<string>30</string>
<key>CFBundleName</key>
<string>${EXECUTABLE_NAME}</string>
</dict>

12
lldb/source/API/SBBlock.cpp
View File

@ -28,6 +28,18 @@ SBBlock::SBBlock (lldb_private::Block *lldb_object_ptr) :
{
}
SBBlock::SBBlock(const SBBlock &rhs) :
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBBlock &
SBBlock::operator = (const SBBlock &rhs)
{
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBBlock::~SBBlock ()
{
m_opaque_ptr = NULL;

17
lldb/source/API/SBBreakpointLocation.cpp
View File

@ -25,7 +25,8 @@ using namespace lldb;
using namespace lldb_private;
SBBreakpointLocation::SBBreakpointLocation ()
SBBreakpointLocation::SBBreakpointLocation () :
m_opaque_sp ()
{
}
@ -43,6 +44,20 @@ SBBreakpointLocation::SBBreakpointLocation (const lldb::BreakpointLocationSP &br
}
}
SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) :
m_opaque_sp (rhs.m_opaque_sp)
{
}
const SBBreakpointLocation &
SBBreakpointLocation::operator = (const SBBreakpointLocation &rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBBreakpointLocation::~SBBreakpointLocation ()
{
}

96
lldb/source/API/SBBroadcaster.cpp
View File

@ -20,36 +20,49 @@ using namespace lldb_private;
SBBroadcaster::SBBroadcaster () :
m_opaque (NULL),
m_opaque_owned (false)
m_opaque_sp (),
m_opaque_ptr (NULL)
{
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
if (log)
log->Printf ("SBBroadcastetr::SBBroadcaster () => SBBroadcaster(%p)", this);
}
SBBroadcaster::SBBroadcaster (const char *name) :
m_opaque (new Broadcaster (name)),
m_opaque_owned (true)
m_opaque_sp (new Broadcaster (name)),
m_opaque_ptr (NULL)
{
m_opaque_ptr = m_opaque_sp.get();
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
if (log)
log->Printf ("SBBroadcaster::SBBroadcaster (name=\"%s\") => SBBroadcaster(%p)",
name, m_opaque);
name, m_opaque_ptr);
}
SBBroadcaster::SBBroadcaster (lldb_private::Broadcaster *broadcaster, bool owns) :
m_opaque (broadcaster),
m_opaque_owned (owns)
m_opaque_sp (owns ? broadcaster : NULL),
m_opaque_ptr (broadcaster)
{
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE);
if (log)
log->Printf ("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) "
" => SBBroadcaster(%p)", broadcaster, owns, m_opaque);
log->Printf ("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) => SBBroadcaster(%p)",
broadcaster, owns, m_opaque_ptr);
}
SBBroadcaster::SBBroadcaster (const SBBroadcaster &rhs) :
m_opaque_sp (rhs.m_opaque_sp),
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBBroadcaster &
SBBroadcaster::operator = (const SBBroadcaster &rhs)
{
if (this != &rhs)
{
m_opaque_sp = rhs.m_opaque_sp;
m_opaque_ptr = rhs.m_opaque_ptr;
}
return *this;
}
SBBroadcaster::~SBBroadcaster()
@ -63,15 +76,15 @@ SBBroadcaster::BroadcastEventByType (uint32_t event_type, bool unique)
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
if (log)
log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, unique=%i)", m_opaque, event_type, unique);
log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, unique=%i)", m_opaque_ptr, event_type, unique);
if (m_opaque == NULL)
if (m_opaque_ptr == NULL)
return;
if (unique)
m_opaque->BroadcastEventIfUnique (event_type);
m_opaque_ptr->BroadcastEventIfUnique (event_type);
else
m_opaque->BroadcastEvent (event_type);
m_opaque_ptr->BroadcastEvent (event_type);
}
void
@ -80,16 +93,16 @@ SBBroadcaster::BroadcastEvent (const SBEvent &event, bool unique)
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
if (log)
log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)", m_opaque, event.get(), unique);
log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)", m_opaque_ptr, event.get(), unique);
if (m_opaque == NULL)
if (m_opaque_ptr == NULL)
return;
EventSP event_sp = event.GetSP ();
if (unique)
m_opaque->BroadcastEventIfUnique (event_sp);
m_opaque_ptr->BroadcastEventIfUnique (event_sp);
else
m_opaque->BroadcastEvent (event_sp);
m_opaque_ptr->BroadcastEvent (event_sp);
}
void
@ -97,74 +110,75 @@ SBBroadcaster::AddInitialEventsToListener (const SBListener &listener, uint32_t
{
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
if (log)
log->Printf ("SBBroadcaster(%p)::AddInitialEventsToListener (SBListener(%p), event_mask=0x%8.8x)", m_opaque, listener.get(), requested_events);
if (m_opaque)
m_opaque->AddInitialEventsToListener (listener.get(), requested_events);
log->Printf ("SBBroadcaster(%p)::AddInitialEventsToListener (SBListener(%p), event_mask=0x%8.8x)", m_opaque_ptr, listener.get(), requested_events);
if (m_opaque_ptr)
m_opaque_ptr->AddInitialEventsToListener (listener.get(), requested_events);
}
uint32_t
SBBroadcaster::AddListener (const SBListener &listener, uint32_t event_mask)
{
if (m_opaque)
return m_opaque->AddListener (listener.get(), event_mask);
if (m_opaque_ptr)
return m_opaque_ptr->AddListener (listener.get(), event_mask);
return 0;
}
const char *
SBBroadcaster::GetName () const
{
if (m_opaque)
return m_opaque->GetBroadcasterName().GetCString();
if (m_opaque_ptr)
return m_opaque_ptr->GetBroadcasterName().GetCString();
return NULL;
}
bool
SBBroadcaster::EventTypeHasListeners (uint32_t event_type)
{
if (m_opaque)
return m_opaque->EventTypeHasListeners (event_type);
if (m_opaque_ptr)
return m_opaque_ptr->EventTypeHasListeners (event_type);
return false;
}
bool
SBBroadcaster::RemoveListener (const SBListener &listener, uint32_t event_mask)
{
if (m_opaque)
return m_opaque->RemoveListener (listener.get(), event_mask);
if (m_opaque_ptr)
return m_opaque_ptr->RemoveListener (listener.get(), event_mask);
return false;
}
Broadcaster *
SBBroadcaster::get () const
{
return m_opaque;
return m_opaque_ptr;
}
void
SBBroadcaster::reset (Broadcaster *broadcaster, bool owns)
{
if (m_opaque && m_opaque_owned)
delete m_opaque;
m_opaque = broadcaster;
m_opaque_owned = owns;
if (owns)
m_opaque_sp.reset (broadcaster);
else
m_opaque_sp.reset ();
m_opaque_ptr = broadcaster;
}
bool
SBBroadcaster::IsValid () const
{
return m_opaque != NULL;
return m_opaque_ptr != NULL;
}
bool
SBBroadcaster::operator == (const SBBroadcaster &rhs) const
{
return m_opaque == rhs.m_opaque;
return m_opaque_ptr == rhs.m_opaque_ptr;
}
bool
SBBroadcaster::operator != (const SBBroadcaster &rhs) const
{
return m_opaque != rhs.m_opaque;
return m_opaque_ptr != rhs.m_opaque_ptr;
}

12
lldb/source/API/SBCommandInterpreter.cpp
View File

@ -40,6 +40,18 @@ SBCommandInterpreter::SBCommandInterpreter (CommandInterpreter *interpreter) :
" => SBCommandInterpreter(%p)", interpreter, m_opaque_ptr);
}
SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) :
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBCommandInterpreter &
SBCommandInterpreter::operator = (const SBCommandInterpreter &rhs)
{
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBCommandInterpreter::~SBCommandInterpreter ()
{
}

21
lldb/source/API/SBCommandReturnObject.cpp
View File

@ -21,6 +21,27 @@ SBCommandReturnObject::SBCommandReturnObject () :
{
}
SBCommandReturnObject::SBCommandReturnObject (const SBCommandReturnObject &rhs):
m_opaque_ap ()
{
if (rhs.m_opaque_ap.get())
m_opaque_ap.reset (new CommandReturnObject (*rhs.m_opaque_ap));
}
const SBCommandReturnObject &
SBCommandReturnObject::operator = (const SBCommandReturnObject &rhs)
{
if (this != &rhs)
{
if (rhs.m_opaque_ap.get())
m_opaque_ap.reset (new CommandReturnObject (*rhs.m_opaque_ap));
else
m_opaque_ap.reset();
}
return *this;
}
SBCommandReturnObject::~SBCommandReturnObject ()
{
// m_opaque_ap will automatically delete any pointer it owns

13
lldb/source/API/SBCompileUnit.cpp
View File

@ -29,6 +29,19 @@ SBCompileUnit::SBCompileUnit (lldb_private::CompileUnit *lldb_object_ptr) :
{
}
SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs) :
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBCompileUnit &
SBCompileUnit::operator = (const SBCompileUnit &rhs)
{
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBCompileUnit::~SBCompileUnit ()
{
m_opaque_ptr = NULL;

17
lldb/source/API/SBDebugger.cpp
View File

@ -85,6 +85,21 @@ SBDebugger::SBDebugger () :
{
}
SBDebugger::SBDebugger(const SBDebugger &rhs) :
m_opaque_sp (rhs.m_opaque_sp)
{
}
SBDebugger &
SBDebugger::operator = (const SBDebugger &rhs)
{
if (this != &rhs)
{
m_opaque_sp = rhs.m_opaque_sp;
}
return *this;
}
SBDebugger::~SBDebugger ()
{
}
@ -355,7 +370,7 @@ SBSourceManager &
SBDebugger::GetSourceManager ()
{
static SourceManager g_lldb_source_manager;
static SBSourceManager g_sb_source_manager (g_lldb_source_manager);
static SBSourceManager g_sb_source_manager (&g_lldb_source_manager);
return g_sb_source_manager;
}

40
lldb/source/API/SBEvent.cpp
View File

@ -25,22 +25,40 @@ using namespace lldb_private;
SBEvent::SBEvent () :
m_event_sp (),
m_opaque (NULL)
m_opaque_ptr (NULL)
{
}
SBEvent::SBEvent (uint32_t event_type, const char *cstr, uint32_t cstr_len) :
m_event_sp (new Event (event_type, new EventDataBytes (cstr, cstr_len))),
m_opaque (m_event_sp.get())
m_opaque_ptr (m_event_sp.get())
{
}
SBEvent::SBEvent (EventSP &event_sp) :
m_event_sp (event_sp),
m_opaque (event_sp.get())
m_opaque_ptr (event_sp.get())
{
}
SBEvent::SBEvent (const SBEvent &rhs) :
m_event_sp (rhs.m_event_sp),
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBEvent &
SBEvent::operator = (const SBEvent &rhs)
{
if (this != &rhs)
{
m_event_sp = rhs.m_event_sp;
m_opaque_ptr = rhs.m_opaque_ptr;
}
return *this;
}
SBEvent::~SBEvent()
{
}
@ -136,31 +154,31 @@ SBEvent::get() const
// There is a dangerous accessor call GetSharedPtr which can be used, so if
// we have anything valid in m_event_sp, we must use that since if it gets
// used by a function that puts something in there, then it won't update
// m_opaque...
// m_opaque_ptr...
if (m_event_sp)
m_opaque = m_event_sp.get();
m_opaque_ptr = m_event_sp.get();
return m_opaque;
return m_opaque_ptr;
}
void
SBEvent::reset (EventSP &event_sp)
{
m_event_sp = event_sp;
m_opaque = m_event_sp.get();
m_opaque_ptr = m_event_sp.get();
}
void
SBEvent::reset (Event* event_ptr)
{
m_opaque = event_ptr;
m_opaque_ptr = event_ptr;
m_event_sp.reset();
}
bool
SBEvent::IsValid() const
{
// Do NOT use m_opaque directly!!! Must use the SBEvent::get()
// Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get()
// accessor. See comments in SBEvent::get()....
return SBEvent::get() != NULL;
@ -186,7 +204,7 @@ SBEvent::GetDescription (SBStream &description)
if (get())
{
description.ref();
m_opaque->Dump (description.get());
m_opaque_ptr->Dump (description.get());
}
else
description.Printf ("No value");
@ -200,7 +218,7 @@ SBEvent::GetDescription (SBStream &description) const
if (get())
{
description.ref();
m_opaque->Dump (description.get());
m_opaque_ptr->Dump (description.get());
}
else
description.Printf ("No value");

13
lldb/source/API/SBFrame.cpp
View File

@ -63,6 +63,19 @@ SBFrame::SBFrame (const lldb::StackFrameSP &lldb_object_sp) :
}
}
SBFrame::SBFrame(const SBFrame &rhs) :
m_opaque_sp (rhs.m_opaque_sp)
{
}
const SBFrame &
SBFrame::operator = (const SBFrame &rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBFrame::~SBFrame()
{
}

12
lldb/source/API/SBFunction.cpp
View File

@ -32,6 +32,18 @@ SBFunction::SBFunction (lldb_private::Function *lldb_object_ptr) :
{
}
SBFunction::SBFunction (const lldb::SBFunction &rhs) :
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBFunction &
SBFunction::operator = (const SBFunction &rhs)
{
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBFunction::~SBFunction ()
{
m_opaque_ptr = NULL;

13
lldb/source/API/SBInstruction.cpp
View File

@ -28,6 +28,19 @@ SBInstruction::SBInstruction (const lldb::InstructionSP& inst_sp) :
{
}
SBInstruction::SBInstruction(const SBInstruction &rhs) :
m_opaque_sp (rhs.m_opaque_sp)
{
}
const SBInstruction &
SBInstruction::operator = (const SBInstruction &rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBInstruction::~SBInstruction ()
{
}

14
lldb/source/API/SBInstructionList.cpp
View File

@ -22,6 +22,20 @@ SBInstructionList::SBInstructionList () :
{
}
SBInstructionList::SBInstructionList(const SBInstructionList &rhs) :
m_opaque_sp (rhs.m_opaque_sp)
{
}
const SBInstructionList &
SBInstructionList::operator = (const SBInstructionList &rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBInstructionList::~SBInstructionList ()
{
}

49
lldb/source/API/SBListener.cpp
View File

@ -23,15 +23,17 @@ using namespace lldb_private;
SBListener::SBListener () :
m_opaque_ptr (NULL),
m_opaque_ptr_owned (false)
m_opaque_sp (),
m_opaque_ptr (NULL)
{
}
SBListener::SBListener (const char *name) :
m_opaque_ptr (new Listener (name)),
m_opaque_ptr_owned (true)
m_opaque_sp (new Listener (name)),
m_opaque_ptr (NULL)
{
m_opaque_ptr = m_opaque_sp.get();
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
if (log)
@ -39,22 +41,32 @@ SBListener::SBListener (const char *name) :
name, m_opaque_ptr);
}
SBListener::SBListener (const SBListener &rhs) :
m_opaque_sp (rhs.m_opaque_sp),
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const lldb::SBListener &
SBListener::operator = (const lldb::SBListener &rhs)
{
if (this != &rhs)
{
m_opaque_sp = rhs.m_opaque_sp;
m_opaque_ptr = rhs.m_opaque_ptr;
}
return *this;
}
SBListener::SBListener (Listener &listener) :
m_opaque_ptr (&listener),
m_opaque_ptr_owned (false)
m_opaque_sp (),
m_opaque_ptr (&listener)
{
}
SBListener::~SBListener ()
{
if (m_opaque_ptr_owned)
{
if (m_opaque_ptr)
{
delete m_opaque_ptr;
m_opaque_ptr = NULL;
}
}
}
bool
@ -365,11 +377,12 @@ SBListener::get() const
}
void
SBListener::reset(Listener *listener, bool transfer_ownership)
SBListener::reset(Listener *listener, bool owns)
{
if (m_opaque_ptr_owned && m_opaque_ptr)
delete m_opaque_ptr;
m_opaque_ptr_owned = transfer_ownership;
if (owns)
m_opaque_sp.reset (listener);
else
m_opaque_sp.reset ();
m_opaque_ptr = listener;
}

13
lldb/source/API/SBModule.cpp
View File

@ -30,6 +30,19 @@ SBModule::SBModule (const lldb::ModuleSP& module_sp) :
{
}
SBModule::SBModule(const SBModule &rhs) :
m_opaque_sp (rhs.m_opaque_sp)
{
}
const SBModule &
SBModule::operator = (const SBModule &rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBModule::~SBModule ()
{
}

8
lldb/source/API/SBProcess.cpp
View File

@ -61,6 +61,14 @@ SBProcess::SBProcess (const lldb::ProcessSP &process_sp) :
{
}
const SBProcess&
SBProcess::operator = (const SBProcess& rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------

37
lldb/source/API/SBSourceManager.cpp
View File

@ -20,8 +20,8 @@ using namespace lldb;
using namespace lldb_private;
SBSourceManager::SBSourceManager (SourceManager& source_manager) :
m_opaque_ref (source_manager)
SBSourceManager::SBSourceManager (SourceManager* source_manager) :
m_opaque_ptr (source_manager)
{
}
@ -29,6 +29,18 @@ SBSourceManager::~SBSourceManager()
{
}
SBSourceManager::SBSourceManager(const SBSourceManager &rhs) :
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBSourceManager &
SBSourceManager::operator = (const SBSourceManager &rhs)
{
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
size_t
SBSourceManager::DisplaySourceLinesWithLineNumbers
(
@ -40,6 +52,9 @@ SBSourceManager::DisplaySourceLinesWithLineNumbers
FILE *f
)
{
if (m_opaque_ptr == NULL)
return 0;
if (f == NULL)
return 0;
@ -48,18 +63,12 @@ SBSourceManager::DisplaySourceLinesWithLineNumbers
StreamFile str (f);
return m_opaque_ref.DisplaySourceLinesWithLineNumbers (*file,
line,
context_before,
context_after,
current_line_cstr,
&str);
return m_opaque_ptr->DisplaySourceLinesWithLineNumbers (*file,
line,
context_before,
context_after,
current_line_cstr,
&str);
}
return 0;
}
SourceManager &
SBSourceManager::GetLLDBManager ()
{
return m_opaque_ref;
}

20
lldb/source/API/SBStringList.cpp
View File

@ -34,21 +34,23 @@ SBStringList::SBStringList (const SBStringList &rhs) :
}
SBStringList::~SBStringList ()
{
}
const SBStringList &
SBStringList::operator = (const SBStringList &rhs)
{
if (rhs.IsValid())
m_opaque_ap.reset (new lldb_private::StringList(*rhs));
if (this != &rhs)
{
if (rhs.IsValid())
m_opaque_ap.reset(new lldb_private::StringList(*rhs));
else
m_opaque_ap.reset();
}
return *this;
}
SBStringList::~SBStringList ()
{
}
const lldb_private::StringList *
SBStringList::operator->() const
{

13
lldb/source/API/SBSymbol.cpp
View File

@ -29,6 +29,19 @@ SBSymbol::SBSymbol (lldb_private::Symbol *lldb_object_ptr) :
{
}
SBSymbol::SBSymbol (const lldb::SBSymbol &rhs) :
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBSymbol &
SBSymbol::operator = (const SBSymbol &rhs)
{
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBSymbol::~SBSymbol ()
{
m_opaque_ptr = NULL;

8
lldb/source/API/SBTarget.cpp
View File

@ -64,6 +64,14 @@ SBTarget::SBTarget(const TargetSP& target_sp) :
{
}
const SBTarget&
SBTarget::operator = (const SBTarget& rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------

45
lldb/source/API/SBType.cpp
View File

@ -40,7 +40,21 @@ SBType::SBType (void *ast, void *clang_type) :
m_type (clang_type)
{
}
SBType::SBType (const SBType &rhs) :
m_ast (rhs.m_ast),
m_type (rhs.m_type)
{
}
const SBType &
SBType::operator =(const SBType &rhs)
{
m_ast = rhs.m_ast;
m_type = rhs.m_type;
return *this;
}
SBType::~SBType ()
{
}
@ -212,6 +226,35 @@ SBTypeMember::SBTypeMember () :
{
}
SBTypeMember::SBTypeMember (const SBTypeMember &rhs) :
m_ast (rhs.m_ast),
m_parent_type (rhs.m_parent_type),
m_member_type (rhs.m_member_type),
m_member_name (rhs.m_member_name),
m_offset (rhs.m_offset),
m_bit_size (rhs.m_bit_size),
m_bit_offset (rhs.m_bit_offset),
m_is_base_class (rhs.m_is_base_class)
{
}
const SBTypeMember&
SBTypeMember::operator =(const SBTypeMember &rhs)
{
if (this != &rhs)
{
m_ast = rhs.m_ast;
m_parent_type = rhs.m_parent_type;
m_member_type = rhs.m_member_type;
m_member_name = rhs.m_member_name;
m_offset = rhs.m_offset;
m_bit_size = rhs.m_bit_size;
m_bit_offset = rhs.m_bit_offset;
m_is_base_class = rhs.m_is_base_class;
}
return *this;
}
SBTypeMember::~SBTypeMember ()
{
SetName (NULL);

13
lldb/source/API/SBValue.cpp
View File

@ -44,6 +44,19 @@ SBValue::SBValue (const lldb::ValueObjectSP &value_sp) :
{
}
SBValue::SBValue(const SBValue &rhs) :
m_opaque_sp (rhs.m_opaque_sp)
{
}
const SBValue &
SBValue::operator = (const SBValue &rhs)
{
if (this != &rhs)
m_opaque_sp = rhs.m_opaque_sp;
return *this;
}
SBValue::~SBValue()
{
}

12
lldb/tools/debugserver/debugserver.xcodeproj/project.pbxproj
View File

@ -456,7 +456,7 @@
i386,
);
COPY_PHASE_STRIP = NO;
CURRENT_PROJECT_VERSION = 116;
CURRENT_PROJECT_VERSION = 117;
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
STRIP_INSTALLED_PRODUCT = NO;
@ -474,7 +474,7 @@
x86_64,
i386,
);
CURRENT_PROJECT_VERSION = 116;
CURRENT_PROJECT_VERSION = 117;
DEAD_CODE_STRIPPING = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
@ -494,7 +494,7 @@
x86_64,
i386,
);
CURRENT_PROJECT_VERSION = 116;
CURRENT_PROJECT_VERSION = 117;
DEAD_CODE_STRIPPING = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
@ -511,7 +511,7 @@
buildSettings = {
"CODE_SIGN_ENTITLEMENTS[sdk=iphoneos*]" = "source/debugserver-entitlements.plist";
COPY_PHASE_STRIP = YES;
CURRENT_PROJECT_VERSION = 116;
CURRENT_PROJECT_VERSION = 117;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
FRAMEWORK_SEARCH_PATHS = $SDKROOT/System/Library/PrivateFrameworks;
"FRAMEWORK_SEARCH_PATHS[sdk=iphoneos*][arch=*]" = (
@ -552,7 +552,7 @@
"CODE_SIGN_ENTITLEMENTS[sdk=iphoneos*]" = "source/debugserver-entitlements.plist";
"CODE_SIGN_IDENTITY[sdk=macosx*]" = lldb_codesign;
COPY_PHASE_STRIP = YES;
CURRENT_PROJECT_VERSION = 116;
CURRENT_PROJECT_VERSION = 117;
FRAMEWORK_SEARCH_PATHS = $SDKROOT/System/Library/PrivateFrameworks;
"FRAMEWORK_SEARCH_PATHS[sdk=iphoneos*][arch=*]" = (
"$(SDKROOT)/System/Library/PrivateFrameworks",
@ -593,7 +593,7 @@
"CODE_SIGN_ENTITLEMENTS[sdk=iphoneos*]" = "source/debugserver-entitlements.plist";
"CODE_SIGN_IDENTITY[sdk=macosx*]" = lldb_codesign;
COPY_PHASE_STRIP = YES;
CURRENT_PROJECT_VERSION = 116;
CURRENT_PROJECT_VERSION = 117;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
FRAMEWORK_SEARCH_PATHS = $SDKROOT/System/Library/PrivateFrameworks;
"FRAMEWORK_SEARCH_PATHS[sdk=iphoneos*][arch=*]" = (