Fixed issue where first process is null

lbs.lua

@@ -73,6 +73,10 @@ local function compile(CXX, src_dirs, include_dirs, defines, additional_argument
 	local base_argv = {}
 	
 	additional_arguments[#additional_arguments+1] = "-c"
+	if (config.buildmode == "debug") then
+		additional_arguments[#additional_arguments+1] = "-O0"
+		additional_arguments[#additional_arguments+1] = "-g"
+	end
 	for _,v in pairs(additional_arguments) do base_argv[#base_argv+1] = v end
 	for _,v in pairs(include_dirs) do base_argv[#base_argv+1] = "-I\"" .. v .. "\"" end
 	for k,v in pairs(defines) do base_argv[#base_argv+1] = "-D" .. k .. "=" .. v end
@@ -100,6 +104,10 @@ end
 
 local function link(LNK, obj_dirs, library_dirs, linker_inputs, additional_arguments, file_output)
 	local argv = {}
+	if (config.buildmode == "debug") then
+		additional_arguments[#additional_arguments+1] = "-O0"
+		additional_arguments[#additional_arguments+1] = "-g"
+	end
 	for _,v in pairs(library_dirs) do argv[#argv+1] = "-L\"" .. v .. "\"" end
 	for _,v in pairs(linker_inputs) do argv[#argv+1] = "-l\"" .. v .. "\"" end
 	for _,v in pairs(additional_arguments) do argv[#argv+1] = v end
@@ -137,6 +145,8 @@ function build(...)
 	compile(CXX, source_dirs, include_dirs, defines, additional_arguments)
 
 	link(CXX, {"obj"}, library_dirs, linker_inputs, {}, program_name)
+
+	print("Program generated! See " .. program_name)
 end
 
 function main(...) build(...) end

src/lua_filesystem.cpp

@@ -106,11 +106,14 @@ int lua_fs_list_alldirs(lua_State* L)
 
 int lua_fs_foreach_dir(lua_State* L)
 {
+	try {
 		luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "Expected first argument to be a string representing a path");
 		const char* path = lua_tostring(L, 1);
 
 		void* ud = lua_newuserdata(L, sizeof(std::filesystem::directory_iterator));
 		new (ud) std::filesystem::directory_iterator(path);
+	} catch (const std::exception& e)
+	{ return luaL_error(L, "%s:%d: An exception occured creating fs.foreach iterator/generator\n\t%s\n", __FUNCTION__, __LINE__, e.what()); }
 
 	luaL_getmetatable(L, "fs.stdlibcpp.filesystem.directory_iterator");
 	lua_setmetatable(L, -2);
@@ -123,8 +126,11 @@ int lua_fs_forall_dir(lua_State* L)
 	luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "Expected first argument to be a string representing a path");
 	const char* path = lua_tostring(L, 1);
 
+	try {
 		void* ud = lua_newuserdata(L, sizeof(std::filesystem::recursive_directory_iterator));
 		new (ud) std::filesystem::recursive_directory_iterator(path);
+	} catch (const std::exception& e)
+	{ return luaL_error(L, "%s:%d: An exception occured creating fs.forall iterator/generator\n\t%s\n", __FUNCTION__, __LINE__, e.what()); }
 
 	luaL_getmetatable(L, "fs.stdlibcpp.filesystem.recursive_directory_iterator");
 	lua_setmetatable(L, -2);
@@ -134,6 +140,7 @@ int lua_fs_forall_dir(lua_State* L)
 
 int lua_fs_foreach_dir_next(lua_State* L)
 {
+	try {
 		int idx = lua_upvalueindex(1);
 		luaL_argcheck(L, lua_type(L, idx) == LUA_TUSERDATA, 1, "Expected first argument to fs.foreach_dir_next to be userdata<std::filesystem::directory_iterator>");
 		void* ud = luaL_checkudata(L, idx, "fs.stdlibcpp.filesystem.directory_iterator");
@@ -144,11 +151,14 @@ int lua_fs_foreach_dir_next(lua_State* L)
 		std::string p = (*x).path().string();
 		lua_pushlstring(L, p.c_str(), p.size());
 		x++;
+	} catch (const std::exception& e)
+	{ return luaL_error(L, "%s:%d: An exception occured iterating fs.foreach\n\t%s\n", __FUNCTION__, __LINE__, e.what()); }
 	return 1;
 }
 
 int lua_fs_forall_dir_next(lua_State* L)
 {
+	try {
 		int idx = lua_upvalueindex(1);
 		luaL_argcheck(L, lua_type(L, idx) == LUA_TUSERDATA, 1, "Expected first argument to fs.forall_dir_next to be userdata<std::filesystem::recursive_directory_iterator>");
 		void* ud = luaL_checkudata(L, idx, "fs.stdlibcpp.filesystem.recursive_directory_iterator");
@@ -159,26 +169,34 @@ int lua_fs_forall_dir_next(lua_State* L)
 		std::string p = (*x).path().string();
 		lua_pushlstring(L, p.c_str(), p.size());
 		x++;
+	} catch (const std::exception& e)
+	{ return luaL_error(L, "%s:%d: An exception occured iterating fs.forall\n\t%s\n", __FUNCTION__, __LINE__, e.what()); }
 	return 1;
 }
 
 int lua_fs_foreach_dir_dtor(lua_State* L)
 {
+	try {
 		luaL_argcheck(L, lua_type(L, 1) == LUA_TUSERDATA, 1, "Expected first argument to fs.foreach_dir_next to be userdata<std::filesystem::directory_iterator>");
 		void* ud = luaL_checkudata(L, 1, "fs.stdlibcpp.filesystem.directory_iterator");
 		luaL_argcheck(L, ud != nullptr, 1, "Expected first argument's userdata type to be a std::filesystem::directory_iterator");
 		std::filesystem::directory_iterator& x = *(std::filesystem::directory_iterator*)ud;
 		x.~directory_iterator();
+	} catch (const std::exception& e)
+	{ return luaL_error(L, "%s:%d: An exception occured destroying fs.foreach iterator/generator\n\t%s\n", __FUNCTION__, __LINE__, e.what()); }
 	return 0;
 }
 
 int lua_fs_forall_dir_dtor(lua_State* L)
 {
+	try {
 		luaL_argcheck(L, lua_type(L, 1) == LUA_TUSERDATA, 1, "Expected first argument to fs.forall_dir_next to be userdata<std::filesystem::recursive_directory_iterator>");
 		void* ud = luaL_checkudata(L, 1, "fs.stdlibcpp.filesystem.recursive_directory_iterator");
 		luaL_argcheck(L, ud != nullptr, 1, "Expected first argument's userdata type to be a std::filesystem::recursive_directory_iterator");
 		std::filesystem::recursive_directory_iterator& x = *(std::filesystem::recursive_directory_iterator*)ud;
 		x.~recursive_directory_iterator();
+	} catch (const std::exception& e)
+	{ return luaL_error(L, "%s:%d: An exception occured destroying fs.forall iterator/generator\n\t%s\n", __FUNCTION__, __LINE__, e.what()); }
 	return 0;
 }
 

src/lua_platform.cpp

@@ -65,6 +65,7 @@ int lua_platform_exec(lua_State* L)
 
 int lua_platform_exec_parallel(lua_State* L)
 {
+    try {
         luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "Expected first argument to be a string representing a command");
         luaL_argcheck(L, lua_type(L, 2) == LUA_TNUMBER, 2, "Expected second argument to be an integer representing the maximum number of parallel jobs to start");
         luaL_argcheck(L, lua_type(L, 3) == LUA_TTABLE, 3, "Expected third argument to be a table of table of strings representing the arguments");
@@ -72,9 +73,17 @@ int lua_platform_exec_parallel(lua_State* L)
         const size_t max_parallel = lua_tointeger(L, 2);
         const size_t num_cmds = lua_objlen(L, 3);
 
-    size_t* num_args = (size_t*)malloc(num_cmds * sizeof(size_t));
+        uniproc_process* workers = nullptr;
+        int* retcodes = nullptr;
+        size_t* num_args = nullptr;
+        const char*** args = nullptr;
+        std::vector<std::string> std_outs;
+        std::vector<std::string> std_errs;
+
+        try {
+            num_args = (size_t*)malloc(num_cmds * sizeof(size_t));
             memset(num_args, 0, sizeof(size_t) * num_cmds);
-    const char*** args = (const char***)malloc(num_cmds*sizeof(const char**));
+            args = (const char***)malloc(num_cmds * sizeof(const char**));
 
             // Generate the command stack from lua arguments
             for (size_t i = 0; i < num_cmds; ++i)
@@ -105,31 +114,40 @@ int lua_platform_exec_parallel(lua_State* L)
                 lua_pop(L, 1);
             }
 
-    uniproc_process* workers = (uniproc_process*)malloc(max_parallel*sizeof(uniproc_process));
+            workers = (uniproc_process*)malloc(max_parallel * sizeof(uniproc_process));
             uniproc_nullify_processes(workers, max_parallel);
-    int* retcodes = (int*)malloc(num_cmds*sizeof(int));
+            retcodes = (int*)malloc(num_cmds * sizeof(int));
             memset(retcodes, 0, num_cmds);
 
-    std::vector<std::string> std_outs;
-    std::vector<std::string> std_errs;
             std_outs.resize(num_cmds, "");
             std_errs.resize(num_cmds, "");
 
+        }
+        catch (const std::exception& e) {
+            fprintf(stderr, "%s:%d: Exception occured in preparation for fs.parallel_exec(...)\n\t%s\n", __FUNCTION__, __LINE__, e.what());
+            return luaL_error(L, "%s:%d: Exception occured in preparation for fs.parallel_exec(...)\n\t%s\n", __FUNCTION__, __LINE__, e.what());
+        }
 
         size_t cmd_idx = 0;
         while (cmd_idx < num_cmds || !uniproc_are_processes_finished(workers, max_parallel))
         {
+            try {
                 for (uniproc_process* p = workers; p != (workers + max_parallel); ++p)
                 {
                     // Check and handle a worker if it has completed
-            if (uniproc_are_processes_finished(p, 1))
+                    if (!uniproc_is_process_null(p) && uniproc_are_processes_finished(p, 1))
                     {
                         char buf[64];
                         // Read the std. streams into the output vectors
+                        // TODO: Errors out here
+                        fprintf(stderr, "p->out = %p\n", p->out);
                         while (fgets(buf, sizeof(buf), p->out) != NULL)
                             std_outs[p->userdata].append(buf);
+                        fprintf(stderr, "C: %llu\n", cmd_idx);
+                        fprintf(stderr, "p->err = %p\n", p->err);
                         while (fgets(buf, sizeof(buf), p->err) != NULL)
                             std_errs[p->userdata].append(buf);
+                        fprintf(stderr, "D: %llu\n", cmd_idx);
                         // Add the process return code to retcode array
                         uniproc_await_processes(p, retcodes + p->userdata, 1);
                         // Close the process and zero it
@@ -158,6 +176,11 @@ int lua_platform_exec_parallel(lua_State* L)
                 //  Prevents spinning the CPU
                 uniproc_await_any_processes(workers, max_parallel);
             }
+            catch (const std::exception& e) {
+                fprintf(stderr, "%s:%d: Exception occured in parallel execution for fs.parallel_exec(...)\n\t%s\n", __FUNCTION__, __LINE__, e.what());
+                return luaL_error(L, "%s:%d: Exception occured in parallel execution for fs.parallel_exec(...)\n\t%s\n", __FUNCTION__, __LINE__, e.what());
+            }
+        }
 
         for (size_t i = 0; i < num_cmds; ++i)
             free(args[i]);
@@ -184,3 +207,9 @@ int lua_platform_exec_parallel(lua_State* L)
 
         return 3;
     }
+    catch (const std::exception& e)
+    {
+        fprintf(stderr, "%s:%d: Exception occured in cleanup and result handling for fs.parallel_exec(...)\n\t%s\n", __FUNCTION__, __LINE__, e.what());
+        return luaL_error(L, "%s:%d: Exception occured in cleanup and result handling for fs.parallel_exec(...)\n\t%s\n", __FUNCTION__, __LINE__, e.what());
+    }
+}