Make tracking/checking of context more obvious

When C++ code is called from Lua we need to know in which context we
are, because calling some functions is only allowed in certain contexts.

Author: joto

src/output-flex.cpp

@@ -69,8 +69,8 @@ static char const osm2pgsql_table_name[] = "osm2pgsql.table";
 static char const osm2pgsql_object_metatable[] = "osm2pgsql.object_metatable";
 
 prepared_lua_function_t::prepared_lua_function_t(lua_State *lua_state,
-                                                 char const *name,
-                                                 int nresults)
+                                                 calling_context context,
+                                                 char const *name, int nresults)
 {
     int const index = lua_gettop(lua_state);
 
@@ -80,6 +80,7 @@ prepared_lua_function_t::prepared_lua_function_t(lua_State *lua_state,
         m_index = index;
         m_name = name;
         m_nresults = nresults;
+        m_calling_context = context;
         return;
     }
 
@@ -540,6 +541,12 @@ std::size_t output_flex_t::get_way_nodes()
 
 int output_flex_t::app_get_bbox()
 {
+    if (m_calling_context != calling_context::process_node &&
+        m_calling_context != calling_context::process_way) {
+        throw std::runtime_error{"The function get_bbox() can only be called"
+                                 " from process_node() or process_way()"};
+    }
+
     if (lua_gettop(lua_state()) > 1) {
         throw std::runtime_error{"No parameter(s) needed for get_box()"};
     }
@@ -726,9 +733,9 @@ void output_flex_t::setup_flex_table_columns(flex_table_t *table)
 
 int output_flex_t::app_define_table()
 {
-    if (m_context_node || m_context_way || m_context_relation) {
-        throw std::runtime_error{"Tables have to be defined before calling any "
-                                 "of the process callbacks"};
+    if (m_calling_context != calling_context::main) {
+        throw std::runtime_error{"Database tables have to be defined in the"
+                                 " main Lua code, not in any of the callbacks"};
     }
 
     luaL_checktype(lua_state(), 1, LUA_TTABLE);
@@ -791,8 +798,17 @@ int output_flex_t::table_tostring()
 
 int output_flex_t::table_add_row()
 {
+    if (m_calling_context != calling_context::process_node &&
+        m_calling_context != calling_context::process_way &&
+        m_calling_context != calling_context::process_relation) {
+        throw std::runtime_error{
+            "The function add_row() can only be called from the "
+            "process_node/way/relation() functions"};
+    }
+
     if (lua_gettop(lua_state()) != 2) {
-        throw std::runtime_error{"Need two parameters: The osm2pgsql.table and the row data"};
+        throw std::runtime_error{
+            "Need two parameters: The osm2pgsql.table and the row data"};
     }
 
     auto &table_connection =
@@ -823,9 +839,6 @@ int output_flex_t::table_add_row()
                 "Trying to add relation to table '{}'"_format(table.name())};
         }
         add_row(&table_connection, *m_context_relation);
-    } else {
-        throw std::runtime_error{"The add_row() function can only be called "
-                                 "from inside a process function"};
     }
 
     return 0;
@@ -1009,6 +1022,8 @@ void output_flex_t::call_lua_function(prepared_lua_function_t func,
 {
     std::lock_guard<std::mutex> guard{lua_mutex};
 
+    m_calling_context = func.context();
+
     lua_pushvalue(lua_state(), func.index()); // the function to call
     push_osm_object_to_lua_stack(
         lua_state(), object,
@@ -1020,6 +1035,8 @@ void output_flex_t::call_lua_function(prepared_lua_function_t func,
             "Failed to execute Lua function 'osm2pgsql.{}':"
             " {}"_format(func.name(), lua_tostring(lua_state(), -1))};
     }
+
+    m_calling_context = calling_context::main;
 }
 
 void output_flex_t::pending_way(osmid_t id)
@@ -1318,10 +1335,12 @@ void output_flex_t::init_lua(std::string const &filename)
     // Check whether the process_* functions are available and store them on
     // the Lua stack for fast access later
     lua_getglobal(lua_state(), "osm2pgsql");
-    m_process_node = prepared_lua_function_t{lua_state(), "process_node"};
-    m_process_way = prepared_lua_function_t{lua_state(), "process_way"};
-    m_process_relation =
-        prepared_lua_function_t{lua_state(), "process_relation"};
+    m_process_node = prepared_lua_function_t{
+        lua_state(), calling_context::process_node, "process_node"};
+    m_process_way = prepared_lua_function_t{
+        lua_state(), calling_context::process_way, "process_way"};
+    m_process_relation = prepared_lua_function_t{
+        lua_state(), calling_context::process_relation, "process_relation"};
 
     lua_remove(lua_state(), 1); // global "osm2pgsql"
 }

src/output-flex.hpp

@@ -28,6 +28,18 @@ extern "C"
 
 using idset_t = osmium::index::IdSetSmall<osmid_t>;
 
+/**
+ * When C++ code is called from the Lua code we sometimes need to know
+ * in what context this happens. These are the possible contexts.
+ */
+enum class calling_context
+{
+    main = 0, ///< In main context, i.e. the Lua script outside any callbacks
+    process_node = 1, ///< In the process_node() callback
+    process_way = 2, ///< In the process_way() callback
+    process_relation = 3 ///< In the process_relation() callback
+};
+
 /**
  * The flex output calls several user-defined Lua functions. They are
  * "prepared" by putting the function pointers on the Lua stack. Objects
@@ -48,8 +60,8 @@ class prepared_lua_function_t
      * \param name Name of the function.
      * \param nresults The number of results this function is supposed to have.
      */
-    prepared_lua_function_t(lua_State *lua_state, const char *name,
-                            int nresults = 0);
+    prepared_lua_function_t(lua_State *lua_state, calling_context context,
+                            const char *name, int nresults = 0);
 
     /// Return the index of the function on the Lua stack.
     int index() const noexcept { return m_index; }
@@ -60,13 +72,16 @@ class prepared_lua_function_t
     /// The number of results this function is expected to have.
     int nresults() const noexcept { return m_nresults; }
 
+    calling_context context() const noexcept { return m_calling_context; }
+
     /// Is this function defined in the users Lua code?
     operator bool() const noexcept { return m_index != 0; }
 
 private:
     char const *m_name = nullptr;
     int m_index = 0;
     int m_nresults = 0;
+    calling_context m_calling_context = calling_context::main;
 };
 
 class output_flex_t : public output_t
@@ -195,10 +210,13 @@ class output_flex_t : public output_t
 
     std::size_t m_num_way_nodes = std::numeric_limits<std::size_t>::max();
 
-    bool m_in_stage2 = false;
     prepared_lua_function_t m_process_node;
     prepared_lua_function_t m_process_way;
     prepared_lua_function_t m_process_relation;
+
+    calling_context m_calling_context = calling_context::main;
+
+    bool m_in_stage2 = false;
 };
 
 #endif // OSM2PGSQL_OUTPUT_FLEX_HPP