Merge lp:~zorba-coders/zorba/debugger_ctrl_c into lp:zorba

[Gabriel Petrovay]

Added Ctrl-C hooking in the debugger. Ctrl-C can not kill the debugger anymore. It will only stop the running query.

Added Ctrl-C hooking in the debugger. Ctrl-C can not kill the debugger anymore. It will only stop the running query.

[Gabriel Petrovay (gabipetrovay)]

review: Approve

[David Graf (davidagraf)]

I tested it. Works really nice. I just have some little comments concerning the code:

1)
Do we already have a bug entry for this:
336 // TODO: this was the initial implementation. This will have to change
337 - this->sleep_(1000);
338 + this->sleep_(250);

2)
Do these lines of code block the default behavior of ctrl-C? If yes, can you please at a comment?
134 +#ifdef WIN32
135 +BOOL WINAPI
136 +ctrlC_Handler(DWORD aCtrlType)
137 +{
138 + if (CTRL_C_EVENT == aCtrlType) {
139 + return true;
140 + }
141 + return false;
142 +}
143 +#else
144 +void
145 +ctrlC_Handler(int lParam)
146 +{
147 + //exit(1);
148 +}
149 +#endif
150 +

3)
Strange variable name: theNotBremse :-)

review: Needs Fixing

[lp:~zorba-coders/zorba/debugger_ctrl_c]

10621. By Gabriel Petrovay on 2012-01-18

comment renamings in code

Unmerged revisions

=== modified file 'bin/CMakeLists.txt'
--- bin/CMakeLists.txt	2012-01-11 17:30:25 +0000
+++ bin/CMakeLists.txt	2012-01-18 12:03:24 +0000
@@ -31,6 +31,7 @@
 
   SET (DEBUG_CLIENT_SRCS
     debugger/main.cpp
+    debugger/xqdb_client.cpp
     debugger/process_listener.cpp
     debugger/command_prompt.cpp
     debugger/command_line_handler.cpp

=== modified file 'bin/debugger/command_prompt.cpp'
--- bin/debugger/command_prompt.cpp	2012-01-11 17:30:25 +0000
+++ bin/debugger/command_prompt.cpp	2012-01-18 12:03:24 +0000
@@ -94,6 +94,8 @@
 void
 CommandPrompt::execute()
 {
+  bool lWithOutput = true;
+
   for (;;) {
 #ifdef ZORBA_HAVE_LIBEDIT_H
     const char* lBuf;
@@ -101,10 +103,19 @@
     lBuf = el_gets(theEditLine, &lCharsRead);
     std::string lCommandLine(lBuf, lCharsRead - 1);
 #else
-    std::cout << "(xqdb) ";
+    if (lWithOutput) {
+      std::cout << "(xqdb) ";
+    }
+    lWithOutput = true;
     std::string lCommandLine;
     std::getline(std::cin, lCommandLine);
+    if (std::cin.fail()) {
+      lWithOutput = false;
+      std::cin.clear();
+      continue;
+    }
 #endif
+    
     std::vector<std::string> lArgs;
 
     // split the command into arguments

=== modified file 'bin/debugger/main.cpp'
--- bin/debugger/main.cpp	2012-01-11 17:30:25 +0000
+++ bin/debugger/main.cpp	2012-01-18 12:03:24 +0000
@@ -24,67 +24,47 @@
 
 #include <zorba/config.h>
 
-#include "command_prompt.h"
-#include "command_line_handler.h"
+#include "xqdb_client.h"
 #include "process_listener.h"
 
+
 using namespace zorba;
 using namespace zorba::debugger;
 
-class XqdbClient {
-
-  public:
-
-    XqdbClient(unsigned int aPort)
-    {
-      theIdQueue = new LockFreeQueue<std::size_t>();
-      theQuitQueue = new LockFreeQueue<bool>();
-      theEventHandler = new EventHandler(*theIdQueue, *theQuitQueue);
-      theEventHandler->init();
-
-      theCommandPrompt = new CommandPrompt();
-      theCommandLineHandler = new CommandLineHandler(aPort, *theIdQueue, *theQuitQueue, theEventHandler, theCommandPrompt);
-    }
-
-    ~XqdbClient()
-    {
-      if (theCommandLineHandler) {
-        delete theCommandLineHandler;
-      }
-      if (theCommandPrompt) {
-        delete theCommandPrompt;
-      }
-      if (theEventHandler) {
-        delete theEventHandler;
-      }
-
-      delete theIdQueue;
-      delete theQuitQueue;
-    }
-
-    void start()
-    {
-      theCommandLineHandler->execute();
-    }
-
-  private:
-
-    LockFreeQueue<std::size_t>* theIdQueue;
-    LockFreeQueue<bool>*        theQuitQueue;
-
-    EventHandler*       theEventHandler;
-    CommandPrompt*      theCommandPrompt;
-    CommandLineHandler* theCommandLineHandler;
-};
-
-
+
+std::auto_ptr<XqdbClient> theClient;
+
+// this will make sure the xqdb process will not quit when Ctrl-C is pressed
+#ifdef WIN32
+BOOL WINAPI
+ctrlC_Handler(DWORD aCtrlType)
+{
+  if (CTRL_C_EVENT == aCtrlType) {
+    return true;
+  }
+  return false;
+}
+#else
+void
+ctrlC_Handler(int lParam)
+{
+  // an empty sugnal handler on Linux should do the job
+}
+#endif
+
+
+// this handler function is passed the the zorba process listener and will
+// the client if the zorba process terminates
 void
 onExitProcess(ExitCode aExitCode) {
-  //if (aExitCode != -1) {
-  //  std::cout << "Zorba has exited with code: " << aExitCode << std::endl;
-  //}
-  std::cout << "Terminating debugger client."<< std::endl;
-  // TODO: and the memory?
+  std::cout << std::endl << "Terminating debugger client." << std::endl;
+
+#ifndef WIN32
+  XqdbClient* lClient = theClient.release();
+  if (lClient) {
+    delete lClient;
+  }
+#endif
 
   exit(aExitCode);
 }
@@ -322,6 +302,12 @@
 _tmain(int argc, _TCHAR* argv[])
 #endif
 {
+#ifdef WIN32
+  SetConsoleCtrlHandler(ctrlC_Handler, TRUE);
+#else
+  signal(SIGINT, ctrlC_Handler);
+#endif
+
   // **************************************************************************
   // processing arguments
 
@@ -369,12 +355,19 @@
     // **************************************************************************
     // start the debugger command line
 
-    std::auto_ptr<XqdbClient> theClient(new XqdbClient(lPort));
+    theClient.reset(new XqdbClient(lPort));
     theClient->start();
 
   } catch (...) {
     return -1;
   }
 
+#ifndef WIN32
+  XqdbClient* lClient = theClient.release();
+  if (lClient) {
+    delete lClient;
+  }
+#endif
+
   return 0;
 }

=== added file 'bin/debugger/xqdb_client.cpp'
--- bin/debugger/xqdb_client.cpp	1970-01-01 00:00:00 +0000
+++ bin/debugger/xqdb_client.cpp	2012-01-18 12:03:24 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "xqdb_client.h"
+
+#include <iostream>
+
+#ifdef ZORBA_HAVE_PTHREAD_H
+# include <cassert>
+#endif
+
+
+namespace zorba { namespace debugger {
+
+XqdbClient::XqdbClient(unsigned int aPort)
+{
+  theIdQueue = new LockFreeQueue<std::size_t>();
+  theQuitQueue = new LockFreeQueue<bool>();
+  theEventHandler = new EventHandler(*theIdQueue, *theQuitQueue);
+  theEventHandler->init();
+
+  theCommandPrompt = new CommandPrompt();
+  theCommandLineHandler = new CommandLineHandler(aPort, *theIdQueue, *theQuitQueue, theEventHandler, theCommandPrompt);
+}
+
+XqdbClient::~XqdbClient()
+{
+  if (theCommandLineHandler) {
+    delete theCommandLineHandler;
+  }
+  if (theCommandPrompt) {
+    delete theCommandPrompt;
+  }
+  if (theEventHandler) {
+    delete theEventHandler;
+  }
+
+  delete theIdQueue;
+  delete theQuitQueue;
+}
+
+void
+XqdbClient::start()
+{
+  theCommandLineHandler->execute();
+}
+
+
+} // namespace zorba
+} // namespace debugger

=== added file 'bin/debugger/xqdb_client.h'
--- bin/debugger/xqdb_client.h	1970-01-01 00:00:00 +0000
+++ bin/debugger/xqdb_client.h	2012-01-18 12:03:24 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_DEBUGGER_XQDB_CLIENT_H
+#define ZORBA_DEBUGGER_XQDB_CLIENT_H
+
+#include "command_prompt.h"
+#include "command_line_handler.h"
+
+
+namespace zorba { namespace debugger {
+
+class XqdbClient {
+
+  public:
+
+    XqdbClient(unsigned int aPort);
+
+    ~XqdbClient();
+
+    void
+    start();
+
+  private:
+
+    LockFreeQueue<std::size_t>* theIdQueue;
+    LockFreeQueue<bool>*        theQuitQueue;
+
+    EventHandler*       theEventHandler;
+    CommandPrompt*      theCommandPrompt;
+    CommandLineHandler* theCommandLineHandler;
+};
+
+  
+} // namespace zorba
+} // namespace debugger
+
+#endif // ZORBA_DEBUGGER_XQDB_CLIENT_H

=== modified file 'src/debugger/debugger_clientimpl.cpp'
--- src/debugger/debugger_clientimpl.cpp	2012-01-11 17:30:25 +0000
+++ src/debugger/debugger_clientimpl.cpp	2012-01-18 12:03:24 +0000
@@ -53,17 +53,22 @@
     lStr >> length;
 #endif
 
-    // we are not interested in the length, but only in the init message
     std::getline(*(theClient->theInStream), str, '\0');
 
+    // only assert if we have a good stream (no stream was broken,
+    // case in which an empty string will be returned)
+    if (theClient->theInStream->good()) {
 #ifndef NDEBUG
-    assert(str.size() == length);
+      assert(str.size() == length);
 #endif
+    } else {
+      break;
+    }
 
     theClient->theHandler->parseMessage(str);
 
     // TODO: this was the initial implementation. This will have to change
-    this->sleep_(1000);
+    this->sleep_(250);
   }
 }
   

=== modified file 'src/debugger/debugger_commons.cpp'
--- src/debugger/debugger_commons.cpp	2012-01-11 17:30:25 +0000
+++ src/debugger/debugger_commons.cpp	2012-01-18 12:03:24 +0000
@@ -35,6 +35,8 @@
 
 #include "zorba/util/uri.h"
 
+#include "debugger_runtime.h"
+
 namespace zorba {
 
 // ****************************************************************************
@@ -382,8 +384,12 @@
 bool
 DebuggerCommons::mustBreak(SuspensionCause& aCause)
 {
+  if (theRuntime->getAndClearInterruptBreak()) {
+    aCause = CAUSE_USER;
+    return true;
+  }
   if (theBreak) {
-    aCause = CAUSE_STEP;
+    aCause = theCause;
     return true;
   } else if (theStepping) {
     std::size_t lSize = theIteratorStack.size();

=== modified file 'src/debugger/debugger_runtime.cpp'
--- src/debugger/debugger_runtime.cpp	2012-01-11 17:30:25 +0000
+++ src/debugger/debugger_runtime.cpp	2012-01-18 12:03:24 +0000
@@ -60,7 +60,8 @@
   Zorba_SerializerOptions& serializerOptions,
   DebuggerCommunicator* communicator,
   itemHandler aHandler,
-  void* aCallBackData)
+  void* aCallBackData,
+  bool* aInterruptBreak)
   : theQuery(xqueryImpl),
     theOStream(oStream),
     theSerializerOptions(serializerOptions),
@@ -71,7 +72,8 @@
     theSerializer(0),
     theItemHandler(aHandler),
     theCallbackData(aCallBackData),
-    theLastContinuationCommand()
+    theLastContinuationCommand(),
+    theInterruptBreak(aInterruptBreak)
 {
 }
 
@@ -320,6 +322,7 @@
   if (theExecStatus != QUERY_SUSPENDED) {
     return;
   }
+  *theInterruptBreak = false;
   theExecStatus = QUERY_RUNNING;
   resume();
 }
@@ -500,6 +503,17 @@
 }
 
 
+bool
+DebuggerRuntime::getAndClearInterruptBreak()
+{
+  bool lMustBreak = *theInterruptBreak;
+  if (lMustBreak) {
+    *theInterruptBreak = false;
+  }
+  return lMustBreak;
+}
+
+
 std::list<std::pair<zstring, zstring> >
 DebuggerRuntime::eval(zstring& aExpr)
 {
@@ -700,7 +714,8 @@
     theSerializerOptions,
     theCommunicator,
     theItemHandler,
-    theCallbackData);
+    theCallbackData,
+    theInterruptBreak);
 
   lNewRuntime->theBreakpoints = theBreakpoints;
   return lNewRuntime;

=== modified file 'src/debugger/debugger_runtime.h'
--- src/debugger/debugger_runtime.h	2012-01-11 17:30:25 +0000
+++ src/debugger/debugger_runtime.h	2012-01-18 12:03:24 +0000
@@ -48,11 +48,12 @@
 
     DebuggerRuntime(
       XQueryImpl* xqueryImpl,
-      std::ostream& oStream,
+      std::ostream& outStream,
       Zorba_SerializerOptions&  serializerOptions,
       DebuggerCommunicator* communicator,
-      itemHandler aHandler,
-      void* aCallBackData);
+      itemHandler handler,
+      void* callBackData,
+      bool* interruptBreak);
 
     virtual ~DebuggerRuntime();
 
@@ -151,6 +152,9 @@
     void
     stepOut();
 
+    bool
+    getAndClearInterruptBreak();
+
     DebuggerRuntime*
     clone();
 
@@ -174,8 +178,8 @@
     serializer*                       theSerializer;
     itemHandler                       theItemHandler;
     void*                             theCallbackData;
-
     std::pair<int, std::string>       theLastContinuationCommand;
+    bool*                             theInterruptBreak;
   };
 }
 

=== modified file 'src/debugger/debugger_server.cpp'
--- src/debugger/debugger_server.cpp	2012-01-11 17:30:25 +0000
+++ src/debugger/debugger_server.cpp	2012-01-18 12:03:24 +0000
@@ -18,6 +18,9 @@
 #include "debugger_server.h"
 
 #include <sstream>
+#ifndef WIN32
+# include <signal.h>
+#endif
 
 #include <zorba/base64.h>
 #include <zorba/util/uri.h>
@@ -34,6 +37,31 @@
 
 namespace zorba {
 
+bool theInterruptBreak = false;
+
+// this will make sure the zorba when run in debug (i.e. with the debugger)
+// will not terminate when Ctrl-C is pressed but trigger a query interruption
+// break through the theInterruptBreak variable that is continuously monitored
+// by the debugger commons through the debugger runtime
+#ifdef WIN32
+BOOL WINAPI
+DebuggerServer::ctrlC_Handler(DWORD aCtrlType)
+{
+  if (CTRL_C_EVENT == aCtrlType) {
+    theInterruptBreak = true;
+    return true;
+  }
+  return false;
+}
+#else
+void
+DebuggerServer::ctrlC_Handler(int lParam)
+{
+  theInterruptBreak = true;
+}
+#endif
+
+
 DebuggerServer::DebuggerServer(
   XQueryImpl*               aQuery,
   Zorba_SerializerOptions&  aSerializerOptions,
@@ -47,7 +75,8 @@
   theCommunicator = new DebuggerCommunicator(aHost, aPort);
   theRuntime = new DebuggerRuntime(
     aQuery, aOstream, aSerializerOptions,
-    theCommunicator, aHandler, aCallbackData);
+    theCommunicator, aHandler, aCallbackData,
+    &theInterruptBreak);
 #ifdef WIN32
   theFileName = aQuery->getFileName().str();
 #else
@@ -66,9 +95,17 @@
   delete theCommunicator;
 }
 
+
 bool
 DebuggerServer::run()
 {
+  // add the interrupt handlers to catch Ctrl-C
+  #ifdef WIN32
+    SetConsoleCtrlHandler(DebuggerServer::ctrlC_Handler, TRUE);
+  #else
+    signal(SIGINT, ctrlC_Handler);
+  #endif
+
   theCommunicator->connect();
 
   if (!theCommunicator->isConnected()) {

=== modified file 'src/debugger/debugger_server.h'
--- src/debugger/debugger_server.h	2011-12-21 14:40:33 +0000
+++ src/debugger/debugger_server.h	2012-01-18 12:03:24 +0000
@@ -59,6 +59,15 @@
 
   private:
 
+#ifdef WIN32
+    static BOOL WINAPI
+    ctrlC_Handler(DWORD aCtrlType);
+#else
+    static void
+    ctrlC_Handler(int lParam);
+#endif
+
+
     std::string
     processCommand(DebuggerCommand command);