
EDB uses QtPlugin system for plugins, this means that all plugins must be built 
using this system. All includes relating to plugins and data they can access
can be found in the main include directory, you should add this to the include
path of the .pro file you use to compile your plugins.

classes such as "ByteShiftArray" and "BinaryString" are simply utility classes 
which make implementing commong tasks in plugins simpler, Binary string is a 
widget which will display 3 text fields (ascii/utf-16/hex) and update all 3 as 
the user types which appropriate values (similar to the binary string input 
system of OllyDbg).

There are two main types of plugins, "DebuggerPlugin" which is a general purpose
plugin and "DebuggerCore" which is uses to implement the core debugging 
functionality. Most likley you will want to create a "DebuggerPlugin".

To create a "DebuggerPlugin" plugin, you must inherit from 
DebuggerPluginInterface found in include/DebuggerPluginInterface.h. It only 
requires that you implement one pure virtual function:

virtual QMenu *menu(QWidget *parent = 0) = 0;

This will return a menu object which will be added to the "plugins" in EDB, 
when this menu item is activated, you may do whatever you wish.

Basic operations for implementing the plugin functionality can be found in 
include/Debugger.h which defines the "Debugger" namespace. Here is a listing
and description of all functions:

These functions add/remove/toggle breakpoints at a given address:

void Debugger::removeBreakPoint(BaseTypes::address_t address);
void Debugger::toggleBreakPoint(BaseTypes::address_t address);
void Debugger::createBreakPoint(BaseTypes::address_t address);


These functions update the data views to show a given address either in the 
current tab or new tab, they also allow displaying just a specific range and 
return success or failure:

bool Debugger::dumpDataRange(BaseTypes::address_t address, BaseTypes::address_t end_address, bool newTab);
bool Debugger::dumpDataRange(BaseTypes::address_t address, BaseTypes::address_t end_address);	
bool Debugger::dumpData(BaseTypes::address_t address, bool newTab);
bool Debugger::dumpData(BaseTypes::address_t address);
bool Debugger::dumpStack(BaseTypes::address_t address);

These functions prompt the user for a 32-bit value and return true if the 
input is a value number.

bool Debugger::getValueFromUser(unsigned int &value);
bool Debugger::getValueFromUser(unsigned int &value, const QString &title);

This function attempts to attach to a given pid:

bool Debugger::attachToProcess(BaseTypes::pid_t pid);

Is a pointer to the current debug event handler, this object is used to 
trap the incoming events such as crashs and step events:

DebugEventHandlerInterface *Debugger::debugEventHandler;

Is a pointer to the symbol manager, DO NOT change this pointer, the debugger 
will assume it is the only one to set this pointer.

SymbolManager *Debugger::symbolManager;

Is a pointer to the memory region manager, DO NOT change this pointer, the 
debugger will assume it is the only one to set this pointer.

MemoryRegions *Debugger::memoryRegions;

Is a pointer to the active debugging core plugin, DO NOT change this pointer, 
the debugger will assume it is the only one to set this pointer. This will 
allow you to use all of the main debugging primitives directly, though things 
like stepping/running and such should be used very carefully.

DebuggerCoreInterface *Debugger::debuggerBase;

Is a pointer to the main GUI object, DO NOT change this pointer, the debugger 
will assume it is the only one to set this pointer. This is mostely used for 
giving plugin windows a proper parent object during construction.

QWidget *Debugger::debuggerGUI;

Returns a list of the currently loaded libraries.
QList<QString> Debugger::loadedLibraries();

Returns a pointer to the configuration dialog.
QDialog *Debugger::dialogOptions();

Returns a read only pointer to the current configuration.
const Configuration *Debugger::config();

Outputs a string to the logging system which for now is standard out, 
eventually, it may possibly be routed to a logging console or file.

void Debugger::log(const QString &s);
