refactor(util/script_state): replace std::recursive_mutex with std::mutex, and use unlock_guard

The unlock_guard and exec_unprotected will be useful also for implementing the Lua tactic API.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

src/frontends/lean/register_module.cpp

@@ -19,8 +19,11 @@ static int parse_lean_expr_core(lua_State * L, ro_environment const & env, io_st
     char const * src = luaL_checkstring(L, 1);
     std::istringstream in(src);
     script_state S   = to_script_state(L);
-    push_expr(L, parse_expr(env, st, in, &S));
-    return 1;
+    expr r;
+    S.exec_unprotected([&]() {
+            r = parse_expr(env, st, in, &S);
+        });
+    return push_expr(L, r);
 }
 
 /** \see parse_lean_expr */
@@ -75,7 +78,9 @@ static void parse_lean_cmds_core(lua_State * L, rw_environment & env, io_state &
     char const * src = luaL_checkstring(L, 1);
     std::istringstream in(src);
     script_state S   = to_script_state(L);
+    S.exec_unprotected([&]() {
             parse_commands(env, st, in, &S);
+        });
 }
 
 /** \see parse_lean_cmds */

src/util/script_state.cpp

@@ -42,7 +42,7 @@ static char g_weak_ptr_key; // key for Lua registry (used at get_weak_ptr and sa
 
 struct script_state::imp {
     lua_State * m_state;
-    std::recursive_mutex  m_mutex;
+    std::mutex  m_mutex;
 
     static std::weak_ptr<imp> * get_weak_ptr(lua_State * L) {
         lua_pushlightuserdata(L, static_cast<void *>(&g_weak_ptr_key));
@@ -92,12 +92,12 @@ struct script_state::imp {
     }
 
     void dofile(char const * fname) {
-        std::lock_guard<std::recursive_mutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         ::lean::dofile(m_state, fname);
     }
 
     void dostring(char const * str) {
-        std::lock_guard<std::recursive_mutex> lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         ::lean::dostring(m_state, str);
     }
 };
@@ -126,7 +126,7 @@ void script_state::dostring(char const * str) {
     m_ptr->dostring(str);
 }
 
-std::recursive_mutex & script_state::get_mutex() {
+std::mutex & script_state::get_mutex() {
     return m_ptr->m_mutex;
 }
 

src/util/script_state.h

@@ -8,6 +8,7 @@ Author: Leonardo de Moura
 #include <memory>
 #include <mutex>
 #include <lua.hpp>
+#include "util/unlock_guard.h"
 
 namespace lean {
 /**
@@ -20,12 +21,12 @@ private:
     std::shared_ptr<imp> m_ptr;
     script_state(std::weak_ptr<imp> const & ptr);
     friend script_state to_script_state(lua_State * L);
-    std::recursive_mutex & get_mutex();
+    std::mutex & get_mutex();
     lua_State * get_state();
     friend class data_channel;
 public:
     script_state();
-    virtual ~script_state();
+    ~script_state();
 
     /**
        \brief Execute the file with the given name.
@@ -36,14 +37,14 @@ public:
        \brief Execute the given string.
        This method throws an exception if an error occurs.
     */
-    virtual void dostring(char const * str);
+    void dostring(char const * str);
 
     /**
        \brief Execute \c f in the using the internal Lua State.
     */
     template<typename F>
     typename std::result_of<F(lua_State * L)>::type apply(F && f) {
-        std::lock_guard<std::recursive_mutex> lock(get_mutex());
+        std::lock_guard<std::mutex> lock(get_mutex());
         return f(get_state());
     }
 
@@ -51,6 +52,17 @@ public:
     static void register_module(reg_fn f);
 
     static void register_code(char const * code);
+
+    /**
+       \brief Auxiliary function for writing API bindings
+       that release the lock to this object while executing
+       \c f.
+    */
+    template<typename F>
+    void exec_unprotected(F && f) {
+        unlock_guard unlock(get_mutex());
+        f();
+    }
 };
 /**
    \brief Return a reference to the script_state object that is wrapping \c L.

src/util/unlock_guard.h

@@ -0,0 +1,42 @@
+/*
+Copyright (c) 2013 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+
+Author: Leonardo de Moura
+*/
+#pragma once
+#include <mutex>
+namespace lean {
+/**
+   \brief The class \c unlock_guard is a mutex wrapper that provides a
+   convenient RAII-style mechanism for releasing a mutex for the
+   duration of a scoped block.
+
+   It is the dual of lock_guard in the standard library.
+
+   Example:
+   <code>
+      {
+         std::lock_guard<std::mutex> lock(m);
+         ...
+         {
+             unlock_guard unlock(m);
+             ...
+         }
+         ...
+     }
+   </code>
+
+   \warning The calling thread must own the lock to m_mutex
+*/
+class unlock_guard {
+    std::mutex & m_mutex;
+public:
+    explicit unlock_guard(std::mutex & m):m_mutex(m) { m_mutex.unlock(); }
+    unlock_guard(unlock_guard const &) = delete;
+    unlock_guard(unlock_guard &&) = delete;
+    unlock_guard & operator=(unlock_guard const &) = delete;
+    unlock_guard & operator=(unlock_guard &&) = delete;
+    ~unlock_guard() { m_mutex.lock(); }
+};
+}