lldb/source/Core/Event.cpp - toolchain/llvm-project - Gitiles

 //===-- Event.cpp -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 // C Includes
 // C++ Includes
 #include <algorithm>

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Target/Process.h"

 using namespace lldb;
 using namespace lldb_private;

 #pragma mark -
 #pragma mark Event

 //------------------------------------------------------------------
 // Event functions
 //------------------------------------------------------------------

 Event::Event (Broadcaster *broadcaster, uint32_t event_type, EventData *data) :
     m_broadcaster_wp(broadcaster->GetBroadcasterImpl()),
     m_type(event_type),
     m_data_sp(data)
 {
 }

 Event::Event (Broadcaster *broadcaster, uint32_t event_type, const EventDataSP &event_data_sp) :
     m_broadcaster_wp(broadcaster->GetBroadcasterImpl()),
     m_type(event_type),
     m_data_sp(event_data_sp)
 {
 }

 Event::Event(uint32_t event_type, EventData *data) :
     m_broadcaster_wp(),
     m_type(event_type),
     m_data_sp(data)
 {
 }

 Event::Event(uint32_t event_type, const EventDataSP &event_data_sp) :
     m_broadcaster_wp(),
     m_type(event_type),
     m_data_sp(event_data_sp)
 {
 }

 Event::~Event() = default;

 void
 Event::Dump (Stream *s) const
 {
     Broadcaster *broadcaster;
     Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock());
     if (broadcaster_impl_sp)
         broadcaster = broadcaster_impl_sp->GetBroadcaster();
     else
         broadcaster = nullptr;

     if (broadcaster)
     {
         StreamString event_name;
         if (broadcaster->GetEventNames (event_name, m_type, false))
             s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
                       static_cast<const void*>(this),
                       static_cast<void*>(broadcaster),
                       broadcaster->GetBroadcasterName().GetCString(),
                       m_type, event_name.GetString().c_str());
         else
             s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
                       static_cast<const void*>(this),
                       static_cast<void*>(broadcaster),
                       broadcaster->GetBroadcasterName().GetCString(), m_type);
     }
     else
         s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
                   static_cast<const void*>(this), m_type);

     if (m_data_sp)
     {
         s->PutChar('{');
         m_data_sp->Dump (s);
         s->PutChar('}');
     }
     else
         s->Printf ("<NULL>");
 }

 void
 Event::DoOnRemoval ()
 {
     if (m_data_sp)
         m_data_sp->DoOnRemoval (this);
 }

 #pragma mark -
 #pragma mark EventData

 //------------------------------------------------------------------
 // EventData functions
 //------------------------------------------------------------------

 EventData::EventData() = default;

 EventData::~EventData() = default;

 void
 EventData::Dump (Stream *s) const
 {
     s->PutCString ("Generic Event Data");
 }

 #pragma mark -
 #pragma mark EventDataBytes

 //------------------------------------------------------------------
 // EventDataBytes functions
 //------------------------------------------------------------------


 EventDataBytes::EventDataBytes () :
     m_bytes()
 {
 }

 EventDataBytes::EventDataBytes (const char *cstr) :
     m_bytes()
 {
     SetBytesFromCString (cstr);
 }

 EventDataBytes::EventDataBytes (const void *src, size_t src_len) :
     m_bytes()
 {
     SetBytes (src, src_len);
 }

 EventDataBytes::~EventDataBytes() = default;

 const ConstString &
 EventDataBytes::GetFlavorString ()
 {
     static ConstString g_flavor ("EventDataBytes");
     return g_flavor;
 }

 const ConstString &
 EventDataBytes::GetFlavor () const
 {
     return EventDataBytes::GetFlavorString ();
 }

 void
 EventDataBytes::Dump (Stream *s) const
 {
     size_t num_printable_chars = std::count_if (m_bytes.begin(), m_bytes.end(), isprint);
     if (num_printable_chars == m_bytes.size())
     {
         s->Printf("\"%s\"", m_bytes.c_str());
     }
     else if (!m_bytes.empty())
     {
         DataExtractor data;
         data.SetData(m_bytes.data(), m_bytes.size(), endian::InlHostByteOrder());
         data.Dump(s, 0, eFormatBytes, 1, m_bytes.size(), 32, LLDB_INVALID_ADDRESS, 0, 0);
     }
 }

 const void *
 EventDataBytes::GetBytes() const
 {
     return (m_bytes.empty() ? nullptr : m_bytes.data());
 }

 size_t
 EventDataBytes::GetByteSize() const
 {
     return m_bytes.size ();
 }

 void
 EventDataBytes::SetBytes (const void *src, size_t src_len)
 {
     if (src != nullptr && src_len > 0)
         m_bytes.assign ((const char *)src, src_len);
     else
         m_bytes.clear();
 }

 void
 EventDataBytes::SetBytesFromCString (const char *cstr)
 {
     if (cstr != nullptr && cstr[0])
         m_bytes.assign (cstr);
     else
         m_bytes.clear();
 }

 const void *
 EventDataBytes::GetBytesFromEvent (const Event *event_ptr)
 {
     const EventDataBytes *e = GetEventDataFromEvent (event_ptr);
     if (e != nullptr)
         return e->GetBytes();
     return nullptr;
 }

 size_t
 EventDataBytes::GetByteSizeFromEvent (const Event *event_ptr)
 {
     const EventDataBytes *e = GetEventDataFromEvent (event_ptr);
     if (e != nullptr)
         return e->GetByteSize();
     return 0;
 }

 const EventDataBytes *
 EventDataBytes::GetEventDataFromEvent (const Event *event_ptr)
 {
     if (event_ptr != nullptr)
     {
         const EventData *event_data = event_ptr->GetData();
         if (event_data && event_data->GetFlavor() == EventDataBytes::GetFlavorString())
             return static_cast <const EventDataBytes *> (event_data);
     }
     return nullptr;
 }

 void
 EventDataBytes::SwapBytes (std::string &new_bytes)
 {
     m_bytes.swap (new_bytes);
 }

 #pragma mark -
 #pragma mark EventStructuredData

 //------------------------------------------------------------------
 // EventDataStructuredData definitions
 //------------------------------------------------------------------

 EventDataStructuredData::EventDataStructuredData() :
     EventData(),
     m_process_sp(),
     m_object_sp(),
     m_plugin_sp()
 {
 }

 EventDataStructuredData::EventDataStructuredData(const ProcessSP &process_sp,
                                                  const StructuredData::ObjectSP
                                                  &object_sp,
                                                  const
                                                  lldb::StructuredDataPluginSP
                                                  &plugin_sp) :
     EventData(),
     m_process_sp(process_sp),
     m_object_sp(object_sp),
     m_plugin_sp(plugin_sp)
 {
 }

 EventDataStructuredData::~EventDataStructuredData()
 {
 }

 //------------------------------------------------------------------
 // EventDataStructuredData member functions
 //------------------------------------------------------------------

 const ConstString &
 EventDataStructuredData::GetFlavor() const
 {
     return EventDataStructuredData::GetFlavorString();
 }

 void
 EventDataStructuredData::Dump(Stream *s) const
 {
     if (!s)
         return;

     if (m_object_sp)
         m_object_sp->Dump(*s);
 }

 const ProcessSP&
 EventDataStructuredData::GetProcess() const
 {
     return m_process_sp;
 }

 const StructuredData::ObjectSP&
 EventDataStructuredData::GetObject() const
 {
     return m_object_sp;
 }

 const lldb::StructuredDataPluginSP&
 EventDataStructuredData::GetStructuredDataPlugin() const
 {
     return m_plugin_sp;
 }

 void
 EventDataStructuredData::SetProcess(const ProcessSP &process_sp)
 {
     m_process_sp = process_sp;
 }

 void
 EventDataStructuredData::SetObject(const StructuredData::ObjectSP &object_sp)
 {
     m_object_sp = object_sp;
 }

 void
 EventDataStructuredData::SetStructuredDataPlugin(const
                                                  lldb::StructuredDataPluginSP
                                                  &plugin_sp)
 {
     m_plugin_sp = plugin_sp;
 }

 //------------------------------------------------------------------
 // EventDataStructuredData static functions
 //------------------------------------------------------------------

 const EventDataStructuredData*
 EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr)
 {
     if (event_ptr == nullptr)
         return nullptr;

     const EventData *event_data = event_ptr->GetData();
     if (!event_data || event_data->GetFlavor() !=
         EventDataStructuredData::GetFlavorString())
         return nullptr;

     return static_cast<const EventDataStructuredData*>(event_data);
 }

 ProcessSP
 EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr)
 {
     auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
     if (event_data)
         return event_data->GetProcess();
     else
         return ProcessSP();
 }

 StructuredData::ObjectSP
 EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr)
 {
     auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
     if (event_data)
         return event_data->GetObject();
     else
         return StructuredData::ObjectSP();
 }

 lldb::StructuredDataPluginSP
 EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr)
 {
     auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
     if (event_data)
         return event_data->GetStructuredDataPlugin();
     else
         return StructuredDataPluginSP();
 }

 const ConstString &
 EventDataStructuredData::GetFlavorString ()
 {
     static ConstString s_flavor("EventDataStructuredData");
     return s_flavor;
 }
	//===-- Event.cpp ------------------------------------------------ C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	// C Includes
	// C++ Includes
	#include <algorithm>

	// Other libraries and framework includes
	// Project includes
	#include "lldb/Core/Event.h"
	#include "lldb/Core/Broadcaster.h"
	#include "lldb/Core/DataExtractor.h"
	#include "lldb/Core/Log.h"
	#include "lldb/Core/State.h"
	#include "lldb/Core/Stream.h"
	#include "lldb/Host/Endian.h"
	#include "lldb/Target/Process.h"

	using namespace lldb;
	using namespace lldb_private;

	#pragma mark -
	#pragma mark Event

	//------------------------------------------------------------------
	// Event functions
	//------------------------------------------------------------------

	Event::Event (Broadcaster broadcaster, uint32_t event_type, EventData data) :
	m_broadcaster_wp(broadcaster->GetBroadcasterImpl()),
	m_type(event_type),
	m_data_sp(data)
	{
	}

	Event::Event (Broadcaster *broadcaster, uint32_t event_type, const EventDataSP &event_data_sp) :
	m_broadcaster_wp(broadcaster->GetBroadcasterImpl()),
	m_type(event_type),
	m_data_sp(event_data_sp)
	{
	}

	Event::Event(uint32_t event_type, EventData *data) :
	m_broadcaster_wp(),
	m_type(event_type),
	m_data_sp(data)
	{
	}

	Event::Event(uint32_t event_type, const EventDataSP &event_data_sp) :
	m_broadcaster_wp(),
	m_type(event_type),
	m_data_sp(event_data_sp)
	{
	}

	Event::~Event() = default;

	void
	Event::Dump (Stream *s) const
	{
	Broadcaster *broadcaster;
	Broadcaster::BroadcasterImplSP broadcaster_impl_sp(m_broadcaster_wp.lock());
	if (broadcaster_impl_sp)
	broadcaster = broadcaster_impl_sp->GetBroadcaster();
	else
	broadcaster = nullptr;

	if (broadcaster)
	{
	StreamString event_name;
	if (broadcaster->GetEventNames (event_name, m_type, false))
	s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x (%s), data = ",
	static_cast<const void*>(this),
	static_cast<void*>(broadcaster),
	broadcaster->GetBroadcasterName().GetCString(),
	m_type, event_name.GetString().c_str());
	else
	s->Printf("%p Event: broadcaster = %p (%s), type = 0x%8.8x, data = ",
	static_cast<const void*>(this),
	static_cast<void*>(broadcaster),
	broadcaster->GetBroadcasterName().GetCString(), m_type);
	}
	else
	s->Printf("%p Event: broadcaster = NULL, type = 0x%8.8x, data = ",
	static_cast<const void*>(this), m_type);

	if (m_data_sp)
	{
	s->PutChar('{');
	m_data_sp->Dump (s);
	s->PutChar('}');
	}
	else
	s->Printf ("<NULL>");
	}

	void
	Event::DoOnRemoval ()
	{
	if (m_data_sp)
	m_data_sp->DoOnRemoval (this);
	}

	#pragma mark -
	#pragma mark EventData

	//------------------------------------------------------------------
	// EventData functions
	//------------------------------------------------------------------

	EventData::EventData() = default;

	EventData::~EventData() = default;

	void
	EventData::Dump (Stream *s) const
	{
	s->PutCString ("Generic Event Data");
	}

	#pragma mark -
	#pragma mark EventDataBytes

	//------------------------------------------------------------------
	// EventDataBytes functions
	//------------------------------------------------------------------


	EventDataBytes::EventDataBytes () :
	m_bytes()
	{
	}

	EventDataBytes::EventDataBytes (const char *cstr) :
	m_bytes()
	{
	SetBytesFromCString (cstr);
	}

	EventDataBytes::EventDataBytes (const void *src, size_t src_len) :
	m_bytes()
	{
	SetBytes (src, src_len);
	}

	EventDataBytes::~EventDataBytes() = default;

	const ConstString &
	EventDataBytes::GetFlavorString ()
	{
	static ConstString g_flavor ("EventDataBytes");
	return g_flavor;
	}

	const ConstString &
	EventDataBytes::GetFlavor () const
	{
	return EventDataBytes::GetFlavorString ();
	}

	void
	EventDataBytes::Dump (Stream *s) const
	{
	size_t num_printable_chars = std::count_if (m_bytes.begin(), m_bytes.end(), isprint);
	if (num_printable_chars == m_bytes.size())
	{
	s->Printf("\"%s\"", m_bytes.c_str());
	}
	else if (!m_bytes.empty())
	{
	DataExtractor data;
	data.SetData(m_bytes.data(), m_bytes.size(), endian::InlHostByteOrder());
	data.Dump(s, 0, eFormatBytes, 1, m_bytes.size(), 32, LLDB_INVALID_ADDRESS, 0, 0);
	}
	}

	const void *
	EventDataBytes::GetBytes() const
	{
	return (m_bytes.empty() ? nullptr : m_bytes.data());
	}

	size_t
	EventDataBytes::GetByteSize() const
	{
	return m_bytes.size ();
	}

	void
	EventDataBytes::SetBytes (const void *src, size_t src_len)
	{
	if (src != nullptr && src_len > 0)
	m_bytes.assign ((const char *)src, src_len);
	else
	m_bytes.clear();
	}

	void
	EventDataBytes::SetBytesFromCString (const char *cstr)
	{
	if (cstr != nullptr && cstr[0])
	m_bytes.assign (cstr);
	else
	m_bytes.clear();
	}

	const void *
	EventDataBytes::GetBytesFromEvent (const Event *event_ptr)
	{
	const EventDataBytes *e = GetEventDataFromEvent (event_ptr);
	if (e != nullptr)
	return e->GetBytes();
	return nullptr;
	}

	size_t
	EventDataBytes::GetByteSizeFromEvent (const Event *event_ptr)
	{
	const EventDataBytes *e = GetEventDataFromEvent (event_ptr);
	if (e != nullptr)
	return e->GetByteSize();
	return 0;
	}

	const EventDataBytes *
	EventDataBytes::GetEventDataFromEvent (const Event *event_ptr)
	{
	if (event_ptr != nullptr)
	{
	const EventData *event_data = event_ptr->GetData();
	if (event_data && event_data->GetFlavor() == EventDataBytes::GetFlavorString())
	return static_cast <const EventDataBytes *> (event_data);
	}
	return nullptr;
	}

	void
	EventDataBytes::SwapBytes (std::string &new_bytes)
	{
	m_bytes.swap (new_bytes);
	}

	#pragma mark -
	#pragma mark EventStructuredData

	//------------------------------------------------------------------
	// EventDataStructuredData definitions
	//------------------------------------------------------------------

	EventDataStructuredData::EventDataStructuredData() :
	EventData(),
	m_process_sp(),
	m_object_sp(),
	m_plugin_sp()
	{
	}

	EventDataStructuredData::EventDataStructuredData(const ProcessSP &process_sp,
	const StructuredData::ObjectSP
	&object_sp,
	const
	lldb::StructuredDataPluginSP
	&plugin_sp) :
	EventData(),
	m_process_sp(process_sp),
	m_object_sp(object_sp),
	m_plugin_sp(plugin_sp)
	{
	}

	EventDataStructuredData::~EventDataStructuredData()
	{
	}

	//------------------------------------------------------------------
	// EventDataStructuredData member functions
	//------------------------------------------------------------------

	const ConstString &
	EventDataStructuredData::GetFlavor() const
	{
	return EventDataStructuredData::GetFlavorString();
	}

	void
	EventDataStructuredData::Dump(Stream *s) const
	{
	if (!s)
	return;

	if (m_object_sp)
	m_object_sp->Dump(*s);
	}

	const ProcessSP&
	EventDataStructuredData::GetProcess() const
	{
	return m_process_sp;
	}

	const StructuredData::ObjectSP&
	EventDataStructuredData::GetObject() const
	{
	return m_object_sp;
	}

	const lldb::StructuredDataPluginSP&
	EventDataStructuredData::GetStructuredDataPlugin() const
	{
	return m_plugin_sp;
	}

	void
	EventDataStructuredData::SetProcess(const ProcessSP &process_sp)
	{
	m_process_sp = process_sp;
	}

	void
	EventDataStructuredData::SetObject(const StructuredData::ObjectSP &object_sp)
	{
	m_object_sp = object_sp;
	}

	void
	EventDataStructuredData::SetStructuredDataPlugin(const
	lldb::StructuredDataPluginSP
	&plugin_sp)
	{
	m_plugin_sp = plugin_sp;
	}

	//------------------------------------------------------------------
	// EventDataStructuredData static functions
	//------------------------------------------------------------------

	const EventDataStructuredData*
	EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr)
	{
	if (event_ptr == nullptr)
	return nullptr;

	const EventData *event_data = event_ptr->GetData();
	if (!event_data \|\| event_data->GetFlavor() !=
	EventDataStructuredData::GetFlavorString())
	return nullptr;

	return static_cast<const EventDataStructuredData*>(event_data);
	}

	ProcessSP
	EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr)
	{
	auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
	if (event_data)
	return event_data->GetProcess();
	else
	return ProcessSP();
	}

	StructuredData::ObjectSP
	EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr)
	{
	auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
	if (event_data)
	return event_data->GetObject();
	else
	return StructuredData::ObjectSP();
	}

	lldb::StructuredDataPluginSP
	EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr)
	{
	auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
	if (event_data)
	return event_data->GetStructuredDataPlugin();
	else
	return StructuredDataPluginSP();
	}

	const ConstString &
	EventDataStructuredData::GetFlavorString ()
	{
	static ConstString s_flavor("EventDataStructuredData");
	return s_flavor;
	}