wxString MemCheckPlugin::PrepareCommand(const wxString& projectName, wxString& wd)
{
wd.clear();
if(!clCxxWorkspaceST::Get()->IsOpen()) { return ""; }
ProjectPtr proj = clCxxWorkspaceST::Get()->GetProject(projectName);
if(!proj) {
clWARNING() << "MemCheckPlugin::PrepareCommand(): could not find project:" << projectName;
return wxEmptyString;
}
BuildConfigPtr bldConf = clCxxWorkspaceST::Get()->GetProjBuildConf(projectName, wxEmptyString);
if(!bldConf) {
clWARNING() << "MemCheckPlugin::PrepareCommand(): failed to find project configuration for project:"
<< projectName;
return wxEmptyString;
}
wxString projectPath = proj->GetFileName().GetPath();
// expand variables
wxString cmd = bldConf->GetCommand();
cmd = MacroManager::Instance()->Expand(cmd, NULL, projectName);
wxString cmdArgs = bldConf->GetCommandArguments();
cmdArgs = MacroManager::Instance()->Expand(cmdArgs, NULL, projectName);
// Execute command & cmdArgs
wd = bldConf->GetWorkingDirectory();
wd = MacroManager::Instance()->Expand(wd, NULL, projectName);
wxFileName workingDir(wd, "");
if(workingDir.IsRelative()) { workingDir.MakeAbsolute(projectPath); }
wxFileName fileExe(cmd);
if(fileExe.IsRelative()) { fileExe.MakeAbsolute(workingDir.GetPath()); }
fileExe.Normalize();
#ifdef __WXMSW__
if(!fileExe.Exists() && fileExe.GetExt().IsEmpty()) {
// Try with .exe
wxFileName withExe(fileExe);
withExe.SetExt("exe");
if(withExe.Exists()) { fileExe = withExe; }
}
#endif
wd = workingDir.GetPath();
cmd = fileExe.GetFullPath();
cmd = ::WrapWithQuotes(cmd);
cmd << " " << cmdArgs;
clDEBUG() << "Command to execute:" << cmd;
clDEBUG() << "Working directory:" << wd;
return cmd;
}
void NodeJSDevToolsProtocol::SetBreakpoint(clWebSocketClient& socket, const NodeJSBreakpoint& bp)
{
try {
JSONItem params = bp.ToJSON("params");
// Nodejs is using 0 based line numbers, while the editor starts from 1
params.removeProperty("lineNumber");
params.addProperty("lineNumber", bp.GetLine() - 1);
// Send the command
SendSimpleCommand(socket, "Debugger.setBreakpointByUrl", params);
// Register a handler to handle this command when it returns
CommandHandler handler(message_id, [=](const JSONItem& result) {
wxString breakpointId = result.namedObject("breakpointId").toString();
NodeJSBreakpoint& b = m_debugger->GetBreakpointsMgr()->GetBreakpoint(bp.GetFilename(), bp.GetLine());
if(b.IsOk()) {
b.SetNodeBpID(breakpointId);
clDebugEvent bpEvent(wxEVT_NODEJS_DEBUGGER_UPDATE_BREAKPOINTS_VIEW);
EventNotifier::Get()->AddPendingEvent(bpEvent);
}
});
m_waitingReplyCommands.insert({ handler.m_commandID, handler });
} catch(clSocketException& e) {
clWARNING() << e.what();
}
}
void PHPWorkspace::OnProjectSyncEnd(clCommandEvent& event)
{
const wxString& name = event.GetString();
if(m_inSyncProjects.count(name) == 0) {
clWARNING() << "PHPWorkspace::OnProjectSyncEnd: unable to find project '" << name << "' in the workspace..."
<< clEndl;
return;
}
clDEBUG() << "PHPWorkspace::OnProjectSyncEnd: project" << name << "completed sync" << clEndl;
m_inSyncProjects.erase(name);
// Load the project
PHPProject::Ptr_t pProj = GetProject(name);
CHECK_PTR_RET(pProj);
// Update the project files
pProj->SetFiles(event.GetStrings());
if(m_inSyncProjects.empty()) {
clDEBUG() << "PHPWorkspace::OnProjectSyncEnd: all projects completed sync" << clEndl;
if(m_projectSyncOwner) {
clCommandEvent endEvent(wxEVT_PHP_WORKSPACE_FILES_SYNC_END);
m_projectSyncOwner->AddPendingEvent(endEvent);
}
}
}
void NodeJSDevToolsProtocol::DeleteBreakpointByID(clWebSocketClient& socket, const wxString& bpid)
{
try {
JSONItem params = JSONItem::createObject("params");
params.addProperty("breakpointId", bpid);
// Send the command
SendSimpleCommand(socket, "Debugger.removeBreakpoint", params);
} catch(clSocketException& e) {
clWARNING() << e.what();
}
}
void NodeJSDevToolsProtocol::SendSimpleCommand(clWebSocketClient& socket, const wxString& command,
const JSONItem& params)
{
try {
JSON root(cJSON_Object);
JSONItem e = root.toElement();
e.addProperty("id", ++message_id);
e.addProperty("method", command);
if(params.isOk()) { e.append(params); }
wxString command = e.format(false);
clDEBUG() << "-->" << command;
socket.Send(command);
} catch(clSocketException& e) {
clWARNING() << e.what();
}
}
bool LLDBConnector::ConnectToRemoteDebugger(const wxString& ip, int port, LLDBConnectReturnObject& ret, int timeout)
{
m_socket.reset(NULL);
clSocketClient* client = new clSocketClient();
m_socket.reset(client);
clDEBUG() << "Connecting to codelite-lldb on" << ip << ":" << port;
try {
bool would_block = false;
if(!client->ConnectRemote(ip, port, would_block, true)) {
// select the socket
if(!would_block) {
m_socket.reset(NULL);
return false;
}
try {
if(client->SelectWrite(timeout) == clSocketBase::kTimeout) {
m_socket.reset(NULL);
return false;
}
} catch(clSocketException& e) {
clDEBUG() << "SelectWrite error:" << e.what();
}
}
// Connected!
// Read the negotiation packet (part of the protocol only when doing remote connection)
wxString message;
if(m_socket->ReadMessage(message, 2) != clSocketBase::kSuccess) {
m_socket.reset(NULL);
return false;
}
LLDBRemoteHandshakePacket handshake(message);
ret.SetRemoteHostName(handshake.GetHost());
ret.SetPivotNeeded(handshake.GetHost() != ::wxGetHostName());
} catch(clSocketException& e) {
clWARNING() << "LLDBConnector::ConnectToRemoteDebugger:" << e.what();
m_socket.reset(NULL);
return false;
}
clDEBUG() << "Successfully connected to codelite-lldb";
return true;
}
void NodeJSDevToolsProtocol::DeleteBreakpoint(clWebSocketClient& socket, const NodeJSBreakpoint& bp)
{
try {
JSONItem params = JSONItem::createObject("params");
params.addProperty("breakpointId", bp.GetNodeBpID());
// Send the command
SendSimpleCommand(socket, "Debugger.removeBreakpoint", params);
// Register a handler to handle this command when it returns
CommandHandler handler(message_id, [=](const JSONItem& result) {
clDebugEvent bpEvent(wxEVT_NODEJS_DEBUGGER_UPDATE_BREAKPOINTS_VIEW);
EventNotifier::Get()->AddPendingEvent(bpEvent);
});
m_waitingReplyCommands.insert({ handler.m_commandID, handler });
} catch(clSocketException& e) {
clWARNING() << e.what();
}
}
void LanguageServerCluster::StartServer(const LanguageServerEntry& entry)
{
if(entry.IsEnabled()) {
if(!entry.IsValid()) {
clWARNING() << "LSP Server" << entry.GetName()
<< "is not valid and it will not be started (one of the specified paths do not "
"exist)";
LanguageServerConfig::Get().GetServers()[entry.GetName()].SetEnabled(false);
LanguageServerConfig::Get().Save();
return;
}
LanguageServerProtocol::Ptr_t lsp(new LanguageServerProtocol(entry.GetName(), entry.GetNetType(), this));
lsp->SetPriority(entry.GetPriority());
lsp->SetDisaplayDiagnostics(entry.IsDisaplayDiagnostics());
lsp->SetUnimplementedMethods(entry.GetUnimplementedMethods());
wxArrayString lspCommand;
lspCommand.Add(entry.GetExepath());
if(!entry.GetArgs().IsEmpty()) {
wxArrayString args = ::wxStringTokenize(entry.GetArgs(), " ", wxTOKEN_STRTOK);
lspCommand.insert(lspCommand.end(), args.begin(), args.end());
}
wxString rootDir;
if(clWorkspaceManager::Get().GetWorkspace()) {
rootDir = clWorkspaceManager::Get().GetWorkspace()->GetFileName().GetPath();
}
clDEBUG() << "Starting lsp:";
clDEBUG() << "Connection string:" << entry.GetConnectionString();
clDEBUG() << "lspCommand:" << lspCommand;
clDEBUG() << "entry.GetWorkingDirectory():" << entry.GetWorkingDirectory();
clDEBUG() << "rootDir:" << rootDir;
clDEBUG() << "entry.GetLanguages():" << entry.GetLanguages();
size_t flags = 0;
lsp->Start(lspCommand, entry.GetConnectionString(), entry.GetWorkingDirectory(), rootDir, entry.GetLanguages(),
flags);
m_servers.insert({ entry.GetName(), lsp });
}
}
void clConsoleEnvironment::Apply()
{
if(!m_oldEnvironment.empty()) {
clWARNING() << "Refusing to apply environment. Already in a dirty state";
return;
}
if(m_environment.empty()) { return; }
// keep a copy of the old environment before we apply the new values
m_oldEnvironment.clear();
std::for_each(m_environment.begin(), m_environment.end(), [&](const wxStringMap_t::value_type& vt) {
wxString envvalue;
if(::wxGetEnv(vt.first, &envvalue)) {
m_oldEnvironment[vt.first] = envvalue;
} else {
m_oldEnvironment[vt.first] = "__no_such_env__";
}
::wxSetEnv(vt.first, vt.second);
});
}
void clMultiBook::OnEventProxy(wxBookCtrlEvent& event)
{
if(event.GetEventObject() == this) {
// Avoid loops
event.Skip();
return;
}
int selection = event.GetSelection();
int oldSelection = event.GetOldSelection();
Notebook* book = dynamic_cast<Notebook*>(event.GetEventObject());
if(!book) {
clWARNING() << "clMultiBook::OnEventProxy no notebook event object!";
return;
}
// Convert the event
wxBookCtrlEvent proxyEvent(event.GetEventType());
proxyEvent.SetEventObject(this);
proxyEvent.SetSelection(wxNOT_FOUND);
proxyEvent.SetOldSelection(wxNOT_FOUND);
if(selection != wxNOT_FOUND) { proxyEvent.SetSelection(BookIndexToGlobalIndex(book, selection)); }
if(oldSelection != wxNOT_FOUND) { proxyEvent.SetOldSelection(BookIndexToGlobalIndex(book, oldSelection)); }
// Process the event
if((event.GetEventType() == wxEVT_BOOK_TAB_CONTEXT_MENU) || (event.GetEventType() == wxEVT_BOOK_PAGE_CHANGED)) {
// Use ProcessEvent
GetEventHandler()->ProcessEvent(proxyEvent);
} else if((event.GetEventType() == wxEVT_BOOK_PAGE_CLOSING) || (event.GetEventType() == wxEVT_BOOK_PAGE_CHANGING)) {
// Handle with ProcessEvent with Veto option
GetEventHandler()->ProcessEvent(proxyEvent);
if(!proxyEvent.IsAllowed()) { event.Veto(); }
} else {
// Handle with AddPendingEvent
GetEventHandler()->AddPendingEvent(proxyEvent);
if(event.GetEventType() == wxEVT_BOOK_PAGE_CLOSED) {
// A page was closed
CallAfter(&clMultiBook::UpdateView);
}
}
}
bool LLDBConnector::ConnectToLocalDebugger(LLDBConnectReturnObject& ret, int timeout)
{
#ifndef __WXMSW__
clSocketClient* client = new clSocketClient();
m_socket.reset(client);
clDEBUG() << "Connecting to codelite-lldb on:" << GetDebugServerPath();
long msTimeout = timeout * 1000;
long retriesCount = msTimeout / 250; // We try every 250 ms to connect
bool connected = false;
for(long i = 0; i < retriesCount; ++i) {
if(!client->ConnectLocal(GetDebugServerPath())) {
wxThread::Sleep(250);
continue;
}
connected = true;
break;
}
if(!connected) {
return false;
}
// Start the lldb event thread
// and start a listener thread which will read replies
// from codelite-lldb and convert them into LLDBEvent
socket_t fd = m_socket->GetSocket();
m_pivot.Clear();
m_thread = new LLDBNetworkListenerThread(this, m_pivot, fd);
m_thread->Start();
clDEBUG() << "Successfully connected to codelite-lldb";
return true;
#else
clWARNING() << "LLDB Debugger: can't connect to local debugger - this is not support on MSW";
return false;
#endif
}
void FileUtils::OSXOpenDebuggerTerminalAndGetTTY(const wxString& path, const wxString& appname, wxString& tty,
long& pid)
{
tty.Clear();
wxString command;
wxString tmpfile;
tmpfile << "/tmp/terminal.tty." << ::wxGetProcessId();
wxFileName helperScript("/tmp", "codelite-lldb-helper.sh");
wxString fileContent;
fileContent << "#!/bin/bash\n";
fileContent << "tty > " << tmpfile << "\n";
fileContent << "sleep 12345";
FileUtils::WriteFileContent(helperScript, fileContent);
int rc = system("chmod +x /tmp/codelite-lldb-helper.sh");
wxUnusedVar(rc);
command << "/usr/bin/open -a " << appname << " /tmp/codelite-lldb-helper.sh";
clDEBUG() << "Executing: " << command;
long res = ::wxExecute(command);
if(res == 0) {
clWARNING() << "Failed to execute command:" << command;
return;
}
// Read the tty from the file, wait for it up to 10 seconds
wxFileName ttyFile(tmpfile);
pid = wxNOT_FOUND;
for(size_t i = 0; i < 10; ++i) {
if(!ttyFile.Exists()) {
::wxSleep(1);
continue;
}
ReadFileContent(ttyFile, tty);
tty.Trim().Trim(false);
// Remove the file
clRemoveFile(ttyFile.GetFullPath());
// Get the parent process ID (we want the parent PID and not
// the sleep command PID)
wxString psCommand;
psCommand << "ps -A -o ppid,command";
wxString psOutput = ProcUtils::SafeExecuteCommand(psCommand);
clDEBUG() << "ps command output:\n" << psOutput;
wxArrayString lines = ::wxStringTokenize(psOutput, "\n", wxTOKEN_STRTOK);
for(size_t u = 0; u < lines.GetCount(); ++u) {
wxString l = lines.Item(u);
l.Trim().Trim(false);
if(l.Contains("sleep") && l.Contains("12345")) {
// we got a match
clDEBUG() << "Got a match!";
wxString ppidString = l.BeforeFirst(' ');
ppidString.ToCLong(&pid);
break;
}
}
break;
}
clDEBUG() << "PID is:" << pid;
clDEBUG() << "TTY is:" << tty;
}
