diff options
39 files changed, 1668 insertions, 1089 deletions
diff --git a/nihil.config/CMakeLists.txt b/nihil.config/CMakeLists.txt index ed2bba3..6b1073d 100644 --- a/nihil.config/CMakeLists.txt +++ b/nihil.config/CMakeLists.txt @@ -2,9 +2,8 @@ add_library(nihil.config STATIC) target_link_libraries(nihil.config PUBLIC nihil nihil.ucl) -target_sources(nihil.config PUBLIC - FILE_SET modules TYPE CXX_MODULES FILES - +target_sources(nihil.config + PUBLIC FILE_SET modules TYPE CXX_MODULES FILES nihil.config.ccm error.ccm read.ccm @@ -13,6 +12,11 @@ target_sources(nihil.config PUBLIC option.ccm string.ccm + + PRIVATE + option.cc + store.cc + string.cc ) if(NIHIL_TESTS) diff --git a/nihil.config/option.cc b/nihil.config/option.cc new file mode 100644 index 0000000..9bf77c9 --- /dev/null +++ b/nihil.config/option.cc @@ -0,0 +1,67 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <iostream> +#include <string> + +module nihil.config; + +namespace nihil::config { + +auto option::name(this option const &self) noexcept +-> std::string_view +{ + return self._name; +} + +// Human-readable description of this option. +auto option::description(this option const &self) noexcept +-> std::string_view +{ + return self._description; +} + +// If true, this option is set to its default value. +auto option::is_default(this option const &self) noexcept +-> bool +{ + return self._is_default; +} + +// Get or set this option as a string. +auto option::string(this option const &self) +-> std::string +{ + return self.get_string(); +} + +auto option::string(this option &self, std::string_view value) +-> void +{ + self.set_string(value); + self._is_default = false; +} + +option::option(std::string_view name, + std::string_view description) + : _name(name) + , _description(description) +{ +} + +auto option::is_default(bool b) +-> void +{ + _is_default = b; +} + +auto operator<<(std::ostream &strm, option const &opt) +-> std::ostream & +{ + return strm << "<" << opt.name() << "=" << opt.string() << ">"; +} + +} // namespace nihil diff --git a/nihil.config/option.ccm b/nihil.config/option.ccm index 1be542e..c6a8329 100644 --- a/nihil.config/option.ccm +++ b/nihil.config/option.ccm @@ -4,11 +4,9 @@ module; -#include <iostream> +#include <iosfwd> #include <string> -#include <ucl++.h> - export module nihil.config:option; import nihil.ucl; @@ -23,34 +21,17 @@ namespace nihil::config { export struct option { // Short name of this option. - auto name(this option const &self) noexcept -> std::string_view - { - return self._name; - } + auto name(this option const &self) noexcept -> std::string_view; // Human-readable description of this option. - auto description(this option const &self) noexcept -> std::string_view - { - return self._description; - } + auto description(this option const &self) noexcept -> std::string_view; // If true, this option is set to its default value. - auto is_default(this option const &self) noexcept -> bool - { - return self._is_default; - } + auto is_default(this option const &self) noexcept -> bool; // Get or set this option as a string. - auto string(this option const &self) -> std::string - { - return self.get_string(); - } - - void string(this option &self, std::string_view value) - { - self.set_string(value); - self._is_default = false; - } + auto string(this option const &self) -> std::string; + auto string(this option &self, std::string_view value) -> void; /* * Return this object as a UCL object. This is used when writing the @@ -69,17 +50,9 @@ export struct option auto operator=(option const &) -> option& = delete; protected: - option(std::string_view name, - std::string_view description) - : _name(name) - , _description(description) - { - } - - auto is_default(bool b) -> void - { - _is_default = b; - } + option(std::string_view name, std::string_view description); + + auto is_default(bool b) -> void; /* * Get or set this option as a string. @@ -96,9 +69,6 @@ private: /* * Make options printable. This is mostly useful for testing. */ -export auto operator<<(std::ostream &strm, option const &opt) -> std::ostream & -{ - return strm << "<" << opt.name() << "=" << opt.string() << ">"; -} +export auto operator<<(std::ostream &strm, option const &opt) -> std::ostream &; } // namespace nihil diff --git a/nihil.config/store.cc b/nihil.config/store.cc new file mode 100644 index 0000000..2ec8ade --- /dev/null +++ b/nihil.config/store.cc @@ -0,0 +1,89 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <coroutine> +#include <filesystem> +#include <format> +#include <map> + +module nihil.config; + +import nihil; + +namespace nihil::config { + +unknown_option::unknown_option(std::string_view option_name) + : error(std::format("unknown configuration variable '{}'", + option_name)) + , _option_name(option_name) +{ +} + +auto unknown_option::option_name(this unknown_option const &self) +-> std::string_view +{ + return self._option_name; +} + +auto store::get() +-> store& +{ + if (instance == nullptr) + instance = new store; + + return *instance; +} + + +auto store::register_option(this store &self, option *object) +-> void +{ + auto [it, okay] = self.options.insert( + std::pair{object->name(), object}); + + if (!okay) + throw error(std::format( + "INTERNAL ERROR: attempt to register " + "duplicate config value '{0}'", + object->name())); +} + +auto store::unregister_option(this store &self, option *object) +-> void +{ + auto it = self.options.find(object->name()); + if (it == self.options.end()) + throw error(std::format( + "INTERNAL ERROR: attempt to unregister " + "non-existent config value '{}'", + object->name())); + + self.options.erase(it); +} + +auto store::fetch(this store const &self, std::string_view name) +-> option & +{ + if (auto it = self.options.find(name); it != self.options.end()) + return *it->second; + + throw unknown_option(name); +} + +auto store::all(this store const &self) +-> nihil::generator<option const &> +{ + for (auto &&it : self.options) + co_yield *it.second; +} + +auto get_option(std::string_view option_name) +-> option & +{ + return store::get().fetch(option_name); +} + +} // namespace nihil::config diff --git a/nihil.config/store.ccm b/nihil.config/store.ccm index e0eebc0..77b44b5 100644 --- a/nihil.config/store.ccm +++ b/nihil.config/store.ccm @@ -9,12 +9,12 @@ module; */ #include <coroutine> -#include <filesystem> -#include <format> +#include <string> #include <map> export module nihil.config:store; +import nihil; import :error; import :option; @@ -22,16 +22,8 @@ namespace nihil::config { // Exception thrown on an attempt to fetch an undefined option. export struct unknown_option final : error { - unknown_option(std::string_view option_name) - : error(std::format("unknown configuration variable '{}'", - option_name)) - , _option_name(option_name) - {} - - auto option_name(this unknown_option const &self) -> std::string_view - { - return self._option_name; - } + unknown_option(std::string_view option_name); + auto option_name(this unknown_option const &self) -> std::string_view; private: std::string _option_name; @@ -41,64 +33,27 @@ struct store final { /* * Get the global config store. */ - static auto get() -> store& { - if (instance == nullptr) - instance = new store; - - return *instance; - } - + static auto get() -> store &; /* * Register a new value with the config store. */ - auto register_option(this store &self, option *object) -> void - { - auto [it, okay] = self.options.insert( - std::pair{object->name(), object}); - - if (!okay) - throw error(std::format( - "INTERNAL ERROR: attempt to register " - "duplicate config value '{0}'", - object->name())); - } + auto register_option(this store &self, option *object) -> void; /* * Remove a value from the config store. */ - auto unregister_option(this store &self, option *object) -> void - { - auto it = self.options.find(object->name()); - if (it == self.options.end()) - throw error(std::format( - "INTERNAL ERROR: attempt to unregister " - "non-existent config value '{}'", - object->name())); - - self.options.erase(it); - } + auto unregister_option(this store &self, option *object) -> void; /* * Fetch an existing value in the config store. */ - auto fetch(this store const &self, std::string_view name) - -> option & - { - if (auto it = self.options.find(name); it != self.options.end()) - return *it->second; - - throw unknown_option(name); - } + auto fetch(this store const &self, std::string_view name) -> option &; /* * Fetch all values in the configuration store. */ - auto all(this auto &&self) -> nihil::generator<option const &> - { - for (auto &&it : self.options) - co_yield *it.second; - } + auto all(this store const &self) -> nihil::generator<option const &>; // Not movable or copyable. store(store const &) = delete; @@ -120,9 +75,6 @@ private: /* * The public API. */ -export auto get_option(std::string_view option_name) -> option & -{ - return store::get().fetch(option_name); -} +export auto get_option(std::string_view option_name) -> option &; } // namespace nihil::config diff --git a/nihil.config/string.cc b/nihil.config/string.cc new file mode 100644 index 0000000..6b201ae --- /dev/null +++ b/nihil.config/string.cc @@ -0,0 +1,57 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <format> +#include <string> + +module nihil.config; + +import nihil.ucl; + +namespace nihil::config { + +string::string( + std::string &storage, + std::string_view name, + std::string_view description) noexcept + : option(name, description) + , _storage(storage) +{ + store::get().register_option(this); +} + +string::~string() +{ + store::get().unregister_option(this); +} + +auto string::get_string() const -> std::string +{ + return _storage; +} + +auto string::set_string(std::string_view new_value) -> void +{ + _storage = new_value; +} + +auto string::to_ucl() const -> ucl::object +{ + return ucl::string(_storage); +} + +auto string::from_ucl(ucl::object const &uclobj) -> void +{ + try { + _storage = object_cast<ucl::string>(uclobj).value(); + is_default(false); + } catch (ucl::type_mismatch const &exc) { + throw error(std::format("'{}': expected string, not {}", + name(), str(exc.actual_type()))); + } +} + +} // namespace nihil::config diff --git a/nihil.config/string.ccm b/nihil.config/string.ccm index 57770ae..ae5efb9 100644 --- a/nihil.config/string.ccm +++ b/nihil.config/string.ccm @@ -9,10 +9,8 @@ module; export module nihil.config:string; -import nihil; import nihil.ucl; import :option; -import :store; namespace nihil::config { @@ -20,43 +18,15 @@ export struct string final : option { string(std::string &storage, std::string_view name, - std::string_view description) noexcept - : option(name, description) - , _storage(storage) - { - store::get().register_option(this); - } + std::string_view description) noexcept; - ~string() - { - store::get().unregister_option(this); - } + ~string(); - auto get_string() const -> std::string override - { - return _storage; - }; + auto get_string() const -> std::string override; + auto set_string(std::string_view new_value) -> void override; - auto set_string(std::string_view new_value) -> void override - { - _storage = new_value; - } - - auto to_ucl() const -> ucl::object override - { - return ucl::string(_storage); - } - - auto from_ucl(ucl::object const &uclobj) -> void override - { - try { - _storage = object_cast<ucl::string>(uclobj).value(); - is_default(false); - } catch (ucl::type_mismatch const &exc) { - throw error(std::format("'{}': expected string, not {}", - name(), str(exc.actual_type()))); - } - } + auto to_ucl() const -> ucl::object override; + auto from_ucl(ucl::object const &uclobj) -> void override; private: std::string &_storage; diff --git a/nihil.ucl/CMakeLists.txt b/nihil.ucl/CMakeLists.txt index cb051a3..0ee024c 100644 --- a/nihil.ucl/CMakeLists.txt +++ b/nihil.ucl/CMakeLists.txt @@ -4,8 +4,9 @@ pkg_check_modules(LIBUCL REQUIRED libucl) add_library(nihil.ucl STATIC) target_link_libraries(nihil.ucl PUBLIC nihil) -target_sources(nihil.ucl PUBLIC - FILE_SET modules TYPE CXX_MODULES FILES + +target_sources(nihil.ucl + PUBLIC FILE_SET modules TYPE CXX_MODULES FILES nihil.ucl.ccm emit.ccm error.ccm @@ -20,6 +21,18 @@ target_sources(nihil.ucl PUBLIC map.ccm real.ccm string.ccm + + PRIVATE + emit.cc + error.cc + parser.cc + type.cc + + object.cc + boolean.cc + integer.cc + real.cc + string.cc ) target_compile_options(nihil.ucl PUBLIC ${LIBUCL_CFLAGS_OTHER}) diff --git a/nihil.ucl/boolean.cc b/nihil.ucl/boolean.cc new file mode 100644 index 0000000..95b4e2f --- /dev/null +++ b/nihil.ucl/boolean.cc @@ -0,0 +1,77 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <compare> +#include <cstdlib> + +#include <ucl.h> + +module nihil.ucl; + +namespace nihil::ucl { + +boolean::boolean() : boolean(false) +{ +} + +boolean::boolean(ref_t, ::ucl_object_t const *uobj) + : object(nihil::ucl::ref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +boolean::boolean(noref_t, ::ucl_object_t *uobj) + : object(noref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +boolean::boolean(contained_type value) + : object(noref, ::ucl_object_frombool(value)) +{ + if (_object == nullptr) + throw error("failed to create UCL object"); +} + +auto boolean::value(this boolean const &self) +-> contained_type +{ + auto v = contained_type{}; + auto const *uobj = self.get_ucl_object(); + + if (::ucl_object_toboolean_safe(uobj, &v)) + return v; + + std::abort(); +} + +auto operator== (boolean const &a, boolean const &b) +-> bool +{ + return a.value() == b.value(); +} + +auto operator<=> (boolean const &a, boolean const &b) +-> std::strong_ordering +{ + return a.value() <=> b.value(); +} + +auto operator== (boolean const &a, boolean::contained_type b) +-> bool +{ + return a.value() == b; +} + +auto operator<=> (boolean const &a, boolean::contained_type b) +-> std::strong_ordering +{ + return a.value() <=> b; +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/boolean.ccm b/nihil.ucl/boolean.ccm index 6a93867..78ede17 100644 --- a/nihil.ucl/boolean.ccm +++ b/nihil.ucl/boolean.ccm @@ -23,70 +23,28 @@ export struct boolean final : object { inline static constexpr object_type ucl_type = object_type::boolean; // Create a new boolean from a UCL object. - boolean(ref_t, ::ucl_object_t const *uobj) - : object(nihil::ucl::ref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } - - boolean(noref_t, ::ucl_object_t *uobj) - : object(noref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } + boolean(ref_t, ::ucl_object_t const *uobj); + boolean(noref_t, ::ucl_object_t *uobj); // Create a new default-initialised boolean. - boolean() : boolean(false) {} + boolean(); // Create a new boolean from a value. - explicit boolean(contained_type value) - : object(noref, ::ucl_object_frombool(value)) - { - if (_object == nullptr) - throw error("failed to create UCL object"); - } + explicit boolean(contained_type value); // Return this object's value. - auto value(this boolean const &self) -> contained_type - { - auto v = contained_type{}; - auto const *uobj = self.get_ucl_object(); - - if (::ucl_object_toboolean_safe(uobj, &v)) - return v; - - std::abort(); - } + auto value(this boolean const &self) -> contained_type; }; /* * Comparison operators. */ -export auto operator== (boolean const &a, boolean const &b) - -> bool -{ - return a.value() == b.value(); -} - +export auto operator== (boolean const &a, boolean const &b) -> bool; +export auto operator== (boolean const &a, boolean::contained_type b) -> bool; export auto operator<=> (boolean const &a, boolean const &b) - -> std::strong_ordering -{ - return a.value() <=> b.value(); -} - -export auto operator== (boolean const &a, boolean::contained_type b) - -> bool -{ - return a.value() == b; -} - + -> std::strong_ordering; export auto operator<=> (boolean const &a, boolean::contained_type b) - -> std::strong_ordering -{ - return a.value() <=> b; -} + -> std::strong_ordering; } // namespace nihil::ucl diff --git a/nihil.ucl/emit.cc b/nihil.ucl/emit.cc new file mode 100644 index 0000000..480ddd8 --- /dev/null +++ b/nihil.ucl/emit.cc @@ -0,0 +1,21 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <iostream> +#include <iterator> + +module nihil.ucl; + +namespace nihil::ucl { + +auto operator<<(std::ostream &stream, object const &o) +-> std::ostream & +{ + emit(o, emitter::json, std::ostream_iterator<char>(stream)); + return stream; +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/emit.ccm b/nihil.ucl/emit.ccm index c4aa79b..849c5a7 100644 --- a/nihil.ucl/emit.ccm +++ b/nihil.ucl/emit.ccm @@ -9,7 +9,7 @@ module; #include <cstdlib> #include <format> #include <iterator> -#include <iostream> +#include <iosfwd> #include <span> #include <string> #include <utility> @@ -34,8 +34,8 @@ export enum struct emitter { * * We can't throw exceptions here since we're called from C code. The emit * functions return an integer value, but it's not really clear what this is - * for (for example, returning errors?) and the C API seems to mostly ignore - * it. So, we just eat errors and keep going. + * for and the C API seems to mostly ignore it. So, we just eat errors and + * keep going. */ template<std::output_iterator<char> Iterator> struct emit_wrapper { @@ -130,7 +130,7 @@ private: export auto emit(object const &object, emitter format, std::output_iterator<char> auto &&it) - -> void +-> void { auto ucl_format = static_cast<ucl_emitter>(format); auto wrapper = emit_wrapper(it); @@ -144,12 +144,7 @@ export auto emit(object const &object, emitter format, * Basic ostream printer for UCL; default to JSON since it's probably what * most people expect. */ -export auto operator<<(std::ostream &stream, object const &o) - -> std::ostream & -{ - emit(o, emitter::json, std::ostream_iterator<char>(stream)); - return stream; -} +export auto operator<<(std::ostream &stream, object const &o) -> std::ostream &; } // namespace nihil::ucl diff --git a/nihil.ucl/error.cc b/nihil.ucl/error.cc new file mode 100644 index 0000000..2f19cb7 --- /dev/null +++ b/nihil.ucl/error.cc @@ -0,0 +1,19 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <string> +#include <utility> + +module nihil.ucl; + +namespace nihil::ucl { + +error::error(std::string what) + : generic_error(std::move(what)) +{ +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/error.ccm b/nihil.ucl/error.ccm index c6a0f2d..cdb5c2b 100644 --- a/nihil.ucl/error.ccm +++ b/nihil.ucl/error.ccm @@ -4,8 +4,7 @@ module; -#include <format> -#include <utility> +#include <string> export module nihil.ucl:error; @@ -17,7 +16,7 @@ namespace nihil::ucl { * Exception thrown when an issue occurs with UCL. */ export struct error : generic_error { - error(std::string what) : generic_error(std::move(what)) {} + error(std::string what); }; } // namespace nihil::ucl diff --git a/nihil.ucl/integer.cc b/nihil.ucl/integer.cc new file mode 100644 index 0000000..16328d4 --- /dev/null +++ b/nihil.ucl/integer.cc @@ -0,0 +1,76 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <compare> +#include <cstdlib> + +#include <ucl.h> + +module nihil.ucl; + +namespace nihil::ucl { + +integer::integer(ref_t, ::ucl_object_t const *uobj) + : object(nihil::ucl::ref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +integer::integer(noref_t, ::ucl_object_t *uobj) + : object(noref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +integer::integer() + : integer(0) +{} + +integer::integer(contained_type value) + : object(noref, ::ucl_object_fromint(value)) +{ + if (_object == nullptr) + throw error("failed to create UCL object"); +} + +auto integer::value(this integer const &self) -> contained_type +{ + auto v = contained_type{}; + auto const *uobj = self.get_ucl_object(); + + if (::ucl_object_toint_safe(uobj, &v)) + return v; + + std::abort(); +} + +auto operator== (integer const &a, integer const &b) +-> bool +{ + return a.value() == b.value(); +} + +auto operator<=> (integer const &a, integer const &b) +-> std::strong_ordering +{ + return a.value() <=> b.value(); +} + +auto operator== (integer const &a, integer::contained_type b) +-> bool +{ + return a.value() == b; +} + +auto operator<=> (integer const &a, integer::contained_type b) +-> std::strong_ordering +{ + return a.value() <=> b; +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/integer.ccm b/nihil.ucl/integer.ccm index 482a716..e43ae8b 100644 --- a/nihil.ucl/integer.ccm +++ b/nihil.ucl/integer.ccm @@ -4,10 +4,9 @@ module; -#include <cassert> +#include <compare> #include <cstdint> #include <cstdlib> -#include <string> #include <ucl.h> @@ -22,72 +21,28 @@ export struct integer final : object { inline static constexpr object_type ucl_type = object_type::integer; // Create a new integer from a UCL object. - integer(ref_t, ::ucl_object_t const *uobj) - : object(nihil::ucl::ref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } - - integer(noref_t, ::ucl_object_t *uobj) - : object(noref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } + integer(ref_t, ::ucl_object_t const *uobj); + integer(noref_t, ::ucl_object_t *uobj); // Create a new default-initialised integer. - integer() - : integer(0) - {} + integer(); // Create a new integer from a value. - explicit integer(contained_type value) - : object(noref, ::ucl_object_fromint(value)) - { - if (_object == nullptr) - throw error("failed to create UCL object"); - } + explicit integer(contained_type value); // Return the value of this object. - auto value(this integer const &self) -> contained_type - { - auto v = contained_type{}; - auto const *uobj = self.get_ucl_object(); - - if (::ucl_object_toint_safe(uobj, &v)) - return v; - - std::abort(); - } + auto value(this integer const &self) -> contained_type; }; /* * Comparison operators. */ -export auto operator== (integer const &a, integer const &b) - -> bool -{ - return a.value() == b.value(); -} - +export auto operator== (integer const &a, integer const &b) -> bool; +export auto operator== (integer const &a, integer::contained_type b) -> bool; export auto operator<=> (integer const &a, integer const &b) - -> std::strong_ordering -{ - return a.value() <=> b.value(); -} - -export auto operator== (integer const &a, integer::contained_type b) - -> bool -{ - return a.value() == b; -} - + -> std::strong_ordering; export auto operator<=> (integer const &a, integer::contained_type b) - -> std::strong_ordering -{ - return a.value() <=> b; -} + -> std::strong_ordering; } // namespace nihil::ucl diff --git a/nihil.ucl/object.cc b/nihil.ucl/object.cc new file mode 100644 index 0000000..f435b90 --- /dev/null +++ b/nihil.ucl/object.cc @@ -0,0 +1,123 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <cstdlib> +#include <string> +#include <utility> + +#include <ucl.h> + +module nihil.ucl; + +namespace nihil::ucl { + +object::object(ref_t, ::ucl_object_t const *object) + : _object(::ucl_object_ref(object)) +{ +} + +object::object(noref_t, ::ucl_object_t *object) + : _object(object) +{ +} + +object::~object() { + if (_object != nullptr) + ::ucl_object_unref(_object); +} + +object::object(object &&other) noexcept + : _object(std::exchange(other._object, nullptr)) +{} + +object::object(object const &other) noexcept + : _object(nullptr) +{ + *this = other; +} + +auto object::operator=(this object &self, object &&other) noexcept + -> object & +{ + if (&self != &other) + self._object = std::exchange(other._object, nullptr); + return self; +} + +auto object::operator=(this object &self, object const &other) + -> object & +{ + if (&self != &other) { + auto *new_uobj = ::ucl_object_copy(other.get_ucl_object()); + if (new_uobj == nullptr) + throw error("failed to copy UCL object"); + + if (self._object != nullptr) + ::ucl_object_unref(self._object); + self._object = new_uobj; + } + + return self; +} + +auto object::ref(this object const &self) -> object +{ + return object(nihil::ucl::ref, self.get_ucl_object()); +} + +auto object::type(this object const &self) -> object_type +{ + auto utype = ::ucl_object_type(self.get_ucl_object()); + return static_cast<object_type>(utype); +} + +auto object::get_ucl_object(this object &self) -> ::ucl_object_t * +{ + if (self._object == nullptr) + throw error("attempt to access empty UCL object"); + return self._object; +} + +auto object::get_ucl_object(this object const &self) -> ::ucl_object_t const * +{ + if (self._object == nullptr) + throw error("attempt to access empty UCL object"); + return self._object; +} + +// Return the key of this object. +auto object::key(this object const &self) -> std::string_view +{ + auto dlen = std::size_t{}; + auto const *dptr = ::ucl_object_keyl(self.get_ucl_object(), + &dlen); + return {dptr, dlen}; +} + +auto swap(object &a, object &b) -> void +{ + std::swap(a._object, b._object); +} + +auto operator<=>(object const &lhs, object const &rhs) -> std::strong_ordering +{ + auto cmp = ::ucl_object_compare(lhs.get_ucl_object(), + rhs.get_ucl_object()); + + if (cmp < 0) + return std::strong_ordering::less; + else if (cmp > 0) + return std::strong_ordering::greater; + else + return std::strong_ordering::equal; +} + +auto operator==(object const &lhs, object const &rhs) -> bool +{ + return (lhs <=> rhs) == std::strong_ordering::equal; +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/object.ccm b/nihil.ucl/object.ccm index b220335..5becfa8 100644 --- a/nihil.ucl/object.ccm +++ b/nihil.ucl/object.ccm @@ -10,12 +10,9 @@ module; * */ -#include <algorithm> -#include <cassert> +#include <compare> #include <cstddef> -#include <format> #include <string> -#include <utility> #include <ucl.h> @@ -44,103 +41,40 @@ export struct object { // Create an object from an existing ucl_object_t. The first argument // determines whether we ref the object or not. - object(ref_t, ::ucl_object_t const *object) - : _object(::ucl_object_ref(object)) - { - } - - object(noref_t, ::ucl_object_t *object) - : _object(object) - { - } + object(ref_t, ::ucl_object_t const *object); + object(noref_t, ::ucl_object_t *object); // Free our object on destruction. - virtual ~object() { - if (_object != nullptr) - ::ucl_object_unref(_object); - } + virtual ~object(); // Movable. - object(object &&other) noexcept - : _object(std::exchange(other._object, nullptr)) - {} - - auto operator=(this object &self, object &&other) noexcept - -> object & - { - if (&self != &other) - self._object = std::exchange(other._object, nullptr); - return self; - } + object(object &&other) noexcept; + auto operator=(this object &self, object &&other) noexcept -> object&; // Copyable. - object(object const &other) noexcept - : _object(nullptr) - { - *this = other; - } - - auto operator=(this object &self, object const &other) - -> object & - { - if (&self != &other) { - auto *new_uobj = ::ucl_object_copy(other.get_ucl_object()); - if (new_uobj == nullptr) - throw error("failed to copy UCL object"); - - if (self._object != nullptr) - ::ucl_object_unref(self._object); - self._object = new_uobj; - } - - return self; - } + // Note that this copies the entire UCL object. + object(object const &other) noexcept; + auto operator=(this object &self, object const &other) -> object &; // Increase the refcount of this object. - auto ref(this object const &self) -> object - { - return object(nihil::ucl::ref, self.get_ucl_object()); - } + auto ref(this object const &self) -> object; // Return the type of this object. - auto type(this object const &self) -> object_type - { - auto utype = ::ucl_object_type(self.get_ucl_object()); - return static_cast<object_type>(utype); - } + auto type(this object const &self) -> object_type; // Return the underlying object. - auto get_ucl_object(this object &self) -> ::ucl_object_t * - { - if (self._object == nullptr) - throw error("attempt to access empty UCL object"); - return self._object; - } - - auto get_ucl_object(this object const &self) -> ::ucl_object_t const * - { - if (self._object == nullptr) - throw error("attempt to access empty UCL object"); - return self._object; - } + auto get_ucl_object(this object &self) -> ::ucl_object_t *; + + auto get_ucl_object(this object const &self) -> ::ucl_object_t const *; // Return the key of this object. - auto key(this object const &self) -> std::string_view - { - auto dlen = std::size_t{}; - auto const *dptr = ::ucl_object_keyl(self.get_ucl_object(), - &dlen); - return {dptr, dlen}; - } + auto key(this object const &self) -> std::string_view; protected: // The object we're wrapping. ::ucl_object_t *_object = nullptr; - friend auto swap(object &a, object &b) -> void - { - std::swap(a._object, b._object); - } + friend auto swap(object &a, object &b) -> void; private: @@ -152,104 +86,8 @@ private: * Object comparison. */ +export auto operator==(object const &lhs, object const &rhs) -> bool; export auto operator<=>(object const &lhs, object const &rhs) - -> std::strong_ordering -{ - auto cmp = ::ucl_object_compare(lhs.get_ucl_object(), - rhs.get_ucl_object()); - - if (cmp < 0) - return std::strong_ordering::less; - else if (cmp > 0) - return std::strong_ordering::greater; - else - return std::strong_ordering::equal; -} - -export auto operator==(object const &lhs, object const &rhs) -> bool -{ - return (lhs <=> rhs) == std::strong_ordering::equal; -} - -/*********************************************************************** - * Object iteration. - */ - -export struct iterator { - using difference_type = std::ptrdiff_t; - using value_type = object; - using reference = value_type &; - using const_reference = value_type const &; - using pointer = value_type *; - using const_pointer = value_type const *; - - struct sentinel{}; - - explicit iterator(object const &obj) - { - _state = std::make_shared<state>(obj); - ++(*this); - } - - auto operator==(this iterator const &self, sentinel) -> bool - { - return (self._state->cur == nullptr); - } - - auto operator++(this iterator &self) -> iterator & - { - self._state->next(); - return self; - } - - auto operator++(this iterator &self, int) -> iterator & - { - self._state->next(); - return self; - } - - auto operator*(this iterator const &self) -> object { - return object(ref, self._state->cur); - } - -private: - struct state { - state(object const &obj) - { - auto const *uobj = obj.get_ucl_object(); - if ((iter = ::ucl_object_iterate_new(uobj)) == nullptr) - throw error("failed to create UCL iterator"); - } - - state(state const &) = delete; - auto operator=(this state &, state const &) -> state& = delete; - - ~state() { - if (iter != nullptr) - ::ucl_object_iterate_free(iter); - } - - auto next() -> void { - cur = ::ucl_object_iterate_safe(iter, true); - } - - ucl_object_iter_t iter = nullptr; - ucl_object_t const *cur = nullptr; - }; - - std::shared_ptr<state> _state; -}; - -static_assert(std::input_iterator<iterator>); - -export auto begin(object const &o) -> iterator -{ - return iterator(o); -} - -export auto end(object const &) -> iterator::sentinel -{ - return {}; -} + -> std::strong_ordering; } // namespace nihil::ucl diff --git a/nihil.ucl/parser.cc b/nihil.ucl/parser.cc new file mode 100644 index 0000000..816116d --- /dev/null +++ b/nihil.ucl/parser.cc @@ -0,0 +1,75 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <functional> +#include <string> + +#include <ucl.h> + +module nihil.ucl; + +namespace nihil::ucl { + +parse_error::parse_error(std::string what) + : error(std::move(what)) +{ +} + +auto macro_handler::handle(unsigned char const *data, std::size_t len, void *ud) +-> bool +{ + auto handler = static_cast<macro_handler *>(ud); + auto string = std::string_view( + reinterpret_cast<char const *>(data), + len); + return handler->callback(string); +} + +parser::parser(int flags) +{ + if ((_parser = ::ucl_parser_new(flags)) != nullptr) + return; + + throw error("failed to create UCL parser"); +} + +parser::parser() + : parser(0) +{ +} + +parser::~parser() +{ + if (_parser) + ::ucl_parser_free(_parser); +} + +auto parser::register_value( + this parser &self, + std::string_view variable, + std::string_view value) +-> void +{ + ::ucl_parser_register_variable( + self._parser, + std::string(variable).c_str(), + std::string(value).c_str()); +} + +auto parser::top(this parser &self) -> map<object> +{ + if (self._parser == nullptr) + throw error("attempt to call top() on an empty parser"); + + auto obj = ::ucl_parser_get_object(self._parser); + if (obj == nullptr) + throw error("attempt to call top() on an empty parser"); + + // ucl_parser_get_objects() refs the object for us. + return {noref, obj}; +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/parser.ccm b/nihil.ucl/parser.ccm index 9b87773..f817b76 100644 --- a/nihil.ucl/parser.ccm +++ b/nihil.ucl/parser.ccm @@ -25,7 +25,7 @@ namespace nihil::ucl { * Exception thrown when an issue occurs parsing UCL. */ export struct parse_error : error { - parse_error(std::string what) : error(std::move(what)) {} + parse_error(std::string what); }; // UCL parser flags. @@ -33,8 +33,6 @@ export inline constexpr int parser_key_lower = UCL_PARSER_KEY_LOWERCASE; export inline constexpr int parser_zerocopy = UCL_PARSER_ZEROCOPY; export inline constexpr int parser_no_time = UCL_PARSER_NO_TIME; -export struct parser; - // A macro handler. This proxies the C API callback to the C++ API. using macro_callback_t = bool (std::string_view); @@ -42,39 +40,25 @@ struct macro_handler { std::function<macro_callback_t> callback; // Handle a callback from the C API. - static auto handle(unsigned char const *data, std::size_t len, void *ud) - -> bool - { - auto handler = static_cast<macro_handler *>(ud); - auto string = std::string_view( - reinterpret_cast<char const *>(data), - len); - return handler->callback(string); - } + static auto handle( + unsigned char const *data, + std::size_t len, void + *ud) + -> bool; }; /* * A UCL parser. This wraps the C ucl_parser API. */ export struct parser { - // Create a new parser with the given flags. - parser(int flags) { - if ((_parser = ::ucl_parser_new(flags)) != nullptr) - return; - - throw error("failed to create UCL parser"); - } + parser(int flags); // Create a new parser with the default flags. - parser() : parser(0) {} + parser(); // Destroy our parser when we're destroyed. - ~parser() - { - if (_parser) - ::ucl_parser_free(_parser); - } + ~parser(); // Add a parser macro. Unlike ucl_parser_register_macro, this doesn't // take a userdata parameter; it's assumed the user will use lambda @@ -99,17 +83,12 @@ export struct parser { // Add a parser variable. auto register_value(this parser &self, std::string_view variable, - std::string_view value) -> void - { - ::ucl_parser_register_variable(self._parser, - std::string(variable).c_str(), - std::string(value).c_str()); - } + std::string_view value) -> void; // Add data to the parser. auto add(this parser &self, std::ranges::contiguous_range auto &&data) - -> void + -> void // Only bytes (chars) are permitted. requires(sizeof(std::ranges::range_value_t<decltype(data)>) == 1) { @@ -125,7 +104,7 @@ export struct parser { } auto add(this parser &self, std::ranges::range auto &&data) - -> void + -> void requires (!std::ranges::contiguous_range<decltype(data)>) { auto cdata = std::vector<char>( @@ -135,18 +114,7 @@ export struct parser { } // Return the top object of this parser. - auto top(this parser &self) -> map<object> - { - if (self._parser == nullptr) - throw error("attempt to call top() on an empty parser"); - - auto obj = ::ucl_parser_get_object(self._parser); - if (obj == nullptr) - throw error("attempt to call top() on an empty parser"); - - // ucl_parser_get_objects() refs the object for us. - return {noref, obj}; - } + auto top(this parser &self) -> map<object>; private: // The parser object. Should never be null, unless we've been diff --git a/nihil.ucl/real.cc b/nihil.ucl/real.cc new file mode 100644 index 0000000..b371072 --- /dev/null +++ b/nihil.ucl/real.cc @@ -0,0 +1,79 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <cassert> +#include <compare> +#include <cstdlib> +#include <string> + +#include <ucl.h> + +module nihil.ucl; + +namespace nihil::ucl { + +real::real(ref_t, ::ucl_object_t const *uobj) + : object(nihil::ucl::ref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +real::real(noref_t, ::ucl_object_t *uobj) + : object(noref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +real::real() + : real(0) +{ +} + +real::real(contained_type value) + : object(noref, ::ucl_object_fromdouble(value)) +{ + if (_object == nullptr) + throw error("failed to create UCL object"); +} + +auto real::value(this real const &self) -> contained_type +{ + auto v = contained_type{}; + auto const *uobj = self.get_ucl_object(); + + if (::ucl_object_todouble_safe(uobj, &v)) + return v; + + std::abort(); +} + +auto operator== (real const &a, real const &b) +-> bool +{ + return a.value() == b.value(); +} + +auto operator<=> (real const &a, real const &b) +-> std::partial_ordering +{ + return a.value() <=> b.value(); +} + +auto operator== (real const &a, real::contained_type b) +-> bool +{ + return a.value() == b; +} + +auto operator<=> (real const &a, real::contained_type b) +-> std::partial_ordering +{ + return a.value() <=> b; +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/real.ccm b/nihil.ucl/real.ccm index 260e993..e0ecbb5 100644 --- a/nihil.ucl/real.ccm +++ b/nihil.ucl/real.ccm @@ -4,9 +4,7 @@ module; -#include <cassert> -#include <cstdlib> -#include <string> +#include <compare> #include <ucl.h> @@ -22,72 +20,29 @@ export struct real final : object { inline static constexpr object_type ucl_type = object_type::real; // Create a new real from a UCL object. - real(ref_t, ::ucl_object_t const *uobj) - : object(nihil::ucl::ref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } - - real(noref_t, ::ucl_object_t *uobj) - : object(noref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } + real(ref_t, ::ucl_object_t const *uobj); + real(noref_t, ::ucl_object_t *uobj); // Create a default-initialised real. - real() - : real(0) - {} + real(); // Create a new real from a value. - explicit real(contained_type value) - : object(noref, ::ucl_object_fromdouble(value)) - { - if (_object == nullptr) - throw error("failed to create UCL object"); - } + explicit real(contained_type value); // Return the value of this real. - auto value(this real const &self) -> contained_type - { - auto v = contained_type{}; - auto const *uobj = self.get_ucl_object(); - - if (::ucl_object_todouble_safe(uobj, &v)) - return v; - - std::abort(); - } + auto value(this real const &self) -> contained_type; }; /* * Comparison operators. */ -export auto operator== (real const &a, real const &b) - -> bool -{ - return a.value() == b.value(); -} +export auto operator== (real const &a, real const &b) -> bool; +export auto operator== (real const &a, real::contained_type b) -> bool; export auto operator<=> (real const &a, real const &b) - -> std::partial_ordering -{ - return a.value() <=> b.value(); -} - -export auto operator== (real const &a, real::contained_type b) - -> bool -{ - return a.value() == b; -} - + -> std::partial_ordering; export auto operator<=> (real const &a, real::contained_type b) - -> std::partial_ordering -{ - return a.value() <=> b; -} + -> std::partial_ordering; } // namespace nihil::ucl diff --git a/nihil.ucl/string.cc b/nihil.ucl/string.cc new file mode 100644 index 0000000..d2f4618 --- /dev/null +++ b/nihil.ucl/string.cc @@ -0,0 +1,139 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <cstdlib> +#include <string> + +#include <ucl.h> + +module nihil.ucl; + +namespace nihil::ucl { + +string::string(ref_t, ::ucl_object_t const *uobj) + : object(nihil::ucl::ref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +string::string(noref_t, ::ucl_object_t *uobj) + : object(noref, uobj) +{ + if (type() != ucl_type) + throw type_mismatch(ucl_type, type()); +} + +string::string() + : string(std::string_view("")) +{} + +string::string(std::string_view value) + : object(nihil::ucl::ref, + ::ucl_object_fromstring_common( + value.data(), value.size(), + UCL_STRING_RAW)) +{ + if (_object == nullptr) + throw error("failed to create UCL object"); +} + +auto string::value(this string const &self) -> contained_type +{ + char const *dptr{}; + std::size_t dlen; + + auto const *uobj = self.get_ucl_object(); + if (::ucl_object_tolstring_safe(uobj, &dptr, &dlen)) + return {dptr, dlen}; + + // This should never fail. + std::abort(); +} + +auto string::size(this string const &self) -> size_type +{ + return self.value().size(); +} + +auto string::empty(this string const &self) -> bool +{ + return self.size() == 0; +} + +auto string::data(this string const &self) -> pointer +{ + char const *dptr{}; + + auto const *uobj = self.get_ucl_object(); + if (::ucl_object_tostring_safe(uobj, &dptr)) + return dptr; + + // This should never fail. + std::abort(); +} + +auto string::begin(this string const &self) -> iterator +{ + return self.data(); +} + +auto string::end(this string const &self) -> iterator +{ + return self.data() + self.size(); +} + +auto operator== (string const &a, string const &b) + -> bool +{ + return a.value() == b.value(); +} + +auto operator<=> (string const &a, string const &b) + -> std::strong_ordering +{ + return a.value() <=> b.value(); +} + +/* + * For convenience, allow comparison with C++ strings without having to + * construct a temporary UCL object. + */ + +auto operator==(string const &lhs, std::string_view rhs) -> bool +{ + return lhs.value() == rhs; +} + +auto operator<=>(string const &lhs, std::string_view rhs) + -> std::strong_ordering +{ + return lhs.value() <=> rhs; +} + +auto operator==(string const &lhs, std::string const &rhs) -> bool +{ + return lhs == std::string_view(rhs); +} + +auto operator<=>(string const &lhs, std::string const &rhs) + -> std::strong_ordering +{ + return lhs <=> std::string_view(rhs); +} + +auto operator==(string const &lhs, char const *rhs) -> bool +{ + return lhs == std::string_view(rhs); +} + +auto operator<=>(string const &lhs, char const *rhs) + -> std::strong_ordering +{ + return lhs <=> std::string_view(rhs); +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/string.ccm b/nihil.ucl/string.ccm index f92c82c..f8dc1cd 100644 --- a/nihil.ucl/string.ccm +++ b/nihil.ucl/string.ccm @@ -4,7 +4,6 @@ module; -#include <cassert> #include <cstdlib> #include <string> @@ -28,35 +27,14 @@ export struct string final : object { using iterator = pointer; // Create a new string from a UCL object. - string(ref_t, ::ucl_object_t const *uobj) - : object(nihil::ucl::ref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } - - string(noref_t, ::ucl_object_t *uobj) - : object(noref, uobj) - { - if (type() != ucl_type) - throw type_mismatch(ucl_type, type()); - } + string(ref_t, ::ucl_object_t const *uobj); + string(noref_t, ::ucl_object_t *uobj); // Create a new empty string. - string() - : string(std::string_view("")) - {} + string(); // Create a new UCL string from a string. - explicit string(std::string_view value) - : object(nihil::ucl::ref, - ::ucl_object_fromstring_common( - value.data(), value.size(), - UCL_STRING_RAW)) - { - if (_object == nullptr) - throw error("failed to create UCL object"); - } + explicit string(std::string_view value); // Create a new UCL string from an iterator pair. template<std::contiguous_iterator Iterator> @@ -77,108 +55,44 @@ export struct string final : object { {} // Return the value of this string. - auto value(this string const &self) -> contained_type - { - char const *dptr{}; - std::size_t dlen; - - auto const *uobj = self.get_ucl_object(); - if (::ucl_object_tolstring_safe(uobj, &dptr, &dlen)) - return {dptr, dlen}; - - // This should never fail. - std::abort(); - } + auto value(this string const &self) -> contained_type; // Return the size of this string. - auto size(this string const &self) -> size_type - { - return self.value().size(); - } + auto size(this string const &self) -> size_type; // Test if this string is empty. - auto empty(this string const &self) -> bool - { - return self.size() == 0; - } + auto empty(this string const &self) -> bool; // Access this string's data - auto data(this string const &self) -> pointer - { - char const *dptr{}; - - auto const *uobj = self.get_ucl_object(); - if (::ucl_object_tostring_safe(uobj, &dptr)) - return dptr; - - // This should never fail. - std::abort(); - } + auto data(this string const &self) -> pointer; // Iterator access - auto begin(this string const &self) -> iterator - { - return self.data(); - } - - auto end(this string const &self) -> iterator - { - return self.data() + self.size(); - } + auto begin(this string const &self) -> iterator; + auto end(this string const &self) -> iterator; }; /* * Comparison operators. */ -export auto operator== (string const &a, string const &b) - -> bool -{ - return a.value() == b.value(); -} - +export auto operator== (string const &a, string const &b) -> bool; export auto operator<=> (string const &a, string const &b) - -> std::strong_ordering -{ - return a.value() <=> b.value(); -} + -> std::strong_ordering; /* * For convenience, allow comparison with C++ strings without having to * construct a temporary UCL object. */ -export auto operator==(string const &lhs, std::string_view rhs) -> bool -{ - return lhs.value() == rhs; -} +export auto operator==(string const &lhs, std::string_view rhs) -> bool; +export auto operator==(string const &lhs, std::string const &rhs) -> bool; +export auto operator==(string const &lhs, char const *rhs) -> bool; export auto operator<=>(string const &lhs, std::string_view rhs) - -> std::strong_ordering -{ - return lhs.value() <=> rhs; -} - -export auto operator==(string const &lhs, std::string const &rhs) -> bool -{ - return lhs == std::string_view(rhs); -} - + -> std::strong_ordering; export auto operator<=>(string const &lhs, std::string const &rhs) - -> std::strong_ordering -{ - return lhs <=> std::string_view(rhs); -} - -export auto operator==(string const &lhs, char const *rhs) -> bool -{ - return lhs == std::string_view(rhs); -} - + -> std::strong_ordering; export auto operator<=>(string const &lhs, char const *rhs) - -> std::strong_ordering -{ - return lhs <=> std::string_view(rhs); -} + -> std::strong_ordering; } // namespace nihil::ucl diff --git a/nihil.ucl/type.cc b/nihil.ucl/type.cc new file mode 100644 index 0000000..a008aa3 --- /dev/null +++ b/nihil.ucl/type.cc @@ -0,0 +1,62 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <format> + +module nihil.ucl; + +namespace nihil::ucl { + +auto str(object_type type) -> std::string_view { + using namespace std::literals; + + switch (type) { + case object_type::object: + return "object"sv; + case object_type::array: + return "array"sv; + case object_type::integer: + return "integer"sv; + case object_type::real: + return "real"sv; + case object_type::string: + return "string"sv; + case object_type::boolean: + return "boolean"sv; + case object_type::time: + return "time"sv; + case object_type::userdata: + return "userdata"sv; + case object_type::null: + return "null"sv; + default: + // Don't fail here, since UCL might add more types that we + // don't know about. + return "unknown"sv; + } +} + +type_mismatch::type_mismatch( + object_type expected_type, object_type actual_type) + : error(std::format("UCL type mismatch: expected type '{}' " + "!= actual type '{}'", + str(expected_type), str(actual_type))) + , _expected_type(expected_type) + , _actual_type(actual_type) +{ +} + +auto type_mismatch::expected_type(this type_mismatch const &self) -> object_type +{ + return self._expected_type; +} + +auto type_mismatch::actual_type(this type_mismatch const &self) -> object_type +{ + return self._actual_type; +} + +} // namespace nihil::ucl diff --git a/nihil.ucl/type.ccm b/nihil.ucl/type.ccm index bf6c6bc..088d196 100644 --- a/nihil.ucl/type.ccm +++ b/nihil.ucl/type.ccm @@ -30,34 +30,7 @@ export enum struct object_type { }; // Get the name of a type. -export auto str(object_type type) -> std::string_view { - using namespace std::literals; - - switch (type) { - case object_type::object: - return "object"sv; - case object_type::array: - return "array"sv; - case object_type::integer: - return "integer"sv; - case object_type::real: - return "real"sv; - case object_type::string: - return "string"sv; - case object_type::boolean: - return "boolean"sv; - case object_type::time: - return "time"sv; - case object_type::userdata: - return "userdata"sv; - case object_type::null: - return "null"sv; - default: - // Don't fail here, since UCL might add more types that we - // don't know about. - return "unknown"sv; - } -} +export auto str(object_type type) -> std::string_view; // Concept of a UCL data type. export template<typename T> @@ -69,25 +42,12 @@ concept datatype = requires(T o) { // Exception thrown when a type assertion fails. export struct type_mismatch : error { - type_mismatch(object_type expected_type, object_type actual_type) - : error(std::format("UCL type mismatch: expected type '{}' " - "!= actual type '{}'", - str(expected_type), str(actual_type))) - , _expected_type(expected_type) - , _actual_type(actual_type) - {} + type_mismatch(object_type expected_type, object_type actual_type); // The type we expected. - auto expected_type(this type_mismatch const &self) -> object_type - { - return self._expected_type; - } - + auto expected_type(this type_mismatch const &self) -> object_type; // The type we got. - auto actual_type(this type_mismatch const &self) -> object_type - { - return self._actual_type; - } + auto actual_type(this type_mismatch const &self) -> object_type; private: object_type _expected_type; diff --git a/nihil/CMakeLists.txt b/nihil/CMakeLists.txt index 6406294..6dcec2c 100644 --- a/nihil/CMakeLists.txt +++ b/nihil/CMakeLists.txt @@ -1,8 +1,8 @@ # This source code is released into the public domain. add_library(nihil STATIC) -target_sources(nihil PUBLIC - FILE_SET modules TYPE CXX_MODULES FILES +target_sources(nihil + PUBLIC FILE_SET modules TYPE CXX_MODULES FILES nihil.ccm argv.ccm command_map.ccm @@ -25,6 +25,14 @@ target_sources(nihil PUBLIC tabulate.ccm usage_error.ccm write_file.ccm + + PRIVATE + exec.cc + fd.cc + find_in_path.cc + getenv.cc + open_file.cc + process.cc ) if(NIHIL_TESTS) diff --git a/nihil/exec.cc b/nihil/exec.cc new file mode 100644 index 0000000..f29122a --- /dev/null +++ b/nihil/exec.cc @@ -0,0 +1,75 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <format> +#include <string> +#include <utility> + +#include <err.h> +#include <fcntl.h> +#include <unistd.h> + +extern char **environ; + +module nihil; + +namespace nihil { + +exec_error::exec_error(std::string what) + : generic_error(std::move(what)) +{} + +executable_not_found::executable_not_found(std::string_view filename) + : exec_error(std::format("{}: command not found", filename)) + , _filename(filename) +{ +} + +auto executable_not_found::filename(this executable_not_found const &self) +-> std::string_view +{ + return self._filename; +} + +fexecv::fexecv(fd &&execfd, argv &&args) noexcept + : _execfd(std::move(execfd)) + , _args(std::move(args)) +{ +} + +auto fexecv::exec(this fexecv &self) noexcept +-> void +{ + ::fexecve(self._execfd.get(), self._args.data(), environ); + ::err(1, "fexecve"); +} + +fexecv::fexecv(fexecv &&) noexcept = default; +auto fexecv::operator=(this fexecv &, fexecv &&) noexcept -> fexecv& = default; + +auto execv(std::string_view path, argv &&argv) -> fexecv +{ + auto cpath = std::string(path); + auto const ret = ::open(cpath.c_str(), O_EXEC); + if (ret == -1) + throw executable_not_found(path); + return {fd(ret), std::move(argv)}; +} + +auto execvp(std::string_view file, argv &&argv) -> fexecv +{ + auto execfd = find_in_path(file); + if (!execfd) + throw executable_not_found(file); + return {std::move(*execfd), std::move(argv)}; +} + +auto shell(std::string_view const &command) -> fexecv +{ + return execl("/bin/sh", "sh", "-c", command); +} + +} // namespace nihil diff --git a/nihil/exec.ccm b/nihil/exec.ccm index f91efdf..7dbf31e 100644 --- a/nihil/exec.ccm +++ b/nihil/exec.ccm @@ -8,15 +8,7 @@ module; * Exec providers, mostly used for spawn(). */ -#include <format> #include <string> -#include <utility> - -#include <err.h> -#include <fcntl.h> -#include <unistd.h> - -extern char **environ; export module nihil:exec; @@ -31,24 +23,16 @@ namespace nihil { * Generic error, what() should be descriptive. */ export struct exec_error : generic_error { - exec_error(std::string what) - : generic_error(std::move(what)) - {} + exec_error(std::string what); }; /* * We tried to execute a path or filename and the file was not found. */ export struct executable_not_found : exec_error { - executable_not_found(std::string_view filename) - : exec_error(std::format("{}: command not found", filename)) - , _filename(filename) - {} - - auto filename(this executable_not_found const &self) -> std::string_view - { - return self._filename; - } + executable_not_found(std::string_view filename); + auto filename(this executable_not_found const &self) + -> std::string_view; private: std::string _filename; @@ -77,20 +61,13 @@ concept executor = export struct fexecv final { using tag = exec_tag; - fexecv(fd &&execfd, argv &&args) noexcept - : _execfd(std::move(execfd)) - , _args(std::move(args)) - {} + fexecv(fd &&execfd, argv &&args) noexcept; - [[noreturn]] auto exec(this fexecv &self) noexcept -> void - { - ::fexecve(self._execfd.get(), self._args.data(), environ); - ::err(1, "fexecve"); - } + [[noreturn]] auto exec(this fexecv &self) noexcept -> void; // Movable - fexecv(fexecv &&) noexcept = default; - auto operator=(this fexecv &, fexecv &&) noexcept -> fexecv& = default; + fexecv(fexecv &&) noexcept; + auto operator=(this fexecv &, fexecv &&) noexcept -> fexecv&; // Not copyable (because we hold the open fd object) fexecv(fexecv const &) = delete; @@ -101,33 +78,18 @@ private: argv _args; }; -static_assert(executor<fexecv>); - /* * execv: equivalent to fexecv(), except the command is passed as * a pathname instead of a file descriptor. Does not search $PATH. */ -export auto execv(std::string_view path, argv &&argv) -> fexecv -{ - auto cpath = std::string(path); - auto const ret = ::open(cpath.c_str(), O_EXEC); - if (ret == -1) - throw executable_not_found(path); - return {fd(ret), std::move(argv)}; -} +export auto execv(std::string_view path, argv &&argv) -> fexecv; /* * execvp: equivalent to fexecv(), except the command is passed as * a filename instead of a file descriptor. If the filename is not * an absolute path, it will be searched for in $PATH. */ -export auto execvp(std::string_view file, argv &&argv) -> fexecv -{ - auto execfd = find_in_path(file); - if (!execfd) - throw executable_not_found(file); - return {std::move(*execfd), std::move(argv)}; -} +export auto execvp(std::string_view file, argv &&argv) -> fexecv; /* * execl: equivalent to execv, except the arguments are passed as a @@ -151,9 +113,6 @@ export auto execlp(std::string_view file, auto &&...args) -> fexecv * shell: run the process by invoking /bin/sh -c with the single argument, * equivalent to system(3). */ -export auto shell(std::string_view const &command) -> fexecv -{ - return execl("/bin/sh", "sh", "-c", command); -} +export auto shell(std::string_view const &command) -> fexecv; } // namespace nihil diff --git a/nihil/fd.cc b/nihil/fd.cc new file mode 100644 index 0000000..e25ba28 --- /dev/null +++ b/nihil/fd.cc @@ -0,0 +1,250 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <fcntl.h> +#include <unistd.h> + +#include <expected> +#include <format> +#include <stdexcept> +#include <system_error> + +module nihil; + +namespace nihil { + +fd_logic_error::fd_logic_error(std::string what) + : std::logic_error(std::move(what)) +{ +} + +fd::fd() noexcept = default; + +fd::fd(int fd_) noexcept + : _fd(fd_) +{ +} + +fd::~fd() +{ + if (*this) + this->close(); +} + +fd::fd(fd &&other) noexcept + : _fd(std::exchange(other._fd, _invalid_fd)) +{ +} + +auto fd::operator=(fd &&other) noexcept -> fd & +{ + if (this != &other) + _fd = std::exchange(other._fd, _invalid_fd); + return *this; +} + +fd::operator bool(this fd const &self) noexcept +{ + return self._fd != _invalid_fd; +} + +auto fd::close(this fd &self) -> std::expected<void, std::error_code> +{ + auto const ret = ::close(self.get()); + self._fd = _invalid_fd; + + if (ret == 0) + return {}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto fd::get(this fd const &self) -> int +{ + if (self) + return self._fd; + throw fd_logic_error("Attempt to call get() on invalid fd"); +} + +auto fd::release(this fd &&self) -> int +{ + if (self) + return std::exchange(self._fd, self._invalid_fd); + throw fd_logic_error("Attempt to release an invalid fd"); +} + +auto dup(fd const &self) -> std::expected<fd, std::error_code> +{ + auto thisfd = self.get(); + + auto const newfd = ::dup(thisfd); + if (newfd != -1) + return {newfd}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto dup(fd const &self, int newfd) -> std::expected<fd, std::error_code> +{ + auto thisfd = self.get(); + + auto const ret = ::dup2(thisfd, newfd); + if (ret != -1) + return {newfd}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto raw_dup(fd const &self) -> std::expected<int, std::error_code> +{ + auto thisfd = self.get(); + + auto const newfd = ::dup(thisfd); + if (newfd != -1) + return {newfd}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto raw_dup(fd const &self, int newfd) -> std::expected<int, std::error_code> +{ + auto thisfd = self.get(); + + auto const ret = ::dup2(thisfd, newfd); + if (ret != -1) + return {newfd}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto getflags(fd const &self) -> std::expected<int, std::error_code> +{ + auto const flags = ::fcntl(self.get(), F_GETFL); + if (flags != -1) + return {flags}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto replaceflags(fd &self, int newflags) + -> std::expected<void, std::error_code> +{ + auto const ret = ::fcntl(self.get(), F_SETFL, newflags); + if (ret == 0) + return {}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto setflags(fd &self, int newflags) + -> std::expected<int, std::error_code> +{ + auto flags = getflags(self); + if (!flags) + return flags; + + *flags |= newflags; + auto const ret = replaceflags(self, *flags); + if (!ret) + return std::unexpected(ret.error()); + + return {*flags}; +} + +auto clearflags(fd &self, int clrflags) + -> std::expected<int, std::error_code> +{ + auto flags = getflags(self); + if (!flags) + return flags; + + *flags &= ~clrflags; + auto const ret = replaceflags(self, *flags); + if (!ret) + return std::unexpected(ret.error()); + + return {*flags}; +} + +auto getfdflags(fd const &self) -> std::expected<int, std::error_code> +{ + auto const flags = ::fcntl(self.get(), F_GETFD); + if (flags != -1) + return {flags}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto replacefdflags(fd &self, int newflags) + -> std::expected<void, std::error_code> +{ + auto const ret = ::fcntl(self.get(), F_SETFD, newflags); + if (ret != -1) + return {}; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto setfdflags(fd &self, int newflags) + -> std::expected<int, std::error_code> +{ + auto flags = getfdflags(self); + if (!flags) + return flags; + + *flags |= newflags; + auto const ret = replacefdflags(self, *flags); + if (!ret) + return std::unexpected(ret.error()); + + return {*flags}; +} + +auto clearfdflags(fd &self, int clrflags) + -> std::expected<int, std::error_code> +{ + auto flags = getfdflags(self); + if (!flags) + return flags; + + *flags &= ~clrflags; + auto ret = replacefdflags(self, *flags); + if (!ret) + return std::unexpected(ret.error()); + + return {*flags}; +} + +auto pipe() -> std::expected<std::pair<fd, fd>, std::error_code> { + auto fds = std::array<int, 2>{}; + + if (auto const ret = ::pipe(fds.data()); ret != 0) + return std::unexpected(std::make_error_code(std::errc(errno))); + + return {{fd(fds[0]), fd(fds[1])}}; +} + +auto fd::write(this fd &self, std::span<std::byte const> buffer) + -> std::expected<std::size_t, std::error_code> +{ + auto const ret = ::write(self.get(), buffer.data(), buffer.size()); + if (ret >= 0) + return ret; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +auto fd::read(this fd &self, std::span<std::byte> buffer) + -> std::expected<std::size_t, std::error_code> +{ + auto const ret = ::read(self.get(), buffer.data(), buffer.size()); + if (ret >= 0) + return ret; + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +} // namespace nihil diff --git a/nihil/fd.ccm b/nihil/fd.ccm index ad96ea7..352eab3 100644 --- a/nihil/fd.ccm +++ b/nihil/fd.ccm @@ -4,11 +4,9 @@ module; -#include <fcntl.h> -#include <unistd.h> - #include <expected> -#include <format> +#include <ranges> +#include <span> #include <stdexcept> #include <system_error> @@ -23,9 +21,7 @@ namespace nihil { * to be caught, since it indicates an internal logic error in the caller. */ export struct fd_logic_error final : std::logic_error { - fd_logic_error(std::string what) - : std::logic_error(std::move(what)) - {} + fd_logic_error(std::string what); }; /* @@ -34,67 +30,43 @@ export struct fd_logic_error final : std::logic_error { export struct fd final { // Construct an empty (invalid) fd. - fd() noexcept = default; + fd() noexcept; // Construct an fd from an exising file destrictor, taking ownership. - fd(int fd_) noexcept : _fd(fd_) {} + fd(int fd_) noexcept; // Destructor. Close the fd, discarding any errors. - ~fd() - { - if (*this) - this->close(); - } + ~fd(); // Move from another fd, leaving the moved-from fd in an invalid state. - fd(fd &&other) noexcept - : _fd(std::exchange(other._fd, _invalid_fd)) - {} - - // Move assign from another fd. - auto operator=(fd &&other) noexcept -> fd & - { - if (this != &other) - _fd = std::exchange(other._fd, _invalid_fd); - return *this; - } + fd(fd &&other) noexcept; + auto operator=(fd &&other) noexcept -> fd &; // Not copyable. fd(fd const &) = delete; fd& operator=(fd const &) = delete; // Return true if this fd is valid (open). - explicit operator bool(this fd const &self) noexcept - { - return self._fd != _invalid_fd; - } + explicit operator bool(this fd const &self) noexcept; // Close the wrapped fd. - auto close(this fd &self) -> std::expected<void, std::error_code> - { - auto const ret = ::close(self.get()); - self._fd = _invalid_fd; - - if (ret == 0) - return {}; - - return std::unexpected(std::make_error_code(std::errc(errno))); - } + auto close(this fd &self) -> std::expected<void, std::error_code>; // Return the stored fd. - auto get(this fd const &self) -> int { - if (self) - return self._fd; - throw fd_logic_error("Attempt to call get() on invalid fd"); - } - + auto get(this fd const &self) -> int; // Release the stored fd and return it. The caller must close it. - auto release(this fd &&self) -> int { - if (self) - return std::exchange(self._fd, self._invalid_fd); - throw fd_logic_error("Attempt to release an invalid fd"); - } + auto release(this fd &&self) -> int; + + // Write data from the provided buffer to the fd. Returns the + // number of bytes written. + auto write(this fd &self, std::span<std::byte const>) + -> std::expected<std::size_t, std::error_code>; + + // Read data from the fd to the provided buffer. Returns the + // number of bytes read. + auto read(this fd &self, std::span<std::byte>) + -> std::expected<std::size_t, std::error_code>; private: static constexpr int _invalid_fd = -1; @@ -103,16 +75,7 @@ private: }; // Create a copy of this fd by calling dup(). -export auto dup(fd const &self) -> std::expected<fd, std::error_code> -{ - auto thisfd = self.get(); - - auto const newfd = ::dup(thisfd); - if (newfd != -1) - return {newfd}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} +export auto dup(fd const &self) -> std::expected<fd, std::error_code>; // Create a copy of this fd by calling dup2(). Note that because this results // in the existing fd and the new fd both being managed by an fd instance, @@ -124,171 +87,60 @@ export auto dup(fd const &self) -> std::expected<fd, std::error_code> // In both of these cases, either use raw_dup() instead, or immediately call // release() on the returned fd to prevent the fd instance from closing it. export auto dup(fd const &self, int newfd) - -> std::expected<fd, std::error_code> -{ - auto thisfd = self.get(); - - auto const ret = ::dup2(thisfd, newfd); - if (ret != -1) - return {newfd}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} + -> std::expected<fd, std::error_code>; // Create a copy of this fd by calling dup(). -export auto raw_dup(fd const &self) -> std::expected<int, std::error_code> -{ - auto thisfd = self.get(); - - auto const newfd = ::dup(thisfd); - if (newfd != -1) - return {newfd}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} +export auto raw_dup(fd const &self) + -> std::expected<int, std::error_code>; // Create a copy of this fd by calling dup2(). export auto raw_dup(fd const &self, int newfd) - -> std::expected<int, std::error_code> -{ - auto thisfd = self.get(); - - auto const ret = ::dup2(thisfd, newfd); - if (ret != -1) - return {newfd}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} + -> std::expected<int, std::error_code>; // Return the fnctl flags for this fd. -export auto getflags(fd const &self) -> std::expected<int, std::error_code> -{ - auto const flags = ::fcntl(self.get(), F_GETFL); - if (flags != -1) - return {flags}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} +export auto getflags(fd const &self) + -> std::expected<int, std::error_code>; // Replace the fnctl flags for this fd. export auto replaceflags(fd &self, int newflags) - -> std::expected<void, std::error_code> -{ - auto const ret = ::fcntl(self.get(), F_SETFL, newflags); - if (ret == 0) - return {}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} + -> std::expected<void, std::error_code>; // Add bits to the fcntl flags for this fd. Returns the new flags. export auto setflags(fd &self, int newflags) - -> std::expected<int, std::error_code> -{ - auto flags = getflags(self); - if (!flags) - return flags; - - *flags |= newflags; - auto const ret = replaceflags(self, *flags); - if (!ret) - return std::unexpected(ret.error()); - - return {*flags}; -} + -> std::expected<int, std::error_code>; // Remove bits from the fcntl flags for this fd. Returns the new flags. export auto clearflags(fd &self, int clrflags) - -> std::expected<int, std::error_code> -{ - auto flags = getflags(self); - if (!flags) - return flags; - - *flags &= ~clrflags; - auto const ret = replaceflags(self, *flags); - if (!ret) - return std::unexpected(ret.error()); - - return {*flags}; -} + -> std::expected<int, std::error_code>; // Return the fd flags for this fd. -export auto getfdflags(fd const &self) -> std::expected<int, std::error_code> -{ - auto const flags = ::fcntl(self.get(), F_GETFD); - if (flags != -1) - return {flags}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} +export auto getfdflags(fd const &self) + -> std::expected<int, std::error_code>; // Replace the fd flags for this fd. export auto replacefdflags(fd &self, int newflags) - -> std::expected<void, std::error_code> -{ - auto const ret = ::fcntl(self.get(), F_SETFD, newflags); - if (ret != -1) - return {}; - - return std::unexpected(std::make_error_code(std::errc(errno))); -} + -> std::expected<void, std::error_code>; // Add bits to the fd flags for this fd. Returns the new flags. export auto setfdflags(fd &self, int newflags) - -> std::expected<int, std::error_code> -{ - auto flags = getfdflags(self); - if (!flags) - return flags; - - *flags |= newflags; - auto const ret = replacefdflags(self, *flags); - if (!ret) - return std::unexpected(ret.error()); - - return {*flags}; -} + -> std::expected<int, std::error_code>; // Remove bits from the fd flags for this fd. Returns the new flags. export auto clearfdflags(fd &self, int clrflags) - -> std::expected<int, std::error_code> -{ - auto flags = getfdflags(self); - if (!flags) - return flags; - - *flags &= ~clrflags; - auto ret = replacefdflags(self, *flags); - if (!ret) - return std::unexpected(ret.error()); - - return {*flags}; -} + -> std::expected<int, std::error_code>; // Create two fds by calling pipe() and return them. -export auto pipe() -> std::expected<std::pair<fd, fd>, std::error_code> { - auto fds = std::array<int, 2>{}; - - if (auto const ret = ::pipe(fds.data()); ret != 0) - return std::unexpected(std::make_error_code(std::errc(errno))); - - return {{fd(fds[0]), fd(fds[1])}}; -} +export auto pipe() -> std::expected<std::pair<fd, fd>, std::error_code>; /* - * Write data to a file descriptor from the provided buffer. Returns the + * Write data to a file descriptor from the provided range. Returns the * number of bytes (not objects) written. Incomplete writes may cause a * partial object to be written. */ export auto write(fd &file, std::ranges::contiguous_range auto &&range) -> std::expected<std::size_t, std::error_code> { - auto const ret = ::write(file.get(), std::ranges::data(range), - std::ranges::size(range)); - if (ret >= 0) - return ret; - return std::unexpected(std::make_error_code(std::errc(errno))); + return file.write(as_bytes(std::span(range))); } /* @@ -299,11 +151,7 @@ export auto write(fd &file, std::ranges::contiguous_range auto &&range) export auto read(fd &file, std::ranges::contiguous_range auto &&range) -> std::expected<std::size_t, std::error_code> { - auto const ret = ::read(file.get(), std::ranges::data(range), - std::ranges::size(range)); - if (ret >= 0) - return ret; - return std::unexpected(std::make_error_code(std::errc(errno))); + return file.read(as_writable_bytes(std::span(range))); } } // namespace nihil diff --git a/nihil/find_in_path.cc b/nihil/find_in_path.cc new file mode 100644 index 0000000..2b8a57c --- /dev/null +++ b/nihil/find_in_path.cc @@ -0,0 +1,52 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <filesystem> +#include <optional> +#include <ranges> +#include <string> + +#include <fcntl.h> +#include <paths.h> + +module nihil; + +namespace nihil { + +auto find_in_path(std::filesystem::path const &file) +-> std::optional<fd> +{ + using namespace std::literals; + + auto try_open = + [](std::filesystem::path const &file) -> std::optional<fd> + { + auto ret = open_file(file, O_EXEC); + if (ret) + return {std::move(*ret)}; + return {}; + }; + + // Absolute pathname skips the search. + if (file.is_absolute()) + return try_open(file); + + auto path = getenv("PATH").value_or(_PATH_DEFPATH); + + for (auto &&dir : path | std::views::split(':')) { + // An empty $PATH element means cwd. + auto sdir = dir.empty() + ? std::filesystem::path(".") + : std::filesystem::path(std::string_view(dir)); + + if (auto ret = try_open(sdir / file); ret) + return ret; + } + + return {}; +} + +} // namespace lfjail diff --git a/nihil/find_in_path.ccm b/nihil/find_in_path.ccm index 1e72d0b..3c02ca5 100644 --- a/nihil/find_in_path.ccm +++ b/nihil/find_in_path.ccm @@ -4,57 +4,20 @@ module; -#include <format> -#include <ranges> -#include <string> - -#include <fcntl.h> -#include <paths.h> -#include <unistd.h> +#include <filesystem> +#include <optional> export module nihil:find_in_path; import :fd; -import :getenv; namespace nihil { /* * Find an executable in $PATH, open it with O_EXEC and return the fd. - * If $PATH is not set, uses _PATH_DEFPATH. + * If $PATH is not set, uses _PATH_DEFPATH. If the file can't be found + * or opened, returns std::nullopt. */ -auto find_in_path(std::string_view file) -> std::optional<fd> { - using namespace std::literals; - - auto try_open = [](std::string_view path) -> std::optional<fd> { - auto cpath = std::string(path); - auto const ret = ::open(cpath.c_str(), O_EXEC); - if (ret != -1) - return fd(ret); - return {}; - }; - - if (file.empty()) - return {}; - - // Absolute pathname skips the search. - if (file[0] == '/') - return try_open(file); - - auto path = getenv("PATH").value_or(_PATH_DEFPATH); - - for (auto &&dir : std::views::split(path, ':')) { - // An empty $PATH element means cwd. - auto sdir = std::string_view(dir); - if (sdir.empty()) - sdir = "."; - - auto const path = std::format("{}/{}", sdir, file); - if (auto ret = try_open(path); ret) - return ret; - } - - return {}; -} +auto find_in_path(std::filesystem::path const &file) -> std::optional<fd>; -} // namespace lfjail +} // namespace nihil diff --git a/nihil/getenv.cc b/nihil/getenv.cc new file mode 100644 index 0000000..8f28211 --- /dev/null +++ b/nihil/getenv.cc @@ -0,0 +1,44 @@ + +/* + * This source code is released into the public domain. + */ + +module; + +#include <cstdint> +#include <expected> +#include <string> +#include <system_error> +#include <vector> + +#include <unistd.h> + +module nihil; + +namespace nihil { + + auto getenv(std::string_view varname) +-> std::expected<std::string, std::error_code> +{ + // Start with a buffer of this size, and double it every iteration. + constexpr auto bufinc = std::size_t{1024}; + + auto cvarname = std::string(varname); + auto buf = std::vector<char>(bufinc); + for (;;) { + auto const ret = ::getenv_r(cvarname.c_str(), + buf.data(), buf.size()); + + if (ret == 0) + return {std::string(buf.data())}; + + if (ret == -1 && errno == ERANGE) { + buf.resize(buf.size() * 2); + continue; + } + + return std::unexpected(std::make_error_code(std::errc(errno))); + } +} + +} // namespace nihil diff --git a/nihil/getenv.ccm b/nihil/getenv.ccm index 7397b79..c1b99d7 100644 --- a/nihil/getenv.ccm +++ b/nihil/getenv.ccm @@ -4,13 +4,9 @@ module; -#include <cstdint> #include <expected> #include <string> #include <system_error> -#include <vector> - -#include <unistd.h> export module nihil:getenv; @@ -21,27 +17,6 @@ namespace nihil { */ export auto getenv(std::string_view varname) - -> std::expected<std::string, std::error_code> -{ - // Start with a buffer of this size, and double it every iteration. - constexpr auto bufinc = std::size_t{1024}; - - auto cvarname = std::string(varname); - auto buf = std::vector<char>(bufinc); - for (;;) { - auto const ret = ::getenv_r(cvarname.c_str(), - buf.data(), buf.size()); - - if (ret == 0) - return {std::string(buf.data())}; - - if (ret == -1 && errno == ERANGE) { - buf.resize(buf.size() * 2); - continue; - } - - return std::unexpected(std::make_error_code(std::errc(errno))); - } -} + -> std::expected<std::string, std::error_code>; } // namespace nihil diff --git a/nihil/open_file.cc b/nihil/open_file.cc new file mode 100644 index 0000000..d86478c --- /dev/null +++ b/nihil/open_file.cc @@ -0,0 +1,28 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <expected> +#include <filesystem> +#include <system_error> + +#include <fcntl.h> +#include <unistd.h> + +module nihil; + +namespace nihil { + +auto open_file(std::filesystem::path const &filename, int flags, int mode) +-> std::expected<fd, std::error_code> +{ + auto fdno = ::open(filename.c_str(), flags, mode); + if (fdno != -1) + return fd(fdno); + + return std::unexpected(std::make_error_code(std::errc(errno))); +} + +} // namespace nihil diff --git a/nihil/open_file.ccm b/nihil/open_file.ccm index 38fedbd..a399474 100644 --- a/nihil/open_file.ccm +++ b/nihil/open_file.ccm @@ -8,9 +8,6 @@ module; #include <filesystem> #include <system_error> -#include <fcntl.h> -#include <unistd.h> - export module nihil:open_file; import :fd; @@ -21,15 +18,7 @@ namespace nihil { * Open the given file and return an fd for it. */ auto open_file(std::filesystem::path const &filename, - int flags, - int mode = 0777) - -> std::expected<fd, std::error_code> -{ - auto fdno = ::open(filename.c_str(), flags, mode); - if (fdno != -1) - return fd(fdno); - - return std::unexpected(std::make_error_code(std::errc(errno))); -} + int flags, int mode = 0777) + -> std::expected<fd, std::error_code>; } // namespace nihil diff --git a/nihil/process.cc b/nihil/process.cc new file mode 100644 index 0000000..0122907 --- /dev/null +++ b/nihil/process.cc @@ -0,0 +1,111 @@ +/* + * This source code is released into the public domain. + */ + +module; + +#include <cerrno> +#include <cstring> +#include <format> +#include <optional> +#include <system_error> +#include <utility> + +#include <sys/types.h> +#include <sys/wait.h> + +module nihil; + +namespace nihil { + +process_error::process_error(std::string what) + : generic_error(std::move(what)) +{ +} + +waitpid_error::waitpid_error(::pid_t pid, std::error_code error) + : process_error(std::format("waitpid({}): {}", + pid, error.message())) + , _pid(pid) + , _error(error) +{ +} + +auto waitpid_error::pid(this waitpid_error const &self) -> ::pid_t +{ + return self._pid; +} + +auto waitpid_error::error(this waitpid_error const &self) -> std::error_code +{ + return self._error; +} + +auto wait_result::okay(this wait_result const &self) -> bool +{ + return self.status() == 0; +} + +wait_result::operator bool(this wait_result const &self) +{ + return self.okay(); +} + +auto wait_result::status(this wait_result const &self) -> std::optional<int> +{ + if (WIFEXITED(self._status)) + return WEXITSTATUS(self._status); + return {}; +} + +auto wait_result::signal(this wait_result const &self) -> std::optional<int> +{ + if (WIFSIGNALED(self._status)) + return WTERMSIG(self._status); + return {}; +} + +wait_result::wait_result(int status) + : _status(status) +{} + +process::process(::pid_t pid) + : _pid(pid) +{} + +process::~process() { + if (_pid == -1) + return; + + auto status = int{}; + std::ignore = waitpid(_pid, &status, WEXITED); +} + +process::process(process &&) noexcept = default; +auto process::operator=(process &&) noexcept -> process& = default; + +// Get the child's process id. +auto process::pid(this process const &self) noexcept -> ::pid_t +{ + return self._pid; +} + +auto process::wait(this process &&self) -> wait_result +{ + auto status = int{}; + auto ret = waitpid(self._pid, &status, WEXITED); + if (ret != -1) + return wait_result(status); + + throw waitpid_error(self._pid, + std::make_error_code(std::errc(errno))); +} + +auto process::release(this process &&self) -> ::pid_t +{ + auto const ret = self.pid(); + self._pid = -1; + return ret; +} + +} // namespace nihil diff --git a/nihil/process.ccm b/nihil/process.ccm index ba8a399..db8b61a 100644 --- a/nihil/process.ccm +++ b/nihil/process.ccm @@ -4,15 +4,11 @@ module; -#include <cerrno> -#include <cstring> -#include <format> #include <optional> #include <system_error> #include <utility> #include <sys/types.h> -#include <sys/wait.h> export module nihil:process; @@ -24,29 +20,15 @@ namespace nihil { * Exception thrown when a process operation fails. */ export struct process_error : generic_error { - process_error(std::string what) - : generic_error(std::move(what)) - {} + process_error(std::string what); }; // A waitpid() call failed. export struct waitpid_error : process_error { - waitpid_error(::pid_t pid, std::error_code error) - : process_error(std::format("waitpid({}): {}", - pid, error.message())) - , _pid(pid) - , _error(error) - {} - - auto pid(this waitpid_error const &self) -> ::pid_t - { - return self._pid; - } - - auto error(this waitpid_error const &self) -> std::error_code - { - return self._error; - } + waitpid_error(::pid_t pid, std::error_code error); + + auto pid(this waitpid_error const &self) -> ::pid_t; + auto error(this waitpid_error const &self) -> std::error_code; private: ::pid_t _pid; @@ -59,31 +41,14 @@ private: export struct wait_result final { // Return true if the process exited normally with an exit code of // zero, otherwise false. - auto okay(this wait_result const &self) -> bool - { - return self.status() == 0; - } - - explicit operator bool(this wait_result const &self) - { - return self.okay(); - } + auto okay(this wait_result const &self) -> bool; + explicit operator bool(this wait_result const &self); // Return the exit status, if any. - auto status(this wait_result const &self) -> std::optional<int> - { - if (WIFEXITED(self._status)) - return WEXITSTATUS(self._status); - return {}; - } + auto status(this wait_result const &self) -> std::optional<int>; // Return the exit signal, if any. - auto signal(this wait_result const &self) -> std::optional<int> - { - if (WIFSIGNALED(self._status)) - return WTERMSIG(self._status); - return {}; - } + auto signal(this wait_result const &self) -> std::optional<int>; private: friend struct process; @@ -91,9 +56,7 @@ private: int _status; // Construct a new wait_result from the output of waitpid(). - wait_result(int status) - : _status(status) - {} + wait_result(int status); }; /* @@ -106,23 +69,15 @@ export struct process final { * Create a new process from a pid, which must be a child of the * current process. */ - process(::pid_t pid) - : _pid(pid) - {} + process(::pid_t pid); // When destroyed, we automatically wait for the process to // avoid creating zombie processes. - ~process() { - if (_pid == -1) - return; - - auto status = int{}; - std::ignore = waitpid(_pid, &status, WEXITED); - } + ~process(); // Movable. - process(process &&) noexcept = default; - auto operator=(process &&) noexcept -> process& = default; + process(process &&) noexcept; + auto operator=(process &&) noexcept -> process&; // Not copyable. process(process const &) = delete; @@ -136,26 +91,13 @@ export struct process final { * its exit status. This destroys the process state, leaving this * object in a moved-from state. */ - auto wait(this process &&self) -> wait_result - { - auto status = int{}; - auto ret = waitpid(self._pid, &status, WEXITED); - if (ret != -1) - return wait_result(status); - - throw waitpid_error(self._pid, - std::make_error_code(std::errc(errno))); - } + auto wait(this process &&self) -> wait_result; /* * Release this process so we won't try to wait for it when * destroying this object. */ - auto release(this process &&self) -> ::pid_t { - auto const ret = self._pid; - self._pid = -1; - return ret; - } + auto release(this process &&self) -> ::pid_t; private: ::pid_t _pid; |