bool SvnCommand::Execute(const wxString &command, const wxString &workingDirectory, SvnCommandHandler *handler, Subversion2 *plugin) { // Dont run 2 commands at the same time if(m_process) { if(handler) { //handler->GetPlugin()->GetShell()->AppendText(svnANOTHER_PROCESS_RUNNING); delete handler; } return false; } ClearAll(); // Wrap the command in the OS Shell wxString cmdShell (command); WrapInShell(cmdShell); // Apply the environment variables before executing the command wxStringMap_t om; om.insert( std::make_pair("LC_ALL", "C")); bool useOverrideMap = m_plugin->GetSettings().GetFlags() & SvnUsePosixLocale; EnvSetter env(m_plugin->GetManager()->GetEnv(), useOverrideMap ? &om : NULL); m_process = CreateAsyncProcess(this, command, IProcessCreateDefault, workingDirectory); if ( !m_process ) { return false; } m_workingDirectory = workingDirectory.c_str(); m_command = command.c_str(); m_handler = handler; return true; }
void wxTerminal::DoProcessCommand(const wxString& command) { wxString cmd(command); cmd.Trim().Trim(false); wxString path; // Add the shell prefix ::WrapInShell(cmd); wxString cmdShell; cmdShell.swap(cmd); // real command IProcess* cmdPrc = CreateAsyncProcess(this, cmdShell, IProcessCreateWithHiddenConsole, m_workingDir); if(cmdPrc) { m_process = cmdPrc; } else { m_process = NULL; m_textCtrl->SetInsertionPointEnd(); m_textCtrl->AppendText(wxString::Format( _("Failed to execute command: %s\nWorking Directory: %s\n"), cmdShell.c_str(), m_workingDir.c_str())); if(m_exitWhenProcessDies) { m_textCtrl->SetInsertionPointEnd(); m_textCtrl->AppendText(wxString(wxT("\n")) + _("Press any key to continue...")); m_exitOnKey = true; } } }
bool SvnCommand::Execute(const wxString& command, const wxString& workingDirectory, SvnCommandHandler *handler) { // Dont run 2 commands at the same time if(m_process) { if(handler) { //handler->GetPlugin()->GetShell()->AppendText(svnANOTHER_PROCESS_RUNNING); delete handler; } return false; } ClearAll(); // Wrap the command in the OS Shell wxString cmdShell (command); WrapInShell(cmdShell); m_process = CreateAsyncProcess(this, command, workingDirectory); if ( !m_process ) { return false; } m_workingDirectory = workingDirectory.c_str(); m_command = command.c_str(); m_handler = handler; return true; }
void CppCheckPlugin::DoProcess() { wxString command = DoGetCommand(); m_view->AppendLine(wxString::Format(_("Starting cppcheck: %s\n"), command.c_str())); m_cppcheckProcess = CreateAsyncProcess(this, command); if (!m_cppcheckProcess ) { wxMessageBox(_("Failed to launch codelite_cppcheck process!"), _("Warning"), wxOK|wxCENTER|wxICON_WARNING); return; } }
void GitCommitListDlg::OnSelectionChanged(wxDataViewEvent& event) { wxVariant v; if(!event.GetItem().IsOk()) { return; } m_dvListCtrlCommitList->GetValue(v, m_dvListCtrlCommitList->ItemToRow(event.GetItem()), 0); wxString commitID = v.GetString(); wxString command = wxString::Format(wxT("%s --no-pager show %s"), m_gitPath.c_str(), commitID.c_str()); m_process = CreateAsyncProcess(this, command, IProcessCreateDefault, m_workingDir); }
bool DbgGdb::Attach(const DebugSessionInfo& si) { // set the environment variables EnvSetter env(m_env, NULL, m_debuggeeProjectName, wxEmptyString); wxString dbgExeName; if(!DoLocateGdbExecutable(si.debuggerPath, dbgExeName)) { return false; } wxString cmd; #if defined(__WXGTK__) || defined(__WXMAC__) cmd << dbgExeName; if(!si.ttyName.IsEmpty()) { cmd << wxT(" --tty=") << si.ttyName; } cmd << wxT(" --interpreter=mi "); #else cmd << dbgExeName << wxT(" --interpreter=mi "); cmd << ProcUtils::GetProcessNameByPid(si.PID) << wxT(" "); #endif // if(sudoCmd.IsEmpty() == false) { // cmd.Prepend(sudoCmd + wxT(" ")); //} m_attachedMode = true; m_debuggeePid = si.PID; cmd << wxT(" --pid=") << m_debuggeePid; wxLogMessage(cmd); m_observer->UpdateAddLine(wxString::Format(wxT("Current working dir: %s"), wxGetCwd().c_str())); m_observer->UpdateAddLine(wxString::Format(wxT("Launching gdb from : %s"), wxGetCwd().c_str())); m_observer->UpdateAddLine(wxString::Format(wxT("Starting debugger : %s"), cmd.c_str())); // Build the process creation flags size_t createFlags = IProcessCreateDefault; if(m_info.flags & DebuggerInformation::kRunAsSuperuser) { createFlags |= IProcessCreateAsSuperuser; } m_gdbProcess = CreateAsyncProcess(this, cmd, createFlags); if(!m_gdbProcess) { return false; } m_gdbProcess->SetHardKill(true); DoInitializeGdb(si); m_observer->UpdateGotControl(DBG_END_STEPPING); return true; }
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; } }
bool DbgGdb::Start(const wxString &debuggerPath, const wxString & exeName, int pid, const std::vector<BreakpointInfo> &bpList, const wxArrayString &cmds) { wxString dbgExeName; if ( ! DoLocateGdbExecutable(debuggerPath, dbgExeName) ) { return false; } wxString cmd; #if defined (__WXGTK__) || defined (__WXMAC__) //On GTK and other platforms, open a new terminal and direct all //debugee process into it wxString ptyName; if (!m_consoleFinder.FindConsole(wxT("EmbeddedLite: gdb"), ptyName)) { wxLogMessage(wxT("Failed to allocate console for debugger")); return false; } cmd << dbgExeName << wxT(" --tty=") << ptyName << wxT(" --interpreter=mi "); #else cmd << dbgExeName << wxT(" --interpreter=mi "); cmd << ProcUtils::GetProcessNameByPid(pid) << wxT(" "); #endif m_debuggeePid = pid; cmd << wxT(" --pid=") << m_debuggeePid; wxLogMessage(cmd); //set the environment variables EnvSetter env(m_env); m_observer->UpdateAddLine(wxString::Format(wxT("Current working dir: %s"), wxGetCwd().c_str())); m_observer->UpdateAddLine(wxString::Format(wxT("Launching gdb from : %s"), wxGetCwd().c_str())); m_observer->UpdateAddLine(wxString::Format(wxT("Starting debugger : %s"), cmd.c_str())); m_gdbProcess = CreateAsyncProcess(this, cmd); if (!m_gdbProcess) { return false; } m_gdbProcess->SetHardKill(true); DoInitializeGdb(bpList, cmds); m_observer->UpdateGotControl(DBG_END_STEPPING); return true; }
void SvnConsole::DoProcessNextCommand() { // If another process is running, we try again when the process is termianted if (m_process) { return; } if(m_queue.empty()) return; // Remove the command from the queue SvnConsoleCommand *command = m_queue.front(); m_queue.pop_front(); m_output.Clear(); m_currCmd.clean(); m_currCmd = *command; // Delete it delete command; EnsureVisible(); // Print the command? AppendText(m_currCmd.cmd + wxT("\n")); // Wrap the command in the OS Shell wxString cmdShell (m_currCmd.cmd); // Apply the environment variables before executing the command wxStringMap_t om; om.insert( std::make_pair( "LC_ALL", "C" ) ); bool useOverrideMap = m_plugin->GetSettings().GetFlags() & SvnUsePosixLocale; EnvSetter env(m_plugin->GetManager()->GetEnv(), useOverrideMap ? &om : NULL); m_process = CreateAsyncProcess(this, cmdShell, IProcessCreateWithHiddenConsole, m_currCmd.workingDirectory); if (!m_process) { AppendText(_("Failed to launch Subversion client.\n")); return; } m_sci->SetFocus(); }
void wxFormBuilder::DoLaunchWxFB(const wxString& file) { wxString fbpath = GetWxFBPath(); // if (fbpath.IsEmpty()) { // wxMessageBox(_("Failed to launch wxFormBuilder, no path specified\nPlease set wxFormBuilder path from // Plugins //-> wxFormBuilder -> Settings..."), // _("CodeLite"), wxOK|wxCENTER|wxICON_WARNING); // return; // } ConfFormBuilder confData; m_mgr->GetConfigTool()->ReadObject(wxT("wxFormBuilder"), &confData); wxString cmd = confData.GetCommand(); cmd.Replace(wxT("$(wxfb)"), fbpath); cmd.Replace(wxT("$(wxfb_project)"), wxString::Format(wxT("\"%s\""), file.c_str())); WrapInShell(cmd); CreateAsyncProcess(this, cmd, IProcessCreateWithHiddenConsole); }
void wxTerminal::DoProcessCommand(const wxString& command) { wxString cmd ( command ); cmd.Trim().Trim(false); if (!cmd.StartsWith(wxT("#"))) { // Execute it if (cmd.EndsWith(wxT("&"))) { cmd.RemoveLast(); } wxString path; // Add the shell prefix wxString cmdShell = WrapInShell(cmd); if(CheckForCD(cmd, path)) { // CD command! m_workingDir = path; DoWritePrompt(); } else { // real command IProcess *cmdPrc = CreateAsyncProcess(this, cmdShell, m_workingDir); if( cmdPrc ) { m_process = cmdPrc; } else { m_process = NULL; m_textCtrl->SetInsertionPointEnd(); m_textCtrl->AppendText(wxString::Format(wxT("Failed to execute command: %s\nWorking Directory: %s\n"), cmdShell.c_str(), m_workingDir.c_str())); DoWritePrompt(); } } } else { DoWritePrompt(); } m_history.AddCommand( cmd ); }
// do the actual cleanup void CompileRequest::Process(IManager* manager) { wxString cmd; wxString errMsg; wxStringMap_t om; BuildSettingsConfig* bsc(manager ? manager->GetBuildSettingsConfigManager() : BuildSettingsConfigST::Get()); BuildManager* bm(manager ? manager->GetBuildManager() : BuildManagerST::Get()); clCxxWorkspace* w(manager ? manager->GetWorkspace() : clCxxWorkspaceST::Get()); EnvironmentConfig* env(manager ? manager->GetEnv() : EnvironmentConfig::Instance()); ProjectPtr proj = w->FindProjectByName(m_info.GetProject(), errMsg); if(!proj) { AppendLine(_("Cant find project: ") + m_info.GetProject()); return; } wxString pname(proj->GetName()); // BuilderPtr builder = bm->GetBuilder(wxT("GNU makefile for g++/gcc")); BuilderPtr builder = bm->GetSelectedBuilder(); if(m_fileName.IsEmpty() == false) { // we got a complie request of a single file cmd = m_preprocessOnly ? builder->GetPreprocessFileCmd(m_info.GetProject(), m_info.GetConfiguration(), m_fileName, errMsg) : builder->GetSingleFileCmd(m_info.GetProject(), m_info.GetConfiguration(), m_fileName); } else if(m_info.GetProjectOnly()) { switch(m_info.GetKind()) { case QueueCommand::kRebuild: cmd = builder->GetPORebuildCommand(m_info.GetProject(), m_info.GetConfiguration()); break; default: case QueueCommand::kBuild: cmd = builder->GetPOBuildCommand(m_info.GetProject(), m_info.GetConfiguration()); break; } } else { cmd = builder->GetBuildCommand(m_info.GetProject(), m_info.GetConfiguration()); } // Notify plugins that a compile process is going to start clBuildEvent event(wxEVT_BUILD_STARTING); event.SetProjectName(pname); event.SetConfigurationName(m_info.GetConfiguration()); if(EventNotifier::Get()->ProcessEvent(event)) { // the build is being handled by some plugin, no need to build it // using the standard way return; } // Send the EVENT_STARTED : even if this event is sent, next event will // be post, so no way to be sure the the build process has not started SendStartMsg(); // if we require to run the makefile generation command only, replace the 'cmd' with the // generation command line BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration()); if(m_premakeOnly && bldConf) { BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration()); if(bldConf) { cmd = bldConf->GetMakeGenerationCommand(); } } if(bldConf) { wxString cmpType = bldConf->GetCompilerType(); CompilerPtr cmp = bsc->GetCompiler(cmpType); if(cmp) { // Add the 'bin' folder of the compiler to the PATH environment variable wxString scxx = cmp->GetTool("CXX"); scxx.Trim().Trim(false); scxx.StartsWith("\"", &scxx); scxx.EndsWith("\"", &scxx); // Strip the double quotes wxFileName cxx(scxx); wxString pathvar; pathvar << cxx.GetPath() << clPATH_SEPARATOR; // If we have an additional path, add it as well if(!cmp->GetPathVariable().IsEmpty()) { pathvar << cmp->GetPathVariable() << clPATH_SEPARATOR; } pathvar << "$PATH"; om["PATH"] = pathvar; } } if(cmd.IsEmpty()) { // if we got an error string, use it if(errMsg.IsEmpty() == false) { AppendLine(errMsg); } else { AppendLine(_("Command line is empty. Build aborted.")); } return; } WrapInShell(cmd); DirSaver ds; DoSetWorkingDirectory(proj, false, m_fileName.IsEmpty() == false); // expand the variables of the command cmd = ExpandAllVariables(cmd, w, m_info.GetProject(), m_info.GetConfiguration(), m_fileName); // print the build command AppendLine(cmd + wxT("\n")); if(m_info.GetProjectOnly() || m_fileName.IsEmpty() == false) { // set working directory DoSetWorkingDirectory(proj, false, m_fileName.IsEmpty() == false); } // print the prefix message of the build start. This is important since the parser relies // on this message if(m_info.GetProjectOnly() || m_fileName.IsEmpty() == false) { wxString configName(m_info.GetConfiguration()); // also, send another message to the main frame, indicating which project is being built // and what configuration wxString text; text << wxGetTranslation(BUILD_PROJECT_PREFIX) << m_info.GetProject() << wxT(" - ") << configName << wxT(" ]"); if(m_fileName.IsEmpty()) { text << wxT("----------\n"); } else if(m_preprocessOnly) { text << wxT(" (Preprocess Single File)----------\n"); } else { text << wxT(" (Single File Build)----------\n"); } AppendLine(text); } EnvSetter envir(env, &om, proj->GetName()); m_proc = CreateAsyncProcess(this, cmd); if(!m_proc) { wxString message; message << _("Failed to start build process, command: ") << cmd << _(", process terminated with exit code: 0"); AppendLine(message); return; } }
//do the actual cleanup void CleanRequest::Process(IManager *manager) { wxString cmd; wxString errMsg; wxStringMap_t om; BuildSettingsConfig *bsc(manager ? manager->GetBuildSettingsConfigManager() : BuildSettingsConfigST::Get()); BuildManager * bm(manager ? manager->GetBuildManager() : BuildManagerST::Get()); Workspace * w(manager ? manager->GetWorkspace() : WorkspaceST::Get()); ProjectPtr proj = w->FindProjectByName(m_info.GetProject(), errMsg); if (!proj) { AppendLine(_("Cant find project: ") + m_info.GetProject()); return; } wxString pname (proj->GetName()); //BuilderPtr builder = bm->GetBuilder(wxT("GNU makefile for g++/gcc")); BuilderPtr builder = bm->GetSelectedBuilder(); if (m_info.GetProjectOnly()) { cmd = builder->GetPOCleanCommand(m_info.GetProject(), m_info.GetConfiguration()); } else { cmd = builder->GetCleanCommand(m_info.GetProject(), m_info.GetConfiguration()); } if ( cmd.IsEmpty() ) { AppendLine(_("Sorry, there is no 'Clean' command available\n")); return; } BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration()); if(bldConf) { wxString cmpType = bldConf->GetCompilerType(); CompilerPtr cmp = bsc->GetCompiler(cmpType); if(cmp) { wxString value( cmp->GetPathVariable() ); if(value.Trim().Trim(false).IsEmpty() == false) { wxLogMessage(wxString::Format(wxT("Setting PATH to '%s'"), value.c_str())); om[wxT("PATH")] = value.Trim().Trim(false); } } } else { AppendLine(_("Sorry, couldn't find the Build configuration\n")); return; } // Notify plugins that a compile process is going to start clBuildEvent event(wxEVT_BUILD_STARTING); event.SetProjectName( pname ); event.SetConfigurationName( m_info.GetConfiguration() ); if (EventNotifier::Get()->ProcessEvent(event)) { // the build is being handled by some plugin, no need to build it // using the standard way return; } SendStartMsg(); // Expand the variables of the command cmd = ExpandAllVariables(cmd, w, m_info.GetProject(), m_info.GetConfiguration(), wxEmptyString); WrapInShell(cmd); DirSaver ds; DoSetWorkingDirectory(proj, false, false); if (m_info.GetProjectOnly() ) { //need to change directory to project dir wxSetWorkingDirectory(proj->GetFileName().GetPath()); } //print the build command AppendLine(cmd + wxT("\n")); // print the prefix message of the build start. This is important since the parser relies // on this message if(m_info.GetProjectOnly()) { wxString configName(m_info.GetConfiguration()); //also, send another message to the main frame, indicating which project is being built //and what configuration wxString text; text << wxGetTranslation(CLEAN_PROJECT_PREFIX) << m_info.GetProject() << wxT(" - ") << configName << wxT(" ]"); text << wxT("----------\n"); AppendLine(text); } //apply environment settings EnvSetter env(NULL, &om, proj->GetName()); m_proc = CreateAsyncProcess(this, cmd); if ( !m_proc ) { //remove environment settings applied wxString message; message << _("Failed to start clean process, command: ") << cmd << _(", process terminated with exit code: 0"); AppendLine(message); return; } }
bool DbgGdb::Start( const DebugSessionInfo& si) { //set the environment variables EnvSetter env( m_env, NULL, m_debuggeeProjectName ); wxString dbgExeName; if ( ! DoLocateGdbExecutable( si.debuggerPath, dbgExeName ) ) { return false; } wxString cmd; #if defined (__WXGTK__) || defined (__WXMAC__) cmd << dbgExeName; if ( !si.ttyName.IsEmpty() ) { cmd << wxT( " --tty=" ) << si.ttyName; } cmd << wxT( " --interpreter=mi " ) << si.exeName; #else cmd << dbgExeName << wxT( " --interpreter=mi " ) << si.exeName; #endif m_debuggeePid = wxNOT_FOUND; m_attachedMode = false; m_observer->UpdateAddLine( wxString::Format( wxT( "Current working dir: %s" ), wxGetCwd().c_str() ) ); m_observer->UpdateAddLine( wxString::Format( wxT( "Launching gdb from : %s" ), si.cwd.c_str() ) ); m_observer->UpdateAddLine( wxString::Format( wxT( "Starting debugger : %s" ), cmd.c_str() ) ); #ifdef __WXMSW__ // When using remote debugging on Windows we need a console window, as this is the only // mechanism to send a Ctrl-C event and signal a SIGINT to interrupt the target. bool needs_console = GetIsRemoteDebugging() | m_info.showTerminal; #else bool needs_console = m_info.showTerminal; #endif m_gdbProcess = CreateAsyncProcess( this, cmd, // show console? needs_console ? IProcessCreateConsole : IProcessCreateDefault, si.cwd ); if ( !m_gdbProcess ) { return false; } #ifdef __WXMSW__ if ( GetIsRemoteDebugging() ) { // This doesn't really make sense, but AttachConsole fails without it... AllocConsole(); FreeConsole(); // Disconnect any existing console window. if ( !AttachConsole( m_gdbProcess->GetPid() ) ) m_observer->UpdateAddLine( wxString::Format(wxT("AttachConsole returned error %d"), GetLastError())); // We can at least make the window invisible if the user doesn't want to see it. if ( !m_info.showTerminal ) SetWindowPos(GetConsoleWindow(), HWND_BOTTOM, 0, 0, 0, 0, SWP_HIDEWINDOW); // Finally we ignore SIGINT so we don't get killed by our own signal signal(SIGINT, SIG_IGN); } #endif m_gdbProcess->SetHardKill( true ); DoInitializeGdb( si ); return true; }
void CustomBuildRequest::Process(IManager* manager) { wxString cmd; wxString errMsg; wxStringMap_t om; clCxxWorkspace* w(manager->GetWorkspace()); EnvironmentConfig* env(manager->GetEnv()); ProjectPtr proj = w->FindProjectByName(m_info.GetProject(), errMsg); if(!proj) { AppendLine(_("Cant find project: ") + m_info.GetProject()); return; } // Notify plugins that a compile process is going to start clBuildEvent event(wxEVT_BUILD_STARTING); event.SetProjectName(proj->GetName()); event.SetConfigurationName(m_info.GetConfiguration()); if(EventNotifier::Get()->ProcessEvent(event)) { // the build is being handled by some plugin, no need to build it // using the standard way return; } SendStartMsg(); BuildConfigPtr bldConf = w->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration()); if(!bldConf) { wxLogMessage(wxString::Format(wxT("Failed to find build configuration for project '%s' and configuration '%s'"), m_info.GetProject().c_str(), m_info.GetConfiguration().c_str())); return; } // try the special targets first: bool isClean(false); if(m_info.GetCustomBuildTarget() == wxT("Build")) { cmd = bldConf->GetCustomBuildCmd(); } else if(m_info.GetCustomBuildTarget() == wxT("Clean")) { cmd = bldConf->GetCustomCleanCmd(); isClean = true; } else if(m_info.GetCustomBuildTarget() == wxT("Rebuild")) { cmd = bldConf->GetCustomRebuildCmd(); } else if(m_info.GetCustomBuildTarget() == wxT("Compile Single File")) { cmd = bldConf->GetSingleFileBuildCommand(); } else if(m_info.GetCustomBuildTarget() == wxT("Preprocess File")) { cmd = bldConf->GetPreprocessFileCommand(); } // if still no luck, try with the other custom targets if(cmd.IsEmpty()) { std::map<wxString, wxString> targets = bldConf->GetCustomTargets(); std::map<wxString, wxString>::iterator iter = targets.find(m_info.GetCustomBuildTarget()); if(iter != targets.end()) { cmd = iter->second; } } if(cmd.IsEmpty()) { // if we got an error string, use it if(errMsg.IsEmpty() == false) { AppendLine(errMsg); } else { AppendLine(_("Command line is empty. Build aborted.")); } return; } // Working directory: // By default we use the project path ////////////////////////////////////////////////////// DirSaver ds; // first set the path to the project working directory ::wxSetWorkingDirectory(proj->GetFileName().GetPath()); // If a working directory was specified, use it instead wxString wd = bldConf->GetCustomBuildWorkingDir(); wd.Trim().Trim(false); wxString filename; if(manager->GetActiveEditor()) { filename = manager->GetActiveEditor()->GetFileName().GetFullPath(); } if(wd.IsEmpty()) { // use the project path wd = proj->GetFileName().GetPath(); } else { // expand macros from the working directory wd = ExpandAllVariables(wd, clCxxWorkspaceST::Get(), proj->GetName(), bldConf->GetName(), filename); } { // Ensure that the path to the working directory exist wxFileName fnwd(wd, ""); if(!fnwd.DirExists()) { fnwd.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL); } } ::wxSetWorkingDirectory(wd); // Print message to the build tab AppendLine(wxString::Format(_("MESSAGE: Entering directory `%s'\n"), wd.c_str())); // Command handling: ////////////////////////////////////////////////////// // expand the variables of the command cmd = ExpandAllVariables(cmd, w, m_info.GetProject(), m_info.GetConfiguration(), filename); // in case our configuration includes post/pre build commands // we generate a makefile to include them as well and we update // the build command bool bCommandAltered = DoUpdateCommand(manager, cmd, proj, bldConf, isClean); #ifdef __WXMSW__ // Windows CD command requires the paths to be backslashe if(cmd.Find(wxT("cd ")) != wxNOT_FOUND) cmd.Replace(wxT("/"), wxT("\\")); #endif // Wrap the build command in the shell, so it will be able // to perform 'chain' commands like // cd SOMEWHERE && make && ... // Dont wrap the command if it was altered previously if(!bCommandAltered) { WrapInShell(cmd); } // print the build command AppendLine(cmd + wxT("\n")); wxString configName(m_info.GetConfiguration()); // also, send another message to the main frame, indicating which project is being built // and what configuration wxString text; if(isClean) { text << wxGetTranslation(CLEAN_PROJECT_PREFIX); } else { text << wxGetTranslation(BUILD_PROJECT_PREFIX); } text << m_info.GetProject() << wxT(" - ") << configName << wxT(" ]----------\n"); AppendLine(text); // Avoid Unicode chars coming from the compiler by setting LC_ALL to "C" om["LC_ALL"] = "C"; EnvSetter environment(env, &om, proj->GetName()); m_proc = CreateAsyncProcess(this, cmd); if(!m_proc) { wxString message; message << _("Failed to start build process, command: ") << cmd << _(", process terminated with exit code: 0"); AppendLine(message); return; } }