abdel likes short code

[lyx.git] / src / support / ForkedCalls.cpp

diff --git a/src/support/ForkedCalls.cpp b/src/support/ForkedCalls.cpp
index 965649545561ab79637e6e1cc5764b25df4af4ef..0768652cfb744d2a4a27b1d9ea41e7705bbd7519 100644 (file)
--- a/src/support/ForkedCalls.cpp
+++ b/src/support/ForkedCalls.cpp
@@ -34,6 +34,7 @@
 # define SIGKILL 9
 # include <windows.h>
 # include <process.h>
+# undef max
 #else
 # include <csignal>
 # include <cstdlib>
@@ -41,20 +42,11 @@
 #  include <unistd.h>
 # endif
 # include <sys/wait.h>
-# ifndef CXX_GLOBAL_CSTD
-  using std::signal;
-  using std::strerror;
-# endif
 #endif
 
-using boost::bind;
-
-using std::endl;
-using std::equal_to;
-using std::find_if;
-using std::string;
-using std::vector;
+using namespace std;
 
+using boost::bind;
 
 namespace lyx {
 namespace support {
@@ -72,11 +64,10 @@ public:
        //
        static void killItDead(int secs, pid_t pid)
        {
-               if (secs > 0) {
+               if (secs > 0)
                        new Murder(secs, pid);
-               } else if (pid != 0) {
+               else if (pid != 0)
                        support::kill(pid, SIGKILL);
-               }
        }
 
        //
@@ -84,27 +75,21 @@ public:
        {
                if (pid_ != 0)
                        support::kill(pid_, SIGKILL);
-               lyxerr << "Killed " << pid_ << std::endl;
+               lyxerr << "Killed " << pid_ << endl;
                delete this;
        }
 
 private:
        //
        Murder(int secs, pid_t pid)
-               : timeout_(0), pid_(pid)
+               : timeout_(1000*secs, Timeout::ONETIME), pid_(pid)
        {
-               timeout_ = new Timeout(1000*secs, Timeout::ONETIME);
-               timeout_->timeout.connect(boost::bind(&Murder::kill, this));
-               timeout_->start();
+               timeout_.timeout.connect(boost::bind(&Murder::kill, this));
+               timeout_.start();
        }
 
        //
-       ~Murder()
-       {
-               delete timeout_;
-       }
-       //
-       Timeout * timeout_;
+       Timeout timeout_;
        //
        pid_t pid_;
 };
@@ -123,6 +108,9 @@ ForkedProcess::ForkedProcess()
 {}
 
 
+bool ForkedProcess::IAmAChild = false;
+
+
 void ForkedProcess::emitSignal()
 {
        if (signal_.get()) {
@@ -134,10 +122,14 @@ void ForkedProcess::emitSignal()
 // Spawn the child process
 int ForkedProcess::run(Starttype type)
 {
-       retval_  = 0;
+       retval_ = 0;
        pid_ = generateChild();
        if (pid_ <= 0) { // child or fork failed.
                retval_ = 1;
+               if (pid_ == 0)
+                       //we also do this in fork(), too, but maybe someone will try
+                       //to bypass that
+                       IAmAChild = true; 
                return retval_;
        }
 
@@ -183,26 +175,34 @@ void ForkedProcess::kill(int tol)
                return;
        }
 
-       // The weird (std::max)(a,b) signature prevents expansion
-       // of an evil MSVC macro.
-       int const tolerance = (std::max)(0, tol);
+       int const tolerance = max(0, tol);
        if (tolerance == 0) {
                // Kill it dead NOW!
                Murder::killItDead(0, pid());
-
        } else {
                int ret = support::kill(pid(), SIGHUP);
 
                // The process is already dead if wait_for_death is false
                bool const wait_for_death = (ret == 0 && errno != ESRCH);
 
-               if (wait_for_death) {
+               if (wait_for_death)
                        Murder::killItDead(tolerance, pid());
-               }
        }
 }
 
 
+pid_t ForkedProcess::fork() {
+#if !defined (HAVE_FORK)
+       return -1;
+#else
+       pid_t pid = ::fork();
+       if (pid == 0)
+               IAmAChild = true;
+       return pid;
+#endif
+}
+
+
 // Wait for child process to finish. Returns returncode from child.
 int ForkedProcess::waitForChild()
 {
@@ -219,14 +219,14 @@ int ForkedProcess::waitForChild()
                DWORD exit_code = 0;
                if (!GetExitCodeProcess(hProcess, &exit_code)) {
                        lyxerr << "GetExitCodeProcess failed waiting for child\n"
-                              << getChildErrorMessage() << std::endl;
+                              << getChildErrorMessage() << endl;
                } else
                        retval_ = exit_code;
                break;
        }
        case WAIT_FAILED:
                lyxerr << "WaitForSingleObject failed waiting for child\n"
-                      << getChildErrorMessage() << std::endl;
+                      << getChildErrorMessage() << endl;
                break;
        }
 
@@ -367,7 +367,7 @@ int ForkedCall::generateChild()
                for (; ait != aend; ++ait)
                        if (*ait)
                                lyxerr << '\t'<< *ait << '\n';
-               lyxerr << "</command>" << std::endl;
+               lyxerr << "</command>" << endl;
        }
 
 #ifdef _WIN32
@@ -403,16 +403,16 @@ int ForkedCall::generateChild()
 namespace ForkedCallQueue {
 
 /// A process in the queue
-typedef std::pair<std::string, ForkedCall::SignalTypePtr> Process;
+typedef pair<string, ForkedCall::SignalTypePtr> Process;
 /** Add a process to the queue. Processes are forked sequentially
  *  only one is running at a time.
  *  Connect to the returned signal and you'll be informed when
  *  the process has ended.
  */
-ForkedCall::SignalTypePtr add(std::string const & process);
+ForkedCall::SignalTypePtr add(string const & process);
 
 /// in-progress queue
-static std::queue<Process> callQueue_;
+static queue<Process> callQueue_;
 
 /// flag whether queue is running
 static bool running_ = 0;
@@ -504,7 +504,7 @@ string const getChildErrorMessage()
                (LPTSTR) &t_message, 0, 0
                ) != 0;
 
-       std::ostringstream ss;
+       ostringstream ss;
        ss << "LyX: Error waiting for child: " << error_code;
 
        if (ok) {
@@ -521,7 +521,7 @@ string const getChildErrorMessage()
 namespace ForkedCallsController {
 
 typedef boost::shared_ptr<ForkedProcess> ForkedProcessPtr;
-typedef std::list<ForkedProcessPtr> ListType;
+typedef list<ForkedProcessPtr> ListType;
 typedef ListType::iterator iterator;
 
 
@@ -565,7 +565,7 @@ void handleCompletedProcesses()
                        DWORD exit_code = 0;
                        if (!GetExitCodeProcess(hProcess, &exit_code)) {
                                lyxerr << "GetExitCodeProcess failed waiting for child\n"
-                                      << getChildErrorMessage() << std::endl;
+                                      << getChildErrorMessage() << endl;
                                // Child died, so pretend it returned 1
                                actCall->setRetValue(1);
                        } else {
@@ -576,7 +576,7 @@ void handleCompletedProcesses()
                }
                case WAIT_FAILED:
                        lyxerr << "WaitForSingleObject failed waiting for child\n"
-                              << getChildErrorMessage() << std::endl;
+                              << getChildErrorMessage() << endl;
                        actCall->setRetValue(1);
                        remove_it = true;
                        break;