undo not impl in lite

Author: kr-2003

src/xinterpreter.cpp

@@ -26,47 +26,66 @@
 
 using Args = std::vector<const char*>;
 
-void* createInterpreter(const Args &ExtraArgs = {}) {
-  Args ClangArgs = {/*"-xc++"*/"-v"}; // ? {"-Xclang", "-emit-llvm-only", "-Xclang", "-diagnostic-log-file", "-Xclang", "-", "-xc++"};
+void* createInterpreter(const Args& ExtraArgs = {})
+{
+    Args ClangArgs = {/*"-xc++"*/ "-v"};  // ? {"-Xclang", "-emit-llvm-only", "-Xclang",
+                                          // "-diagnostic-log-file", "-Xclang", "-", "-xc++"};
 #ifdef EMSCRIPTEN
-  ClangArgs.push_back("-std=c++20");
+    ClangArgs.push_back("-std=c++20");
 #else
-  if (std::find_if(ExtraArgs.begin(), ExtraArgs.end(), [](const std::string& s) {
-    return s == "-resource-dir";}) == ExtraArgs.end()) {
-    std::string resource_dir = Cpp::DetectResourceDir();
-    if (resource_dir.empty())
-      std::cerr << "Failed to detect the resource-dir\n";
-    ClangArgs.push_back("-resource-dir");
-    ClangArgs.push_back(resource_dir.c_str());
-  }
-  std::vector<std::string> CxxSystemIncludes;
-  Cpp::DetectSystemCompilerIncludePaths(CxxSystemIncludes);
-  for (const std::string& CxxInclude : CxxSystemIncludes) {
-    ClangArgs.push_back("-isystem");
-    ClangArgs.push_back(CxxInclude.c_str());
-  }
+    if (std::find_if(
+            ExtraArgs.begin(),
+            ExtraArgs.end(),
+            [](const std::string& s)
+            {
+                return s == "-resource-dir";
+            }
+        )
+        == ExtraArgs.end())
+    {
+        std::string resource_dir = Cpp::DetectResourceDir();
+        if (resource_dir.empty())
+        {
+            std::cerr << "Failed to detect the resource-dir\n";
+        }
+        ClangArgs.push_back("-resource-dir");
+        ClangArgs.push_back(resource_dir.c_str());
+    }
+    std::vector<std::string> CxxSystemIncludes;
+    Cpp::DetectSystemCompilerIncludePaths(CxxSystemIncludes);
+    for (const std::string& CxxInclude : CxxSystemIncludes)
+    {
+        ClangArgs.push_back("-isystem");
+        ClangArgs.push_back(CxxInclude.c_str());
+    }
 #endif
-  ClangArgs.insert(ClangArgs.end(), ExtraArgs.begin(), ExtraArgs.end());
-  // FIXME: We should process the kernel input options and conditionally pass
-  // the gpu args here.
-  return Cpp::CreateInterpreter(ClangArgs/*, {"-cuda"}*/);
+    ClangArgs.insert(ClangArgs.end(), ExtraArgs.begin(), ExtraArgs.end());
+    // FIXME: We should process the kernel input options and conditionally pass
+    // the gpu args here.
+    return Cpp::CreateInterpreter(ClangArgs /*, {"-cuda"}*/);
 }
 
 using namespace std::placeholders;
 
 namespace xcpp
 {
-    struct StreamRedirectRAII {
-      std::string &err;
-      StreamRedirectRAII(std::string &e) : err(e) {
-        Cpp::BeginStdStreamCapture(Cpp::kStdErr);
-        Cpp::BeginStdStreamCapture(Cpp::kStdOut);
-      }
-      ~StreamRedirectRAII() {
-        std::string out = Cpp::EndStdStreamCapture();
-        err = Cpp::EndStdStreamCapture();
-        std::cout << out;
-      }
+    struct StreamRedirectRAII
+    {
+        std::string& err;
+
+        StreamRedirectRAII(std::string& e)
+            : err(e)
+        {
+            Cpp::BeginStdStreamCapture(Cpp::kStdErr);
+            Cpp::BeginStdStreamCapture(Cpp::kStdOut);
+        }
+
+        ~StreamRedirectRAII()
+        {
+            std::string out = Cpp::EndStdStreamCapture();
+            err = Cpp::EndStdStreamCapture();
+            std::cout << out;
+        }
     };
 
     void interpreter::configure_impl()
@@ -101,14 +120,14 @@ __get_cxx_version ()
         return std::to_string(cxx_version);
     }
 
-    interpreter::interpreter(int argc, const char* const* argv) :
-        xmagics()
+    interpreter::interpreter(int argc, const char* const* argv)
+        : xmagics()
         , p_cout_strbuf(nullptr)
         , p_cerr_strbuf(nullptr)
         , m_cout_buffer(std::bind(&interpreter::publish_stdout, this, _1))
         , m_cerr_buffer(std::bind(&interpreter::publish_stderr, this, _1))
     {
-        //NOLINTNEXTLINE (cppcoreguidelines-pro-bounds-pointer-arithmetic)
+        // NOLINTNEXTLINE (cppcoreguidelines-pro-bounds-pointer-arithmetic)
         createInterpreter(Args(argv ? argv + 1 : argv, argv + argc));
         m_version = get_stdopt();
         redirect_output();
@@ -174,6 +193,9 @@ __get_cxx_version ()
             StreamRedirectRAII R(err);
             if (code.rfind("%undo", 0) == 0)
             {
+#ifdef EMSCRIPTEN
+                throw std::logic_error("Undo is not supported in xeus-cpp-lite");
+#else
                 int n = 1;  // Default value
                 if (code.length() > 5)
                 {
@@ -184,21 +206,28 @@ __get_cxx_version ()
                     catch (const std::invalid_argument&)
                     {
                         throw std::runtime_error(
-                            "Invalid format for %undo. Expected '%undo n' where n is an integer."
+                            "Invalid format for %undo. Expected '%undo n' where n is an integer"
                         );
                     }
                     catch (const std::out_of_range&)
                     {
-                        throw std::runtime_error("Number out of range for %undo.");
+                        throw std::runtime_error("Number out of range for %undo");
                     }
                 }
-                compilation_result = Cpp::Undo(n) ? true : false;
+                compilation_result = static_cast<bool>(Cpp::Undo(n));
+#endif
             }
             else
             {
                 compilation_result = Cpp::Process(code.c_str());
             }
         }
+        catch(std::logic_error& e)
+        {
+            errorlevel = 1;
+            ename = "Logic Error: ";
+            evalue = e.what();
+        }
         catch (std::exception& e)
         {
             errorlevel = 1;
@@ -239,10 +268,11 @@ __get_cxx_version ()
             //
             // JupyterLab displays the "{ename}: {evalue}" if the traceback is
             // empty.
-            if (evalue.size() < 4) {
+            if (evalue.size() < 4)
+            {
                 ename = " ";
             }
-            std::vector<std::string> traceback({ename  + evalue});
+            std::vector<std::string> traceback({ename + evalue});
             if (!config.silent)
             {
                 publish_execution_error(ename, evalue, traceback);
@@ -285,7 +315,8 @@ __get_cxx_version ()
 
         Cpp::CodeComplete(results, code.c_str(), 1, _cursor_pos + 1);
 
-        return xeus::create_complete_reply(results /*matches*/,
+        return xeus::create_complete_reply(
+            results /*matches*/,
             cursor_pos - to_complete.length() /*cursor_start*/,
             cursor_pos /*cursor_end*/
         );
@@ -306,13 +337,17 @@ __get_cxx_version ()
 
     nl::json interpreter::is_complete_request_impl(const std::string& code)
     {
-        if (!code.empty() && code[code.size() - 1] == '\\') {
+        if (!code.empty() && code[code.size() - 1] == '\\')
+        {
             auto found = code.rfind('\n');
             if (found == std::string::npos)
+            {
                 found = -1;
+            }
             auto found1 = found++;
-            while (isspace(code[++found1])) ;
-            return xeus::create_is_complete_reply("incomplete", code.substr(found, found1-found));
+            while (isspace(code[++found1]))
+                ;
+            return xeus::create_is_complete_reply("incomplete", code.substr(found, found1 - found));
         }
 
         return xeus::create_is_complete_reply("complete");
@@ -386,11 +421,11 @@ __get_cxx_version ()
 
     void interpreter::init_preamble()
     {
-        //NOLINTBEGIN(cppcoreguidelines-owning-memory)
+        // NOLINTBEGIN(cppcoreguidelines-owning-memory)
         preamble_manager.register_preamble("introspection", std::make_unique<xintrospection>());
         preamble_manager.register_preamble("magics", std::make_unique<xmagics_manager>());
         preamble_manager.register_preamble("shell", std::make_unique<xsystem>());
-        //NOLINTEND(cppcoreguidelines-owning-memory)
+        // NOLINTEND(cppcoreguidelines-owning-memory)
     }
 
     void interpreter::init_magic()