void CompilerLocatorGCC::AddTools(CompilerPtr compiler,
const wxString& binFolder,
const wxString& suffix)
{
wxFileName masterPath(binFolder, "");
wxString defaultBinFolder = "/usr/bin";
compiler->SetCompilerFamily(COMPILER_FAMILY_GCC);
compiler->SetInstallationPath( binFolder );
CL_DEBUG("Found GNU GCC compiler under: %s. \"%s\"", masterPath.GetPath(), compiler->GetName());
wxFileName toolFile(binFolder, "");
// ++++-----------------------------------------------------------------
// With XCode installation, only
// g++, gcc, and make are installed under the Xcode installation folder
// the rest (mainly ar and as) are taken from /usr/bin
// ++++-----------------------------------------------------------------
toolFile.SetFullName("g++");
AddTool(compiler, "CXX", toolFile.GetFullPath(), suffix);
AddTool(compiler, "LinkerName", toolFile.GetFullPath(), suffix);
#ifndef __WXMAC__
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), suffix, "-shared -fPIC");
#else
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), suffix, "-dynamiclib -fPIC");
#endif
toolFile.SetFullName("gcc");
AddTool(compiler, "CC", toolFile.GetFullPath(), suffix);
toolFile.SetFullName("make");
wxString makeExtraArgs;
if ( wxThread::GetCPUCount() > 1 ) {
makeExtraArgs << "-j" << wxThread::GetCPUCount();
}
AddTool(compiler, "MAKE", toolFile.GetFullPath(), "", makeExtraArgs);
// ++++-----------------------------------------------------------------
// From this point on, we use /usr/bin only
// ++++-----------------------------------------------------------------
toolFile.AssignDir( defaultBinFolder );
toolFile.SetFullName("ar");
AddTool(compiler, "AR", toolFile.GetFullPath(), "", "rcu");
toolFile.SetFullName("windres");
AddTool(compiler, "ResourceCompiler", "", "");
toolFile.SetFullName("as");
AddTool(compiler, "AS", toolFile.GetFullPath(), "");
}
void ConnectionSmEncryptionKeyRefresh(const typed_bdaddr* taddr)
{
#ifdef CONNECTION_DEBUG_LIB
if(taddr == NULL)
{
CL_DEBUG(("Out of range Bluetooth Address 0x%p\n", (void*)taddr));
}
#endif
{
MAKE_CL_MESSAGE(CL_INTERNAL_SM_ENCRYPTION_KEY_REFRESH_REQ);
message->taddr = *taddr;
MessageSend(connectionGetCmTask(), CL_INTERNAL_SM_ENCRYPTION_KEY_REFRESH_REQ, message);
}
}
void CppCheckPlugin::DoProcess(ProjectPtr proj)
{
wxString command = DoGetCommand(proj);
m_view->AppendLine(wxString::Format(_("Starting cppcheck: %s\n"), command.c_str()));
#if defined(__WXMSW__)
// Under Windows, we set the working directory to the binary folder
// so the configurtion files can be found
CL_DEBUG("CppCheck: Working directory: %s", clStandardPaths::Get().GetBinFolder());
CL_DEBUG("CppCheck: Command: %s", command);
m_cppcheckProcess = CreateAsyncProcess(this, command, IProcessCreateDefault, clStandardPaths::Get().GetBinFolder());
#elif defined(__WXOSX__)
CL_DEBUG("CppCheck: Working directory: %s", clStandardPaths::Get().GetDataDir());
CL_DEBUG("CppCheck: Command: %s", command);
m_cppcheckProcess = CreateAsyncProcess(this, command, IProcessCreateDefault, clStandardPaths::Get().GetDataDir());
#else
m_cppcheckProcess = CreateAsyncProcess(this, command);
#endif
if(!m_cppcheckProcess) {
wxMessageBox(_("Failed to launch codelite_cppcheck process!"), _("Warning"), wxOK | wxCENTER | wxICON_WARNING);
return;
}
}
void LLDBPlugin::TerminateTerminal()
{
if(m_terminalPID != wxNOT_FOUND) {
CL_DEBUG("Killing Terminal Process PID: %d", (int)m_terminalPID);
::wxKill(m_terminalPID, wxSIGKILL);
m_terminalPID = wxNOT_FOUND;
}
#ifdef __WXGTK__
if(m_terminalTTY.StartsWith("/tmp/pts")) {
// this is a fake symlink - remove it
::unlink(m_terminalTTY.mb_str(wxConvUTF8).data());
}
#endif
m_terminalTTY.Clear();
}
void ConnectionL2capUnmapConnectionlessRequest(Sink sink)
{
if (sink)
{
MAKE_CL_MESSAGE(CL_INTERNAL_L2CAP_UNMAP_CONNECTIONLESS_REQ);
message->sink = sink;
MessageSend(connectionGetCmTask(), CL_INTERNAL_L2CAP_UNMAP_CONNECTIONLESS_REQ, message);
}
#ifdef CONNECTION_DEBUG_LIB
else
{
CL_DEBUG(("Sink is NULL!\n"));
}
#endif
}
FileNameVector_t CompilationDatabase::GetCompileCommandsFiles() const
{
wxFileName databaseFile(GetFileName());
wxFileName fn(databaseFile);
// Usually it will be under the top folder
fn.RemoveLastDir();
// Since we can have multiple "compile_commands.json" files, we take the most updated file
// Prepare a list of files to check
FileNameVector_t files;
std::queue<std::pair<wxString, int> > dirs;
// we start with the current path
dirs.push(std::make_pair(fn.GetPath(), 0));
const int MAX_DEPTH = 2; // If no files were found, scan 2 levels only
while(!dirs.empty()) {
std::pair<wxString, int> curdir = dirs.front();
dirs.pop();
if(files.empty() && (curdir.second > MAX_DEPTH)) {
CL_DEBUG("Could not find compile_commands.json files while reaching depth 2, aborting");
break;
}
wxFileName fn(curdir.first, "compile_commands.json");
if(fn.Exists()) {
CL_DEBUGS("CompilationDatabase: found file: " + fn.GetFullPath());
files.push_back(fn);
}
// Check to see if there are more directories to recurse
wxDir dir;
if(dir.Open(curdir.first)) {
wxString dirname;
bool cont = dir.GetFirst(&dirname, "", wxDIR_DIRS);
while(cont) {
wxString new_dir;
new_dir << curdir.first << wxFileName::GetPathSeparator() << dirname;
dirs.push(std::make_pair(new_dir, curdir.second + 1));
dirname.Clear();
cont = dir.GetNext(&dirname);
}
}
}
return files;
}
void LLDBConnector::DeleteBreakpoints()
{
if ( IsCanInteract() ) {
CL_DEBUGS(wxString () << "codelite: deleting breakpoints (total of " << m_pendingDeletionBreakpoints.size() << " breakpoints)");
LLDBCommand command;
command.SetCommandType( kCommandDeleteBreakpoint );
command.SetBreakpoints( m_pendingDeletionBreakpoints );
SendCommand( command );
CL_DEBUGS(wxString () << "codelite: DeleteBreakpoints celar pending deletionbreakpoints queue");
m_pendingDeletionBreakpoints.clear();
} else {
CL_DEBUG("codelite: interrupting codelite-lldb for kInterruptReasonDeleteBreakpoint");
Interrupt( kInterruptReasonDeleteBreakpoint );
}
}
void ClangUtils::printDiagnosticsToLog(CXTranslationUnit& TU)
{
//// Report diagnostics to the log file
const unsigned diagCount = clang_getNumDiagnostics(TU);
for(unsigned i=0; i<diagCount; i++) {
CXDiagnostic diag = clang_getDiagnostic(TU, i);
CXString diagStr = clang_formatDiagnostic(diag, clang_defaultDiagnosticDisplayOptions());
wxString wxDiagString = wxString(clang_getCString(diagStr), wxConvUTF8);
if(!wxDiagString.Contains(wxT("'dllimport' attribute"))) {
CL_DEBUG(wxT("Diagnostic: %s"), wxDiagString.c_str());
}
clang_disposeString(diagStr);
clang_disposeDiagnostic(diag);
}
}
static void t_mine_init ( MbsTask *task )
{
GList *l;
gint64 total = 0;
task->data = g_new0(MineData, 1);
for (l = MB_SECTOR(MB_COLONY_SECTOR(MB_TASK_COLONY(task)))->veins; l; l = l->next)
{
if (MB_VEIN_RESOURCE(l->data) == MB_TASK_RESOURCE(task))
MINE_DATA(task)->veins = g_list_append(MINE_DATA(task)->veins,
l_object_ref(l->data));
total += MB_VEIN_QTTY(l->data);
}
CL_DEBUG("mine task '%s' : %" G_GINT64_FORMAT,
MB_RESOURCE_NAME(MB_TASK_RESOURCE(task)),
total);
}
void CompilerLocatorMinGW::AddTools(CompilerPtr compiler, const wxString& binFolder, const wxString& name)
{
wxFileName masterPath(binFolder, "");
masterPath.RemoveLastDir();
if ( m_locatedFolders.count(masterPath.GetPath()) ) {
return;
}
m_locatedFolders.insert( masterPath.GetPath() );
if ( name.IsEmpty() ) {
compiler->SetName("MinGW ( " + masterPath.GetDirs().Last() + " )");
} else {
compiler->SetName("MinGW ( " + name + " )");
}
CL_DEBUG("Found MinGW compiler under: %s. \"%s\"", masterPath.GetPath(), compiler->GetName());
wxFileName toolFile(binFolder, "");
toolFile.SetFullName("g++.exe");
AddTool(compiler, "CXX", toolFile.GetFullPath());
AddTool(compiler, "LinkerName", toolFile.GetFullPath());
AddTool(compiler, "SharedObjectLinkerName", toolFile.GetFullPath(), "-shared -fPIC");
toolFile.SetFullName("gcc.exe");
AddTool(compiler, "CC", toolFile.GetFullPath());
toolFile.SetFullName("ar.exe");
AddTool(compiler, "AR", toolFile.GetFullPath(), "rcu");
toolFile.SetFullName("windres.exe");
AddTool(compiler, "ResourceCompiler", toolFile.GetFullPath());
toolFile.SetFullName("as.exe");
AddTool(compiler, "AS", toolFile.GetFullPath());
toolFile.SetFullName("make.exe");
if ( toolFile.FileExists() ) {
AddTool(compiler, "MAKE", toolFile.GetFullPath());
} else {
toolFile.SetFullName("mingw32-make.exe");
if ( toolFile.FileExists() ) {
AddTool(compiler, "MAKE", toolFile.GetFullPath());
}
}
}
CXTranslationUnit ClangWorkerThread::DoCreateTU(CXIndex index, ClangThreadRequest* task, bool reparse)
{
wxFileName fn(task->GetFileName());
DoSetStatusMsg(wxString::Format(wxT("clang: parsing file %s..."), fn.GetFullName().c_str()));
FileExtManager::FileType type = FileExtManager::GetType(task->GetFileName());
int argc(0);
char** argv = MakeCommandLine(task, argc, type);
for(int i = 0; i < argc; i++) {
CL_DEBUG(wxT("Command Line Argument: %s"), wxString(argv[i], wxConvUTF8).c_str());
}
std::string c_filename = task->GetFileName().mb_str(wxConvUTF8).data();
CL_DEBUG(wxT("Calling clang_parseTranslationUnit..."));
// First time, need to create it
unsigned flags;
if(reparse) {
flags = CXTranslationUnit_CacheCompletionResults | CXTranslationUnit_PrecompiledPreamble |
CXTranslationUnit_Incomplete | CXTranslationUnit_DetailedPreprocessingRecord |
CXTranslationUnit_CXXChainedPCH;
} else {
flags = CXTranslationUnit_Incomplete |
#if HAS_LIBCLANG_BRIEFCOMMENTS
CXTranslationUnit_SkipFunctionBodies |
#endif
CXTranslationUnit_DetailedPreprocessingRecord;
}
CXTranslationUnit TU = clang_parseTranslationUnit(index, c_filename.c_str(), argv, argc, NULL, 0, flags);
CL_DEBUG(wxT("Calling clang_parseTranslationUnit... done"));
ClangUtils::FreeArgv(argv, argc);
DoSetStatusMsg(wxString::Format(wxT("clang: parsing file %s...done"), fn.GetFullName().c_str()));
if(TU && reparse) {
CL_DEBUG(wxT("Calling clang_reparseTranslationUnit..."));
if(clang_reparseTranslationUnit(TU, 0, NULL, clang_defaultReparseOptions(TU)) == 0) {
CL_DEBUG(wxT("Calling clang_reparseTranslationUnit... done"));
return TU;
} else {
CL_DEBUG(wxT("An error occured during reparsing of the TU for file %s. TU: %p"),
task->GetFileName().c_str(),
(void*)TU);
// The only thing that left to be done here, is to dispose the TU
clang_disposeTranslationUnit(TU);
PostEvent(wxEVT_CLANG_TU_CREATE_ERROR, task->GetFileName());
return NULL;
}
}
return TU;
}
void clTernServer::OnTernTerminated(clProcessEvent& event)
{
wxDELETE(m_tern);
if(m_goingDown || !m_jsCCManager->IsEnabled()) {
return;
}
#if defined(__WXMSW__) && !defined(NDEBUG)
HANDLE hProcess = ::GetCurrentProcess();
DWORD handleCount;
::GetProcessHandleCount(hProcess, &handleCount);
CL_DEBUG("Tern process termianted. Number of handles %d", (int)handleCount);
::CloseHandle(hProcess);
#endif
PrintMessage("Tern server terminated, will restart it\n");
Start(m_workingDirectory);
}
void NotebookNavigationDlg::OnKeyUp(wxKeyEvent& event)
{
CL_DEBUG("NotebookNavigationDlg::OnKeyUp");
#ifdef __WXOSX__
if(event.GetKeyCode() == WXK_ALT) {
CloseDialog();
} else {
event.Skip();
}
#else
if(event.GetKeyCode() == WXK_CONTROL) {
CloseDialog();
} else {
event.Skip();
}
#endif
}
void ConnectionWriteScanEnable(hci_scan_enable mode)
{
/* Check params are within allowed values - debug build only */
#ifdef CONNECTION_DEBUG_LIB
if (mode > hci_scan_enable_inq_and_page)
{
CL_DEBUG(("Out of range scan enable 0x%x\n", mode));
}
#endif
{
/* All requests are sent through the internal state handler */
MAKE_CL_MESSAGE(CL_INTERNAL_DM_WRITE_SCAN_ENABLE_REQ);
message->mode = mode;
MessageSend(connectionGetCmTask(), CL_INTERNAL_DM_WRITE_SCAN_ENABLE_REQ, message);
}
}
void ClangCleanerThread::DeleteStalePCHFiles()
{
wxString tmpdir;
if ( ::wxGetEnv("TMP", &tmpdir) ) {
wxArrayString files;
if ( wxDir::GetAllFiles(tmpdir, &files, "*.pch", wxDIR_FILES) ) {
for(size_t i=0; i<files.GetCount(); ++i) {
wxFileName fn( files.Item(i) );
if ( fn.GetFullName().StartsWith("preamble") ) {
if( ::wxRemoveFile( files.Item(i) ) ) {
CL_DEBUG("Deleting stale file: %s", files.Item(i) );
}
}
}
}
}
}
void ClangCodeCompletion::OnFileSaved(wxCommandEvent& e)
{
e.Skip();
CHECK_CLANG_ENABLED_RET();
if( TagsManagerST::Get()->GetCtagsOptions().GetFlags() & ::CC_DISABLE_AUTO_PARSING) {
CL_DEBUG(wxT("ClangCodeCompletion::OnFileSaved: Auto-parsing of saved files is disabled"));
return;
}
// Incase a file has been saved, we need to reparse its translation unit
wxFileName fn( e.GetString() );
if(!TagsManagerST::Get()->IsValidCtagsFile(fn))
return;
m_clang.ReparseFile( fn.GetFullPath() );
}
void ConnectionSdpOpenSearchRequest(Task appTask, const bdaddr* bd_addr)
{
#ifdef CONNECTION_DEBUG_LIB
if(bd_addr == NULL)
{
CL_DEBUG(("Out of range Bluetooth Address 0x%p\n", (void*)bd_addr));
}
#endif
{
/* Send an internal message */
MAKE_CL_MESSAGE(CL_INTERNAL_SDP_OPEN_SEARCH_REQ);
message->theAppTask = appTask;
message->bd_addr = *bd_addr;
MessageSend(connectionGetCmTask(), CL_INTERNAL_SDP_OPEN_SEARCH_REQ, message);
}
}
void ConnectionL2capMapConnectionlessResponse(Task theAppTask, Source source, l2cap_connectionless_data_type type)
{
if (source)
{
MAKE_CL_MESSAGE(CL_INTERNAL_L2CAP_MAP_CONNECTIONLESS_RES);
message->theAppTask = theAppTask;
message->source = source;
message->type = type;
MessageSend(connectionGetCmTask(), CL_INTERNAL_L2CAP_MAP_CONNECTIONLESS_RES, message);
}
#ifdef CONNECTION_DEBUG_LIB
else
{
CL_DEBUG(("Source is NULL!\n"));
}
#endif
}
void ConnectionSmSecModeConfig(Task theAppTask, cl_sm_wae write_auth_enable, bool debug_keys, bool legacy_auto_pair_key_missing)
{
#ifdef CONNECTION_DEBUG_LIB
if (write_auth_enable > cl_sm_wae_always)
{
CL_DEBUG(("Out of range wae 0x%x\n", write_auth_enable));
}
#endif
{
MAKE_CL_MESSAGE(CL_INTERNAL_SM_SEC_MODE_CONFIG_REQ);
message->theAppTask = theAppTask;
message->write_auth_enable = write_auth_enable;
message->debug_keys = debug_keys;
message->legacy_auto_pair_key_missing = legacy_auto_pair_key_missing;
MessageSend(connectionGetCmTask(), CL_INTERNAL_SM_SEC_MODE_CONFIG_REQ, message);
}
}
bool LLDBPlugin::DoInitializeDebugger(clDebugEvent& event, bool redirectOutput, const wxString& terminalTitle)
{
if(event.GetDebuggerName() != LLDB_DEBUGGER_NAME) {
event.Skip();
return false;
}
if(m_connector.IsRunning()) {
// Another debug session is already in progress
::wxMessageBox(_("Another debug session is already in progress. Please stop it first"),
"CodeLite",
wxOK | wxCENTER | wxICON_WARNING);
return false;
}
TerminateTerminal();
// If terminal is required, launch it now
bool isWindows = wxPlatformInfo::Get().GetOperatingSystemId() & wxOS_WINDOWS;
if(redirectOutput && !isWindows) {
wxString realPts;
::LaunchTerminalForDebugger(
terminalTitle.IsEmpty() ? event.GetExecutableName() : terminalTitle, m_terminalTTY, realPts, m_terminalPID);
if(m_terminalPID != wxNOT_FOUND) {
CL_DEBUG("Successfully launched terminal");
} else {
// Failed to launch it...
DoCleanup();
::wxMessageBox(_("Failed to start terminal for debugger"), "CodeLite", wxICON_ERROR | wxOK | wxCENTER);
return false;
}
}
// Launch local server if needed
LLDBSettings settings;
settings.Load();
if(!settings.IsUsingRemoteProxy() && !m_connector.LaunchLocalDebugServer()) {
DoCleanup();
return false;
}
return true;
}
void LLDBConnector::InvalidateBreakpoints()
{
// mark all the breakpoints as "not-applied" (id=-1)
LLDBBreakpoint::Vec_t updatedList;
for(size_t i = 0; i < m_breakpoints.size(); ++i) {
m_breakpoints.at(i)->Invalidate();
if(wxFileName::Exists(m_breakpoints.at(i)->GetFilename())) {
updatedList.push_back(m_breakpoints.at(i));
}
}
// we keep only breakpoints with valid filename
m_breakpoints.swap(updatedList);
ClearBreakpointDeletionQueue();
CL_DEBUG("codelite: InvalidateBreakpoints called");
m_pendingDeletionBreakpoints.clear();
}
void XDebugManager::DoStopDebugger()
{
ClearDebuggerMarker();
m_connected = false;
// Clear all handlers from the queue
m_handlers.clear();
// Save the breakpoints
// Reset the connection
CL_DEBUG("CodeLite >>> closing debug session");
wxDELETE(m_readerThread);
// Notify about debug session ended
XDebugEvent eventEnd(wxEVT_XDEBUG_SESSION_ENDED);
EventNotifier::Get()->AddPendingEvent( eventEnd );
}
void ConnectionSmPinCodeResponse(const bdaddr* bd_addr, uint16 length, const uint8* pin_code)
{
#ifdef CONNECTION_DEBUG_LIB
if(bd_addr == NULL)
{
CL_DEBUG(("Out of range Bluetooth Address 0x%p\n", (void*)bd_addr));
}
#endif
{
MAKE_CL_MESSAGE(CL_INTERNAL_SM_PIN_REQUEST_RES);
message->bd_addr = *bd_addr;
message->pin_length = length;
if (length > 0)
memcpy(message->pin, pin_code, length);
MessageSend(connectionGetCmTask(), CL_INTERNAL_SM_PIN_REQUEST_RES, message);
}
}
void ConnectionWriteInquiryAccessCode(Task theAppTask, const uint32 *iac, uint16 num_iac)
{
/* Check params are within allowed values - debug build only */
#ifdef CONNECTION_DEBUG_LIB
if ((num_iac < MIN_WRITE_IAC_LAP) || (num_iac > MAX_WRITE_IAC_LAP))
{
CL_DEBUG(("Out of range num_iac 0x%x\n", num_iac));
}
#endif
{
MAKE_CL_MESSAGE_WITH_LEN(CL_INTERNAL_DM_WRITE_IAC_LAP_REQ, sizeof(uint32) * num_iac);
message->theAppTask = theAppTask;
message->num_iac = num_iac;
memmove(&message->iac, iac, sizeof(uint32) * num_iac);
MessageSendConditionally(connectionGetCmTask(), CL_INTERNAL_DM_WRITE_IAC_LAP_REQ, message, (const uint16 *)&theCm.inqState.inquiryLock);
}
}
void ConnectionSetSniffSubRatePolicy(Sink sink, uint16 max_remote_latency, uint16 min_remote_timeout, uint16 min_local_timeout)
{
#ifdef CONNECTION_DEBUG_LIB
if (connectionGetBtVersion() < bluetooth2_1)
{
CL_DEBUG(("Sniff subrating is not supported on (pre BT 2.1)\n"));
}
else
#endif
{
MAKE_CL_MESSAGE(CL_INTERNAL_DM_SET_SNIFF_SUB_RATE_POLICY_REQ);
message->sink = sink;
message->max_remote_latency = max_remote_latency;
message->min_remote_timeout = min_remote_timeout;
message->min_local_timeout = min_local_timeout;
MessageSend(connectionGetCmTask(), CL_INTERNAL_DM_SET_SNIFF_SUB_RATE_POLICY_REQ, message);
}
}
FileNameVector_t CompilationDatabase::GetCompileCommandsFiles() const
{
wxFileName databaseFile ( GetFileName() );
wxFileName fn( databaseFile );
// Usually it will be under the top folder
fn.RemoveLastDir();
// Since we can have multiple "compile_commands.json" files, we take the most updated file
// Prepare a list of files to check
FileNameVector_t files;
std::queue<wxString> dirs;
// we start with the current path
dirs.push( fn.GetPath() );
while ( !dirs.empty() ) {
wxString curdir = dirs.front();
dirs.pop();
wxFileName fn(curdir, "compile_commands.json" );
if ( fn.Exists() && // file exists
(fn.GetModificationTime().GetTicks() > databaseFile.GetModificationTime().GetTicks() ) ) // and its newer than the database file
{
CL_DEBUG("CompilationDatabase: found file: " + fn.GetFullPath());
files.push_back( fn );
}
// Check to see if there are more directories to recurse
wxDir dir;
if ( dir.Open( curdir ) ) {
wxString dirname;
bool cont = dir.GetFirst( &dirname, "", wxDIR_DIRS );
while ( cont ) {
wxString new_dir;
new_dir << curdir << wxFileName::GetPathSeparator() << dirname;
dirs.push( new_dir );
dirname.Clear();
cont = dir.GetNext( &dirname );
}
}
}
return files;
}
void NodeJSSocket::WriteRequest(JSONElement& request, NodeJSHandlerBase::Ptr_t handler)
{
if(!IsConnected()) return;
size_t seq = NextSequence();
request.addProperty("seq", seq);
wxString content, str;
str = request.format();
content << "Content-Length:" << str.length() << "\r\n\r\n";
content << str;
CL_DEBUG("CodeLite >>>> %s", content);
m_socket.Send(content);
// Keep the handler
if(handler) {
m_handlers.insert(std::make_pair(seq, handler));
}
}
void DbgGdb::OnDataRead( wxCommandEvent& e )
{
// Data arrived from the debugger
ProcessEventData *ped = ( ProcessEventData * )e.GetClientData();
wxString bufferRead;
bufferRead << ped->GetData();
delete ped;
if( !m_gdbProcess || !m_gdbProcess->IsAlive() )
return;
CL_DEBUG("GDB>> %s", bufferRead);
wxArrayString lines = wxStringTokenize( bufferRead, wxT( "\n" ), wxTOKEN_STRTOK );
if(lines.IsEmpty())
return;
// Prepend the partially saved line from previous iteration to the first line
// of this iteration
lines.Item(0).Prepend(m_gdbOutputIncompleteLine);
m_gdbOutputIncompleteLine.Clear();
// If the last line is in-complete, remove it from the array and keep it for next iteration
if(!bufferRead.EndsWith(wxT("\n"))) {
m_gdbOutputIncompleteLine = lines.Last();
lines.RemoveAt(lines.GetCount()-1);
}
for( size_t i=0; i<lines.GetCount(); i++ ) {
wxString line = lines.Item( i );
line.Replace( wxT( "(gdb)" ), wxT( "" ) );
line.Trim().Trim( false );
if ( line.IsEmpty() == false ) {
m_gdbOutputArr.Add( line );
}
}
if ( m_gdbOutputArr.IsEmpty() == false ) {
// Trigger GDB processing
Poke();
}
}
void ConnectionSmEncryptionKeyRefreshSink(Sink sink)
{
#ifdef CONNECTION_DEBUG_LIB
if(!sink)
{
CL_DEBUG(("Null sink passed in\n"));
}
#endif
{
bdaddr addr;
if(SinkGetBdAddr(sink, &addr))
{
MAKE_CL_MESSAGE(CL_INTERNAL_SM_ENCRYPTION_KEY_REFRESH_REQ);
message->bd_addr = addr;
MessageSend(connectionGetCmTask(), CL_INTERNAL_SM_ENCRYPTION_KEY_REFRESH_REQ, message);
}
}
}
void NodeJSGetScriptHandler::Process(NodeJSDebugger* debugger, const wxString& output)
{
JSONRoot root(output);
wxString sourceFile = root.toElement().namedObject("body").namedObject("source").toString();
if(!sourceFile.IsEmpty()) {
wxFileName fn(clStandardPaths::Get().GetUserDataDir(), m_filename);
fn.AppendDir("webtools");
fn.AppendDir("tmp");
fn.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
if(FileUtils::WriteFileContent(fn, sourceFile)) {
CL_DEBUG("Calling marking line for %s:%d", fn.GetFullPath(), m_line);
debugger->AddTempFile(fn.GetFullPath());
clDebugEvent eventHighlight(wxEVT_NODEJS_DEBUGGER_MARK_LINE);
eventHighlight.SetLineNumber(m_line);
eventHighlight.SetFileName(fn.GetFullPath());
EventNotifier::Get()->AddPendingEvent(eventHighlight);
}
}
}
