Next

examples/0035.process/args_envs.cc

@@ -19,14 +19,14 @@ int main(int argc, char **argv)
 
 	::fast_io::native_process p{
 		::fast_io::mnp::os_c_str(argv[1]),
-		{"char",
-		 L"wchar Double\"quotation\"marks",
-		 u8"u8",
-		 u"u16",
-		 U"u32",
-		 114514,
-		 115145.1919810,
-		 ::fast_io::concat_fast_io("This ", 1, "s ", ::fast_io::mnp::code_cvt_os_c_str(u8"just "), "a parameter")},
+		::fast_io::native_process_args{"char",
+									   L"wchar Double\"quotation\"marks",
+									   u8"u8",
+									   u"u16",
+									   U"u32",
+									   114514,
+									   115145.1919810,
+									   ::fast_io::concat_fast_io("This ", 1, "s ", ::fast_io::mnp::code_cvt_os_c_str(u8"just "), "a parameter")},
 		{"env1",
 		 L"env2",
 		 3,

examples/0035.process/pipe.cc

@@ -20,7 +20,7 @@ int main(int argc, char **argv)
 		::fast_io::iobuf_pipe pipe_err;
 		::fast_io::native_process p{
 			::fast_io::mnp::os_c_str(argv[1]),
-			{},
+			::fast_io::native_process_args{},
 			{},
 			{::fast_io::posix_dev_null(), pipe_out.handle, pipe_err.handle},
 			::fast_io::process_mode::none};

examples/0035.process/process.cc

@@ -11,7 +11,7 @@ int main(int argc, char **argv)
 		::fast_io::io::perr("Usage: ", ::fast_io::mnp::os_c_str(*argv), " <exe>\n");
 		return 1;
 	}
-	::fast_io::native_process p{::fast_io::mnp::os_c_str(argv[1]), {}, {}, {.in = fast_io::in(), .out = fast_io::out(), .err = fast_io::err()}, ::fast_io::process_mode::none};
+	::fast_io::native_process p{::fast_io::mnp::os_c_str(argv[1]), ::fast_io::native_process_args{}, {}, {.in = fast_io::in(), .out = fast_io::out(), .err = fast_io::err()}, ::fast_io::process_mode::none};
 	auto ec{wait(p)};
 	::fast_io::io::perrln(::fast_io::mnp::os_c_str(*argv), " -> Exit code: ", static_cast<int>(ec.wait_loc));
 }

examples/0040.thread/thread.cc

@@ -3,8 +3,7 @@
 
 int main()
 {
-#ifdef _WIN32 // temporaryly disable this example on rest platforms
-	auto t = ::fast_io::thread{[](int param)
+	auto t = ::fast_io::native_thread{[](int param)
 #if __cpp_static_call_operator >= 2020207L
 								   static
 #endif
@@ -16,6 +15,8 @@ int main()
 #else
 								   ::fast_io::println("the child thread id is: ", ::fast_io::mnp::pointervw(::fast_io::this_thread::get_id()));
 #endif
+#else
+								   ::fast_io::println("the child thread id is: ", ::fast_io::this_thread::get_id());
 #endif
 								   //    ::fflush(stdout);
 								   ::fast_io::this_thread::sleep_for(::std::chrono::seconds{1});
@@ -29,8 +30,9 @@ int main()
 #else
 	::fast_io::println("the parent thread id is: ", ::fast_io::mnp::pointervw(::fast_io::this_thread::get_id()));
 #endif
+#else
+	::fast_io::println("the parent thread id is: ", ::fast_io::this_thread::get_id());
 #endif
 
-	return 0;
-#endif
+
 }

include/fast_io_core_impl/buffer_view.h

@@ -181,6 +181,11 @@ struct basic_obuffer_view
 	{
 		return static_cast<::std::size_t>(end_ptr - begin_ptr);
 	}
+
+	inline constexpr bool empty() const noexcept
+	{
+		return begin_ptr == curr_ptr;
+	}
 };
 
 template <::std::integral char_type>

include/fast_io_driver/install_path/argv0.h

@@ -3,6 +3,7 @@
 #include <limits.h>
 #include <stdlib.h>
 #include <cstring>
+#include <unistd.h>
 
 #ifndef PATH_MAX
 #define PATH_MAX 4096
@@ -20,7 +21,7 @@ inline ::fast_io::install_path get_module_install_path_from_argv0(char const *ar
 {
 	if (!argv0) [[unlikely]]
 	{
-		throw_posix_error();
+		throw_posix_error(EINVAL);
 	}
 
 	::fast_io::install_path ret;
@@ -36,10 +37,13 @@ inline ::fast_io::install_path get_module_install_path_from_argv0(char const *ar
 	char path_list_separator[8] = ":"; // could be ":; "
 	if (argv0[0] == path_separator)
 	{
-		[[maybe_unused]] auto const unused1{::fast_io::noexcept_call(realpath, argv0, newpath)};
-		if (auto status{::fast_io::noexcept_call(access, newpath, F_OK)}; !status)
+		char *rp{::fast_io::noexcept_call(::realpath, argv0, newpath)};
+		if (!rp) [[unlikely]]
+		{
+			throw_posix_error();
+		}
+		if (::fast_io::noexcept_call(::access, newpath, F_OK) == 0)
 		{
-			newpath[PATH_MAX - 1] = 0;
 			ret.module_name = ::fast_io::u8concat_fast_io(::fast_io::mnp::code_cvt_os_c_str(newpath));
 			auto const begin{strlike_begin(::fast_io::io_strlike_type<char8_t, ::fast_io::u8string>, ret.module_name)};
 			auto curr{strlike_curr(::fast_io::io_strlike_type<char8_t, ::fast_io::u8string>, ret.module_name)};
@@ -57,18 +61,39 @@ inline ::fast_io::install_path get_module_install_path_from_argv0(char const *ar
 		}
 		else
 		{
-			throw_posix_error(status);
+			throw_posix_error();
 		}
 	}
 	else if (__builtin_strchr(argv0, static_cast<int>(path_separator)))
 	{
-		[[maybe_unused]] auto const unused1{::fast_io::noexcept_call(getcwd, newpath2, PATH_MAX)};
-		::fast_io::noexcept_call(strncat, newpath2, path_separator_as_string, PATH_MAX + 256);
-		::fast_io::noexcept_call(strncat, newpath2, argv0, PATH_MAX + 256);
-		[[maybe_unused]] auto const unused2{::fast_io::noexcept_call(realpath, newpath2, newpath)};
-		if (auto status{::fast_io::noexcept_call(access, newpath, F_OK)};!status)
+		if (!::fast_io::noexcept_call(::getcwd, newpath2, PATH_MAX)) [[unlikely]]
+		{
+			throw_posix_error();
+		}
+		{
+			auto const used1{::std::strlen(newpath2)};
+			if (used1 + 1 >= sizeof(newpath2)) [[unlikely]]
+			{
+				throw_posix_error(ERANGE);
+			}
+			::fast_io::noexcept_call(::strncat, newpath2, path_separator_as_string, sizeof(newpath2) - used1 - 1);
+		}
+		{
+			auto const used2{::std::strlen(newpath2)};
+			auto const add2{::std::strlen(argv0)};
+			if (used2 + add2 >= sizeof(newpath2)) [[unlikely]]
+			{
+				throw_posix_error(ERANGE);
+			}
+			::fast_io::noexcept_call(::strncat, newpath2, argv0, sizeof(newpath2) - used2 - 1);
+		}
+		char *rp2{::fast_io::noexcept_call(::realpath, newpath2, newpath)};
+		if (!rp2) [[unlikely]]
+		{
+			throw_posix_error();
+		}
+		if (::fast_io::noexcept_call(::access, newpath, F_OK) == 0)
 		{
-			newpath[PATH_MAX - 1] = 0;
 			ret.module_name = ::fast_io::u8concat_fast_io(::fast_io::mnp::code_cvt_os_c_str(newpath));
 			auto const begin{strlike_begin(::fast_io::io_strlike_type<char8_t, ::fast_io::u8string>, ret.module_name)};
 			auto curr{strlike_curr(::fast_io::io_strlike_type<char8_t, ::fast_io::u8string>, ret.module_name)};
@@ -84,26 +109,45 @@ inline ::fast_io::install_path get_module_install_path_from_argv0(char const *ar
 			ret.module_name.erase(begin, curr);
 			return ret;
 		}
-		else
-		{
-			throw_posix_error(status);
-		}
+		throw_posix_error();
 	}
 	else
 	{
-		char *saveptr;
-		char *pathitem;
-		char *save_path{::fast_io::noexcept_call(getenv, "PATH")};
-		for (pathitem = ::fast_io::noexcept_call(strtok_r, save_path, path_list_separator, &saveptr); pathitem;
-			 pathitem = ::fast_io::noexcept_call(strtok_r, nullptr, path_list_separator, &saveptr))
+		char *saveptr{};
+		char *pathitem{};
+		char const *env_path{::fast_io::noexcept_call(::getenv, "PATH")};
+		if (!env_path) [[unlikely]]
+		{
+			throw_posix_error(EINVAL);
+		}
+		char pathbuf[PATH_MAX + 256 + 1]{};
+		::fast_io::noexcept_call(::strncpy, pathbuf, env_path, PATH_MAX + 256);
+		pathbuf[PATH_MAX + 256] = 0;
+
+		for (pathitem = ::fast_io::noexcept_call(::strtok_r, pathbuf, path_list_separator, &saveptr); pathitem;
+			 pathitem = ::fast_io::noexcept_call(::strtok_r, nullptr, path_list_separator, &saveptr))
 		{
-			::fast_io::noexcept_call(strncpy, newpath2, pathitem, PATH_MAX + 256);
-			::fast_io::noexcept_call(strncat, newpath2, path_separator_as_string, PATH_MAX + 256);
-			::fast_io::noexcept_call(strncat, newpath2, argv0, PATH_MAX + 256);
-			[[maybe_unused]] auto const unused1{::realpath(newpath2, newpath)};
-			if (!::fast_io::noexcept_call(access, newpath, F_OK))
+			::fast_io::noexcept_call(::strncpy, newpath2, pathitem, PATH_MAX + 256);
+			{
+				auto const used1{::std::strlen(newpath2)};
+				if (used1 + 1 >= sizeof(newpath2)) [[unlikely]]
+				{
+					continue;
+				}
+				::fast_io::noexcept_call(::strncat, newpath2, path_separator_as_string, sizeof(newpath2) - used1 - 1);
+			}
+			{
+				auto const used2{::std::strlen(newpath2)};
+				auto const add2{::std::strlen(argv0)};
+				if (used2 + add2 >= sizeof(newpath2)) [[unlikely]]
+				{
+					continue;
+				}
+				::fast_io::noexcept_call(::strncat, newpath2, argv0, sizeof(newpath2) - used2 - 1);
+			}
+			char *rp{::fast_io::noexcept_call(::realpath, newpath2, newpath)};
+			if (rp && ::fast_io::noexcept_call(::access, newpath, F_OK) == 0)
 			{
-				newpath[PATH_MAX - 1] = 0;
 				ret.module_name = ::fast_io::u8concat_fast_io(::fast_io::mnp::code_cvt_os_c_str(newpath));
 				auto const begin{strlike_begin(::fast_io::io_strlike_type<char8_t, ::fast_io::u8string>, ret.module_name)};
 				auto curr{strlike_curr(::fast_io::io_strlike_type<char8_t, ::fast_io::u8string>, ret.module_name)};
@@ -120,7 +164,7 @@ inline ::fast_io::install_path get_module_install_path_from_argv0(char const *ar
 				return ret;
 			}
 		} // end for
-		throw_posix_error();
+		throw_posix_error(EINVAL);
 
 	} // end else
 }

include/fast_io_driver/install_path/bsd.h

@@ -36,16 +36,16 @@ inline ::fast_io::install_path get_module_install_path()
 #endif
 	::std::size_t size{PATH_MAX};
 
-	if (auto status{::fast_io::noexcept_call(::sysctl, mib, 4, buffer1, __builtin_addressof(size), nullptr, 0)}; !status) [[unlikely]]
+	if (auto status{::fast_io::noexcept_call(::sysctl, mib, 4, buffer1, __builtin_addressof(size), nullptr, 0)}; status == -1) [[unlikely]]
 	{
-		throw_posix_error(status);
+		throw_posix_error();
 	}
 
 	resolved = ::fast_io::noexcept_call(::realpath, buffer1, buffer2);
 
 	if (!resolved) [[unlikely]]
 	{
-		throw_posix_error(resolved);
+		throw_posix_error();
 	}
 
 	::fast_io::install_path ret;

include/fast_io_driver/install_path/darwin.h

@@ -30,7 +30,14 @@ inline ::fast_io::install_path get_module_install_path()
 	::std::uint_least32_t size{PATH_MAX};
 	if (::fast_io::noexcept_call(::_NSGetExecutablePath, buffer, __builtin_addressof(size)) == -1) [[unlikely]]
 	{
-		throw_posix_error();
+		if (size > PATH_MAX) 
+		{
+			throw_posix_error(ERANGE);
+		}
+		else
+		{
+			throw_posix_error(EINVAL);
+		}
 	}
 	char buffer2[PATH_MAX + 1];
 	char *resolved{::fast_io::noexcept_call(::realpath, buffer, buffer2)};

include/fast_io_driver/install_path/linux.h

@@ -19,12 +19,19 @@ namespace fast_io::details
 #endif
 inline ::fast_io::install_path get_module_install_path()
 {
-	char buffer[PATH_MAX + 1];
+	constexpr ::std::size_t path_max{::std::max<::std::size_t>(PATH_MAX, 4096u)};
+
+	char buffer[path_max + 1];
 	::fast_io::install_path ret;
 
+	using my_ssize_t = ::std::make_signed_t<::std::size_t>;
 #if defined(__linux__) && defined(__NR_readlink)
-	auto resolved{::fast_io::system_call<__NR_readlink, int>("/proc/self/exe", buffer, PATH_MAX)};
+	auto resolved{::fast_io::system_call<__NR_readlink, my_ssize_t>("/proc/self/exe", buffer, path_max)};
 	system_call_throw_error(resolved);
+	if (static_cast<::std::size_t>(resolved) >= path_max)
+	{
+		throw_posix_error(ERANGE);
+	}
 	buffer[resolved] = '\0';
 	ret.module_name = ::fast_io::u8concat_fast_io(::fast_io::mnp::code_cvt(::fast_io::mnp::os_c_str_with_known_size(buffer, resolved)));
 #else

include/fast_io_driver/install_path/null.h

@@ -11,6 +11,6 @@ namespace fast_io::details
 [[noreturn]]
 inline void get_module_install_path()
 {
-	throw_posix_error();
+	throw_posix_error(ENOTSUP);
 }
 } // namespace fast_io::details

include/fast_io_driver/install_path/openbsd.h

@@ -43,7 +43,7 @@ inline ::fast_io::install_path get_module_install_path()
 
 	if (size > PATH_MAX) [[unlikely]]
 	{
-		throw_posix_error();
+		throw_posix_error(ERANGE);
 	}
 
 	if (::fast_io::noexcept_call(::sysctl, mib, 4, argv, __builtin_addressof(size), nullptr, 0) != 0) [[unlikely]]

include/fast_io_dsal/impl/string.h

@@ -631,6 +631,14 @@ class basic_string FAST_IO_TRIVIALLY_RELOCATABLE_IF_ELIGIBLE
 	{
 		this->append_impl(other.data(), other.size());
 	}
+	inline constexpr void append(char_type const *begin, char_type const *end) noexcept
+	{
+		this->append_impl(begin, static_cast<::std::size_t>(end - begin));
+	}
+	inline constexpr void append(char_type const *otherptr, size_type othern) noexcept
+	{
+		this->append_impl(otherptr, othern);
+	}
 
 	inline constexpr void clear() noexcept
 	{