自学教程：C++ CL_DEBUG函数代码示例

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);        }    }}