diff --git a/src/devices/machine/netlist.cpp b/src/devices/machine/netlist.cpp index 26da30d8a82..0ceba02df1e 100644 --- a/src/devices/machine/netlist.cpp +++ b/src/devices/machine/netlist.cpp @@ -289,7 +289,7 @@ public: { } - virtual plib::unique_ptr stream(const pstring &name) override; + virtual plib::unique_ptr stream(const pstring &name) override; private: device_t &m_dev; pstring m_name; @@ -300,7 +300,7 @@ class netlist_data_memregions_t : public netlist::source_t public: netlist_data_memregions_t(const device_t &dev); - virtual plib::unique_ptr stream(const pstring &name) override; + virtual plib::unique_ptr stream(const pstring &name) override; private: const device_t &m_dev; @@ -311,12 +311,14 @@ private: // memregion source support // ---------------------------------------------------------------------------------------- -plib::unique_ptr netlist_source_memregion_t::stream(const pstring &name) +plib::unique_ptr netlist_source_memregion_t::stream(const pstring &name) { if (m_dev.has_running_machine()) { memory_region *mem = m_dev.memregion(m_name.c_str()); - return plib::make_unique(pstring(reinterpret_cast(mem->base()), mem->bytes())); + auto ret(plib::make_unique(pstring(reinterpret_cast(mem->base()), mem->bytes()))); + ret->imbue(std::locale::classic()); + return ret; } else throw memregion_not_set("memregion unavailable for {1} in source {2}", name, m_name); @@ -347,24 +349,32 @@ static bool rom_exists(device_t &root, pstring name) return false; } -plib::unique_ptr netlist_data_memregions_t::stream(const pstring &name) +plib::unique_ptr netlist_data_memregions_t::stream(const pstring &name) { //memory_region *mem = static_cast(setup().setup().exec()).parent().memregion(name.c_str()); if (m_dev.has_running_machine()) { memory_region *mem = m_dev.memregion(name.c_str()); if (mem != nullptr) - return plib::make_unique(pstring(reinterpret_cast(mem->base()), mem->bytes())); + { + auto ret(plib::make_unique(std::string(reinterpret_cast(mem->base()), mem->bytes()), std::ios_base::binary)); + ret->imbue(std::locale::classic()); + return ret; + } else - return plib::unique_ptr(nullptr); + return plib::unique_ptr(nullptr); } else { /* validation */ if (rom_exists(m_dev.mconfig().root_device(), pstring(m_dev.tag()) + ":" + name)) - return plib::make_unique(); + { + auto ret(plib::make_unique(std::ios_base::binary)); + ret->imbue(std::locale::classic()); + return ret; + } else - return plib::unique_ptr(nullptr); + return plib::unique_ptr(nullptr); } } diff --git a/src/lib/netlist/devices/nld_log.cpp b/src/lib/netlist/devices/nld_log.cpp index 6b1b3d8efc1..c8569f473c3 100644 --- a/src/lib/netlist/devices/nld_log.cpp +++ b/src/lib/netlist/devices/nld_log.cpp @@ -19,9 +19,13 @@ namespace netlist { NETLIB_CONSTRUCTOR(log) , m_I(*this, "I") - , m_strm(pstring(plib::pfmt("{1}.log")(this->name()))) + , m_strm(plib::filesystem::u8path(plib::pfmt("{1}.log")(this->name()))) , m_writer(&m_strm) { + if (m_strm.fail()) + throw plib::file_open_e(plib::pfmt("{1}.log")(this->name())); + + m_strm.imbue(std::locale::classic()); } NETLIB_UPDATEI() @@ -33,7 +37,7 @@ namespace netlist NETLIB_RESETI() { } protected: analog_input_t m_I; - plib::pofilestream m_strm; + std::ofstream m_strm; plib::putf8_writer m_writer; }; diff --git a/src/lib/netlist/nl_base.cpp b/src/lib/netlist/nl_base.cpp index 1231d41b46a..851c7b8059f 100644 --- a/src/lib/netlist/nl_base.cpp +++ b/src/lib/netlist/nl_base.cpp @@ -1033,7 +1033,7 @@ nl_double param_model_t::value(const pstring &entity) } -plib::unique_ptr param_data_t::stream() +plib::unique_ptr param_data_t::stream() { return device().setup().get_data_stream(str()); } diff --git a/src/lib/netlist/nl_base.h b/src/lib/netlist/nl_base.h index caa95170308..eb796bf7834 100644 --- a/src/lib/netlist/nl_base.h +++ b/src/lib/netlist/nl_base.h @@ -1119,7 +1119,7 @@ namespace netlist { } - plib::unique_ptr stream(); + plib::unique_ptr stream(); protected: void changed() override { } }; @@ -1139,7 +1139,7 @@ namespace netlist protected: void changed() override { - stream()->read(reinterpret_cast(&m_data[0]),1<read(reinterpret_cast(&m_data[0]),1<read(reinterpret_cast(&m_data[0]),1<read(reinterpret_cast(&m_data[0]),1< &&istrm, const pstring &name) + bool nlparse_t::parse_stream(plib::unique_ptr &&istrm, const pstring &name) { plib::ppreprocessor y(&m_defines); plib::ppreprocessor &x(y.process(std::move(istrm))); @@ -1018,7 +1018,7 @@ const logic_family_desc_t *setup_t::family_from_model(const pstring &model) // Sources // ---------------------------------------------------------------------------------------- -plib::unique_ptr setup_t::get_data_stream(const pstring &name) +plib::unique_ptr setup_t::get_data_stream(const pstring &name) { for (auto &source : m_sources) { @@ -1030,7 +1030,7 @@ plib::unique_ptr setup_t::get_data_stream(const pstring &name) } } log().warning(MW_DATA_1_NOT_FOUND(name)); - return plib::unique_ptr(nullptr); + return plib::unique_ptr(nullptr); } @@ -1199,22 +1199,27 @@ bool source_t::parse(nlparse_t &setup, const pstring &name) } } -plib::unique_ptr source_string_t::stream(const pstring &name) +plib::unique_ptr source_string_t::stream(const pstring &name) { plib::unused_var(name); - return plib::make_unique(m_str); + auto ret(plib::make_unique(m_str)); + ret->imbue(std::locale::classic()); + return std::move(ret); } -plib::unique_ptr source_mem_t::stream(const pstring &name) +plib::unique_ptr source_mem_t::stream(const pstring &name) { plib::unused_var(name); - return plib::make_unique(m_str); + auto ret(plib::make_unique(m_str, std::ios_base::binary)); + ret->imbue(std::locale::classic()); + return std::move(ret); } -plib::unique_ptr source_file_t::stream(const pstring &name) +plib::unique_ptr source_file_t::stream(const pstring &name) { plib::unused_var(name); - return plib::make_unique(m_filename); + auto ret(plib::make_unique(plib::filesystem::u8path(m_filename))); + return std::move(ret); } bool source_proc_t::parse(nlparse_t &setup, const pstring &name) @@ -1228,10 +1233,10 @@ bool source_proc_t::parse(nlparse_t &setup, const pstring &name) return false; } -plib::unique_ptr source_proc_t::stream(const pstring &name) +plib::unique_ptr source_proc_t::stream(const pstring &name) { plib::unused_var(name); - plib::unique_ptr p(nullptr); + plib::unique_ptr p(nullptr); return p; } diff --git a/src/lib/netlist/nl_setup.h b/src/lib/netlist/nl_setup.h index 7fd9cf9cd48..3650b3756a9 100644 --- a/src/lib/netlist/nl_setup.h +++ b/src/lib/netlist/nl_setup.h @@ -196,7 +196,7 @@ namespace netlist type_t type() const { return m_type; } protected: - virtual plib::unique_ptr stream(const pstring &name) = 0; + virtual plib::unique_ptr stream(const pstring &name) = 0; private: const type_t m_type; @@ -278,7 +278,7 @@ namespace netlist bool device_exists(const pstring &name) const; /* FIXME: used by source_t - need a different approach at some time */ - bool parse_stream(plib::unique_ptr &&istrm, const pstring &name); + bool parse_stream(plib::unique_ptr &&istrm, const pstring &name); void add_define(const pstring &def, const pstring &val) { @@ -363,7 +363,7 @@ namespace netlist void register_dynamic_log_devices(); void resolve_inputs(); - plib::unique_ptr get_data_stream(const pstring &name); + plib::unique_ptr get_data_stream(const pstring &name); factory::list_t &factory() { return m_factory; } const factory::list_t &factory() const { return m_factory; } @@ -434,7 +434,7 @@ namespace netlist } protected: - plib::unique_ptr stream(const pstring &name) override; + plib::unique_ptr stream(const pstring &name) override; private: pstring m_str; @@ -450,7 +450,7 @@ namespace netlist } protected: - plib::unique_ptr stream(const pstring &name) override; + plib::unique_ptr stream(const pstring &name) override; private: pstring m_filename; @@ -465,7 +465,7 @@ namespace netlist } protected: - plib::unique_ptr stream(const pstring &name) override; + plib::unique_ptr stream(const pstring &name) override; private: pstring m_str; @@ -484,7 +484,7 @@ namespace netlist bool parse(nlparse_t &setup, const pstring &name) override; protected: - plib::unique_ptr stream(const pstring &name) override; + plib::unique_ptr stream(const pstring &name) override; private: void (*m_setup_func)(nlparse_t &); diff --git a/src/lib/netlist/plib/pmain.cpp b/src/lib/netlist/plib/pmain.cpp index 6b8a5c1f3fb..1ecf0a4d032 100644 --- a/src/lib/netlist/plib/pmain.cpp +++ b/src/lib/netlist/plib/pmain.cpp @@ -35,15 +35,8 @@ namespace plib { app::app() : options() -#if !USE_CSTREAM - , pout_strm() - , perr_strm() - , pout(&pout_strm) - , perr(&perr_strm) -#else , pout(&std::cout) , perr(&std::cerr) -#endif { } diff --git a/src/lib/netlist/plib/pmain.h b/src/lib/netlist/plib/pmain.h index 2538ec23855..cfa73844f57 100644 --- a/src/lib/netlist/plib/pmain.h +++ b/src/lib/netlist/plib/pmain.h @@ -44,10 +44,7 @@ namespace plib { virtual pstring usage() = 0; virtual int execute() = 0; -#if !USE_CSTREAM - plib::pstdout pout_strm; - plib::pstderr perr_strm; -#endif + plib::putf8_fmt_writer pout; plib::putf8_fmt_writer perr; diff --git a/src/lib/netlist/plib/pparser.cpp b/src/lib/netlist/plib/pparser.cpp index bcb3aba4ef3..2b365f22811 100644 --- a/src/lib/netlist/plib/pparser.cpp +++ b/src/lib/netlist/plib/pparser.cpp @@ -264,11 +264,7 @@ void ptokenizer::error(const pstring &errs) // ---------------------------------------------------------------------------------------- ppreprocessor::ppreprocessor(defines_map_type *defines) -#if !USE_CSTREAM -: pistream() -#else -: pistream(new st(this)) -#endif +: std::istream(new st(this)) , m_ifflag(0) , m_level(0) , m_lineno(0) @@ -300,20 +296,6 @@ void ppreprocessor::error(const pstring &err) throw pexception("PREPRO ERROR: " + err); } -#if !USE_CSTREAM -pstream::size_type ppreprocessor::vread(char_type *buf, const pstream::size_type n) -{ - size_type bytes = std::min(m_buf.size() - m_pos, static_cast(n)); - - if (bytes==0) - return 0; - - std::copy(m_buf.c_str() + m_pos, m_buf.c_str() + m_pos + bytes, buf); - m_pos += bytes; - return bytes; -} -#endif - #define CHECKTOK2(p_op, p_prio) \ else if (tok == # p_op) \ { \ diff --git a/src/lib/netlist/plib/pparser.h b/src/lib/netlist/plib/pparser.h index 12dc4183ad0..123786602e0 100644 --- a/src/lib/netlist/plib/pparser.h +++ b/src/lib/netlist/plib/pparser.h @@ -125,6 +125,7 @@ public: token_t get_token_internal(); void error(const pstring &errs); + putf8_reader &stream() { return m_strm; } protected: virtual void verror(const pstring &msg, int line_num, const pstring &line) = 0; @@ -158,11 +159,7 @@ private: }; -#if !USE_CSTREAM -class ppreprocessor : public pistream -#else -class ppreprocessor : public /*std::streambuf,*/ pistream -#endif +class ppreprocessor : public std::istream { public: @@ -178,14 +175,11 @@ public: using defines_map_type = std::unordered_map; explicit ppreprocessor(defines_map_type *defines = nullptr); -#if !USE_CSTREAM - ~ppreprocessor() override = default; -#else ~ppreprocessor() override { delete rdbuf(); } -#endif + template ppreprocessor & process(T &&istrm) { @@ -205,12 +199,7 @@ public: ppreprocessor(ppreprocessor &&s) noexcept - //: pistream(s.rdbuf()) -#if !USE_CSTREAM - : pistream() -#else - : pistream(new st(this)) -#endif + : std::istream(new st(this)) , m_defines(std::move(s.m_defines)) , m_expr_sep(std::move(s.m_expr_sep)) , m_ifflag(s.m_ifflag) @@ -225,15 +214,6 @@ public: protected: -#if !USE_CSTREAM - size_type vread(char_type *buf, const pos_type n) override; - void vseek(const pos_type n) override - { - plib::unused_var(n); - /* FIXME throw exception - should be done in base unless implemented */ - } - pos_type vtell() const override { return m_pos; } -#else class st : public std::streambuf { public: @@ -264,7 +244,7 @@ protected: std::array m_buf; }; //friend class st; -#endif + int expr(const std::vector &sexpr, std::size_t &start, int prio); define_t *get_define(const pstring &name); pstring replace_macros(const pstring &line); @@ -288,7 +268,7 @@ private: int m_level; int m_lineno; pstring_t m_buf; - pistream::pos_type m_pos; + std::istream::pos_type m_pos; state_e m_state; pstring m_line; bool m_comment; diff --git a/src/lib/netlist/plib/pstream.cpp b/src/lib/netlist/plib/pstream.cpp index 4d6b8144760..1e805825af3 100644 --- a/src/lib/netlist/plib/pstream.cpp +++ b/src/lib/netlist/plib/pstream.cpp @@ -21,289 +21,6 @@ namespace plib { -// ----------------------------------------------------------------------------- -// pistream: input stream -// ----------------------------------------------------------------------------- - -// ----------------------------------------------------------------------------- -// postream: output stream -// ----------------------------------------------------------------------------- - -// ----------------------------------------------------------------------------- -// Input file stream -// ----------------------------------------------------------------------------- - -#if !USE_CSTREAM - -pifilestream::pifilestream(const pstring &fname) -: pistream(0) -, m_file(fopen(fname.c_str(), "rb")) -, m_pos(0) -, m_actually_close(true) -, m_filename(fname) -{ - if (m_file == nullptr) - throw file_open_e(fname); - else - init(); -} - -pifilestream::pifilestream(void *file, const pstring &name, const bool do_close) -: pistream(0), m_file(file), m_pos(0), m_actually_close(do_close), m_filename(name) -{ - if (m_file == nullptr) - throw null_argument_e(m_filename); - init(); -} - -void pifilestream::init() -{ - if (ftell(static_cast(m_file)) >= 0) - { - if (fseek(static_cast(m_file), 0, SEEK_SET) >= 0) - set_flag(FLAG_SEEKABLE); - } -} - -pifilestream::~pifilestream() -{ - if (m_actually_close) - { - fclose(static_cast(m_file)); - } -} - -pifilestream::pos_type pifilestream::vread(char_type *buf, const pos_type n) -{ - pos_type r = fread(buf, 1, n, static_cast(m_file)); - if (r < n) - { - if (feof(static_cast(m_file))) - set_flag(FLAG_EOF); - if (ferror(static_cast(m_file))) - throw file_read_e(m_filename); - } - m_pos += r; - return r; -} - -void pifilestream::vseek(const pos_type n) -{ - if (fseek(static_cast(m_file), static_cast(n), SEEK_SET) < 0) - throw file_e("File seek failed: {}", m_filename); - else - m_pos = n; - if (feof(static_cast(m_file))) - set_flag(FLAG_EOF); - else - clear_flag(FLAG_EOF); - if (ferror(static_cast(m_file))) - throw file_e("Generic file operation failed: {}", m_filename); -} - -pifilestream::pos_type pifilestream::vtell() const -{ - long ret = ftell(static_cast(m_file)); - if (ret < 0) - { - return m_pos; - } - else - return static_cast(ret); -} - -// ----------------------------------------------------------------------------- -// pstdin: reads from stdin -// ----------------------------------------------------------------------------- - -pstdin::pstdin() -: pifilestream(stdin, "", false) -{ - /* nothing to do */ -} -#endif - -// ----------------------------------------------------------------------------- -// Output file stream -// ----------------------------------------------------------------------------- - -#if !USE_CSTREAM - -pofilestream::pofilestream(const pstring &fname) -: postream(0), m_file(fopen(fname.c_str(), "wb")), m_pos(0), m_actually_close(true), m_filename(fname) -{ - if (m_file == nullptr) - throw file_open_e(m_filename); - init(); -} - -pofilestream::pofilestream(void *file, const pstring &name, const bool do_close) -: postream(0), m_file(file), m_pos(0), m_actually_close(do_close), m_filename(name) -{ - if (m_file == nullptr) - throw null_argument_e(m_filename); - init(); -} - -void pofilestream::init() -{ - if (ftell(static_cast(m_file)) >= 0) - if (fseek(static_cast(m_file), 0, SEEK_SET) >= 0) - set_flag(FLAG_SEEKABLE); -} - -pofilestream::~pofilestream() -{ - if (m_actually_close) - { - fflush(static_cast(m_file)); - fclose(static_cast(m_file)); - } -} - -void pofilestream::vwrite(const char_type *buf, const pos_type n) -{ - std::size_t r = fwrite(buf, 1, n, static_cast(m_file)); - if (r < n) - { - if (ferror(static_cast(m_file))) - throw file_write_e(m_filename); - } - m_pos += r; -} - -void pofilestream::vseek(const pos_type n) -{ - if (fseek(static_cast(m_file), static_cast(n), SEEK_SET) < 0) - throw file_e("File seek failed: {}", m_filename); - else - { - m_pos = n; - if (ferror(static_cast(m_file))) - throw file_e("Generic file operation failed: {}", m_filename); - } -} - -pstream::pos_type pofilestream::vtell() const -{ - std::ptrdiff_t ret = ftell(static_cast(m_file)); - if (ret < 0) - { - return m_pos; - } - else - return static_cast(ret); -} - -// ----------------------------------------------------------------------------- -// Output memory stream -// ----------------------------------------------------------------------------- - -pomemstream::pomemstream() -: postream(FLAG_SEEKABLE), m_pos(0), m_mem(1024) -{ - m_mem.clear(); -} - -void pomemstream::vwrite(const char_type *buf, const pos_type n) -{ - if (m_pos + n >= m_mem.size()) - m_mem.resize(m_pos + n); - - std::copy(buf, buf + n, &m_mem[0] + m_pos); - m_pos += n; -} - -void pomemstream::vseek(const pos_type n) -{ - m_pos = n; - if (m_pos>=m_mem.size()) - m_mem.resize(m_pos); -} - -pstream::pos_type pomemstream::vtell() const -{ - return m_pos; -} - - -// ----------------------------------------------------------------------------- -// pstderr: write to stderr -// ----------------------------------------------------------------------------- - -pstderr::pstderr() -#ifdef _WIN32 -: pofilestream(fdopen(_dup(fileno(stderr)), "wb"), "", true) -#else -: pofilestream(fdopen(dup(fileno(stderr)), "wb"), "", true) -#endif -{ -} - -// ----------------------------------------------------------------------------- -// pstdout: write to stdout -// ----------------------------------------------------------------------------- - -pstdout::pstdout() -#ifdef _WIN32 -: pofilestream(fdopen(_dup(fileno(stdout)), "wb"), "", true) -#else -: pofilestream(fdopen(dup(fileno(stdout)), "wb"), "", true) -#endif -{ -} -#endif - -#if !USE_CSTREAM - -// ----------------------------------------------------------------------------- -// Memory stream -// ----------------------------------------------------------------------------- - -pimemstream::pimemstream(const void *mem, const pos_type len) - : pistream(FLAG_SEEKABLE), m_pos(0), m_len(len), m_mem(static_cast(mem)) -{ -} - -pimemstream::pimemstream() - : pistream(FLAG_SEEKABLE), m_pos(0), m_len(0), m_mem(static_cast(nullptr)) -{ -} -#if 0 -pimemstream::pimemstream(const pomemstream &ostrm) -: pistream(FLAG_SEEKABLE), m_pos(0), m_len(ostrm.size()), m_mem(reinterpret_cast(ostrm.memory())) -{ -} -#endif - -pimemstream::pos_type pimemstream::vread(char_type *buf, const pos_type n) -{ - pos_type ret = (m_pos + n <= m_len) ? n : m_len - m_pos; - - if (ret > 0) - { - std::copy(m_mem + m_pos, m_mem + m_pos + ret, reinterpret_cast(buf)); - m_pos += ret; - } - - if (ret < n) - set_flag(FLAG_EOF); - - return ret; -} - -void pimemstream::vseek(const pos_type n) -{ - m_pos = (n>=m_len) ? m_len : n; - clear_flag(FLAG_EOF); - -} - -pimemstream::pos_type pimemstream::vtell() const -{ - return m_pos; -} -#endif bool putf8_reader::readline(pstring &line) { diff --git a/src/lib/netlist/plib/pstream.h b/src/lib/netlist/plib/pstream.h index e8e47a4c623..ca21bca795a 100644 --- a/src/lib/netlist/plib/pstream.h +++ b/src/lib/netlist/plib/pstream.h @@ -14,441 +14,16 @@ #include "pfmtlog.h" #include "pstring.h" -#define USE_CSTREAM (0) - #include #include #include #include - -#if USE_CSTREAM #include -//#include #include #include -#endif namespace plib { -#if USE_CSTREAM -using postream = std::ostream; -using pofilestream = std::ofstream; -using postringstream = std::ostringstream; -using pomemstream = std::ostringstream; - -using pistream = std::istream; -using pifilestream = std::ifstream; -using pistringstream = std::istringstream; -using pimemstream = std::istringstream; - -#endif - -// ----------------------------------------------------------------------------- -// pstream: things common to all streams -// ----------------------------------------------------------------------------- - -class pstream -{ -public: - - using pos_type = std::streamsize; - using size_type = std::streamsize; - - static constexpr pos_type SEEK_EOF = static_cast(-1); - - COPYASSIGN(pstream, delete) - pstream &operator=(pstream &&) noexcept = delete; - - bool seekable() const { return ((m_flags & FLAG_SEEKABLE) != 0); } - - void seekp(const pos_type n) - { - vseek(n); - } - - pos_type tellp() const - { - return vtell(); - } - -protected: - pstream() : m_flags(0) - { - } - explicit pstream(const unsigned flags) : m_flags(flags) - { - } - pstream(pstream &&src) noexcept = default; - - virtual ~pstream() = default; - - virtual void vseek(const pos_type n) = 0; - virtual pos_type vtell() const = 0; - - static constexpr unsigned FLAG_EOF = 0x01; - static constexpr unsigned FLAG_SEEKABLE = 0x04; - - void set_flag(const unsigned flag) - { - m_flags |= flag; - } - void clear_flag(const unsigned flag) - { - m_flags &= ~flag; - } - unsigned flags() const { return m_flags; } -private: - - unsigned m_flags; -}; - -#if !USE_CSTREAM - -// ----------------------------------------------------------------------------- -// pistream: input stream -// ----------------------------------------------------------------------------- - -template -class pistream_base : public pstream -{ -public: - - using char_type = T; - - ~pistream_base() noexcept override = default; - - COPYASSIGN(pistream_base, delete) - pistream_base &operator=(pistream_base &&src) noexcept = delete; - - bool eof() const { return ((flags() & FLAG_EOF) != 0); } - - pos_type read(T *buf, const pos_type n) - { - return vread(buf, n); - } - -protected: - pistream_base() : pstream(0) {} - explicit pistream_base(const unsigned flags) : pstream(flags) {} - pistream_base(pistream_base &&src) noexcept : pstream(std::move(src)) {} - - /* read up to n bytes from stream */ - virtual size_type vread(T *buf, const size_type n) = 0; -}; - -using pistream = pistream_base; - -// ----------------------------------------------------------------------------- -// postream: output stream -// ----------------------------------------------------------------------------- - -template -class postream_base : public pstream -{ -public: - - using char_type = T; - - postream_base() = default; - ~postream_base() noexcept override = default; - - COPYASSIGN(postream_base, delete) - postream_base &operator=(postream_base &&src) noexcept = delete; - - void write(const T *buf, const size_type n) - { - vwrite(buf, n); - } - - void write_c_str(const T *buf) - { - size_type n(0); - while (buf[n]) - n++; - vwrite(buf, n); - } - -protected: - explicit postream_base(unsigned flags) : pstream(flags) {} - postream_base(postream_base &&src) noexcept : pstream(std::move(src)) {} - - /* write n bytes to stream */ - virtual void vwrite(const T *buf, const size_type n) = 0; - -private: -}; - -using postream = postream_base; - -// ----------------------------------------------------------------------------- -// pomemstream: output string stream -// ----------------------------------------------------------------------------- - -class pomemstream : public postream -{ -public: - - pomemstream(); - - COPYASSIGN(pomemstream, delete) - - pomemstream(pomemstream &&src) noexcept - : postream(std::move(src)) - , m_pos(src.m_pos) - , m_mem(std::move(src.m_mem)) - { - } - pomemstream &operator=(pomemstream &&src) = delete; - - ~pomemstream() override = default; - - const char *memory() const { return m_mem.data(); } - pos_type size() const { return static_cast(m_mem.size()); } - -protected: - /* write n bytes to stream */ - void vwrite(const char_type *buf, const pos_type) override; - void vseek(const pos_type n) override; - pos_type vtell() const override; - -private: - pos_type m_pos; - std::vector m_mem; -}; - -class postringstream : public postream -{ -public: - - postringstream() : postream(0) { } - postringstream(postringstream &&src) noexcept - : postream(std::move(src)) - , m_buf(std::move(src.m_buf)) - { src.m_buf = ""; } - - COPYASSIGN(postringstream, delete) - postringstream &operator=(postringstream &&src) = delete; - - ~postringstream() override = default; - - const pstring &str() { return m_buf; } - -protected: - /* write n bytes to stream */ - void vwrite(const char_type *buf, const pos_type n) override - { - //m_buf += pstring(reinterpret_cast(buf), n); - m_buf += pstring(buf, static_cast(n)); - } - void vseek(const pos_type n) override { unused_var(n); } - pos_type vtell() const override { return static_cast(m_buf.size()); } - -private: - pstring m_buf; -}; - -// ----------------------------------------------------------------------------- -// pofilestream: file output stream -// ----------------------------------------------------------------------------- - -class pofilestream : public postream -{ -public: - - pofilestream(const pstring &fname); - pofilestream(pofilestream &&src) noexcept - : postream(std::move(src)) - , m_file(src.m_file) - , m_pos(src.m_pos) - , m_actually_close(src.m_actually_close) - , m_filename(std::move(src.m_filename)) - { - src.m_file = nullptr; - src.m_actually_close = false; - } - COPYASSIGN(pofilestream, delete) - pofilestream &operator=(pofilestream &&src) = delete; - - ~pofilestream() override; - -protected: - pofilestream(void *file, const pstring &name, const bool do_close); - /* write n bytes to stream */ - void vwrite(const char_type *buf, const pos_type n) override; - void vseek(const pos_type n) override; - pos_type vtell() const override; - -private: - void *m_file; - pos_type m_pos; - bool m_actually_close; - pstring m_filename; - - void init(); -}; - -// ----------------------------------------------------------------------------- -// pstderr: write to stderr -// ----------------------------------------------------------------------------- - -class pstderr : public pofilestream -{ -public: - pstderr(); - pstderr(pstderr &&src) noexcept = default; - pstderr &operator=(pstderr &&src) = delete; - COPYASSIGN(pstderr, delete) - - ~pstderr() noexcept override= default; -}; - -// ----------------------------------------------------------------------------- -// pstdout: write to stdout -// ----------------------------------------------------------------------------- - -class pstdout : public pofilestream -{ -public: - pstdout(); - pstdout(pstdout &&src) noexcept = default; - pstdout &operator=(pstdout &&src) = delete; - COPYASSIGN(pstdout, delete) - - ~pstdout() noexcept override = default; -}; - - -// ----------------------------------------------------------------------------- -// pifilestream: file input stream -// ----------------------------------------------------------------------------- - -class pifilestream : public pistream -{ -public: - - pifilestream(const pstring &fname); - ~pifilestream() override; - - pifilestream(pifilestream &&src) noexcept - : pistream(std::move(src)) - , m_file(src.m_file) - , m_pos(src.m_pos) - , m_actually_close(src.m_actually_close) - , m_filename(std::move(src.m_filename)) - { - src.m_actually_close = false; - src.m_file = nullptr; - } - COPYASSIGN(pifilestream, delete) - pifilestream &operator=(pifilestream &&src) = delete; - -protected: - pifilestream(void *file, const pstring &name, const bool do_close); - - /* read up to n bytes from stream */ - pos_type vread(char_type *buf, const pos_type n) override; - void vseek(const pos_type n) override; - pos_type vtell() const override; - -private: - void *m_file; - pos_type m_pos; - bool m_actually_close; - pstring m_filename; - - void init(); -}; - -// ----------------------------------------------------------------------------- -// pstdin: reads from stdin -// ----------------------------------------------------------------------------- - -class pstdin : public pifilestream -{ -public: - - pstdin(); - pstdin(pstdin &&src) noexcept = default; - pstdin &operator=(pstdin &&src) = delete; - COPYASSIGN(pstdin, delete) - ~pstdin() override = default; -}; - -// ----------------------------------------------------------------------------- -// pimemstream: input memory stream -// ----------------------------------------------------------------------------- - -class pimemstream : public pistream -{ -public: - - pimemstream(const void *mem, const pos_type len); - pimemstream(); - - pimemstream(pimemstream &&src) noexcept - : pistream(std::move(src)) - , m_pos(src.m_pos) - , m_len(src.m_len) - , m_mem(src.m_mem) - { - src.m_mem = nullptr; - } - COPYASSIGN(pimemstream, delete) - pimemstream &operator=(pimemstream &&src) = delete; - - //explicit pimemstream(const pomemstream &ostrm); - - ~pimemstream() override = default; - - pos_type size() const { return m_len; } -protected: - - void set_mem(const void *mem, const pos_type len) - { - m_mem = static_cast(mem); - m_len = len; - } - - /* read up to n bytes from stream */ - pos_type vread(char_type *buf, const pos_type n) override; - void vseek(const pos_type n) override; - pos_type vtell() const override; - -private: - pos_type m_pos; - pos_type m_len; - const char *m_mem; -}; - -// ----------------------------------------------------------------------------- -// pistringstream: input string stream -// ----------------------------------------------------------------------------- - -class pistringstream : public pimemstream -{ -public: - pistringstream(const pstring &str) - : pimemstream() - , m_str(str) - { - set_mem(m_str.c_str(), static_cast(pstring_mem_t_size(m_str))); - } - pistringstream(pistringstream &&src) noexcept - : pimemstream(std::move(src)), m_str(src.m_str) - { - set_mem(m_str.c_str(), static_cast(pstring_mem_t_size(m_str))); - } - COPYASSIGN(pistringstream, delete) - pistringstream &operator=(pistringstream &&src) = delete; - - ~pistringstream() override = default; - -private: - /* only needed for a reference till destruction */ - const pstring m_str; -}; -#endif - // ----------------------------------------------------------------------------- // putf8reader_t: reader on top of istream // ----------------------------------------------------------------------------- @@ -459,7 +34,7 @@ private: template struct constructor_helper { - plib::unique_ptr operator()(T &&s) { return std::move(plib::make_unique(std::move(s))); } + plib::unique_ptr operator()(T &&s) { return std::move(plib::make_unique(std::move(s))); } }; // NOLINTNEXTLINE(cppcoreguidelines-special-member-functions) @@ -482,27 +57,7 @@ public: bool eof() const { return m_strm->eof(); } bool readline(pstring &line); - -#if !USE_CSTREAM - bool readbyte1(pistream::char_type &b) - { - return (m_strm->read(&b, 1) == 1); - } - - bool readcode(putf8string::traits_type::code_t &c) - { - std::array b{0}; - if (m_strm->read(&b[0], 1) != 1) - return false; - const std::size_t l = putf8string::traits_type::codelen(reinterpret_cast(&b)); - for (std::size_t i = 1; i < l; i++) - if (m_strm->read(&b[i], 1) != 1) - return false; - c = putf8string::traits_type::code(reinterpret_cast(&b)); - return true; - } -#else - bool readbyte1(pistream::char_type &b) + bool readbyte1(std::istream::char_type &b) { if (m_strm->eof()) return false; @@ -511,7 +66,7 @@ public: } bool readcode(putf8string::traits_type::code_t &c) { - std::array b{0}; + std::array b{0}; if (m_strm->eof()) return false; m_strm->read(&b[0], 1); @@ -526,22 +81,22 @@ public: return true; } -#endif + std::istream &stream() { return *m_strm; } private: - plib::unique_ptr m_strm; + plib::unique_ptr m_strm; putf8string m_linebuf; }; template <> struct constructor_helper { - plib::unique_ptr operator()(putf8_reader &&s) { return std::move(s.m_strm); } + plib::unique_ptr operator()(putf8_reader &&s) { return std::move(s.m_strm); } }; template <> -struct constructor_helper> +struct constructor_helper> { - plib::unique_ptr operator()(plib::unique_ptr &&s) { return std::move(s); } + plib::unique_ptr operator()(plib::unique_ptr &&s) { return std::move(s); } }; @@ -552,7 +107,7 @@ struct constructor_helper> class putf8_writer { public: - explicit putf8_writer(postream *strm) : m_strm(strm) {} + explicit putf8_writer(std::ostream *strm) : m_strm(strm) {} putf8_writer(putf8_writer &&src) noexcept : m_strm(src.m_strm) {} @@ -581,14 +136,14 @@ public: } private: - postream *m_strm; + std::ostream *m_strm; }; class putf8_fmt_writer : public pfmt_writer_t, public putf8_writer { public: - explicit putf8_fmt_writer(postream *strm) + explicit putf8_fmt_writer(std::ostream *strm) : pfmt_writer_t() , putf8_writer(strm) { @@ -611,23 +166,23 @@ private: class pbinary_writer { public: - explicit pbinary_writer(postream &strm) : m_strm(strm) {} + explicit pbinary_writer(std::ostream &strm) : m_strm(strm) {} pbinary_writer(pbinary_writer &&src) noexcept : m_strm(src.m_strm) {} COPYASSIGN(pbinary_writer, delete) - postringstream &operator=(pbinary_writer &&src) = delete; + pbinary_writer &operator=(pbinary_writer &&src) = delete; virtual ~pbinary_writer() = default; template void write(const T &val) { - m_strm.write(reinterpret_cast(&val), sizeof(T)); + m_strm.write(reinterpret_cast(&val), sizeof(T)); } void write(const pstring &s) { - const auto sm = reinterpret_cast(s.c_str()); + const auto sm = reinterpret_cast(s.c_str()); const std::streamsize sl(static_cast(pstring_mem_t_size(s))); write(sl); m_strm.write(sm, sl); @@ -638,17 +193,17 @@ public: { const std::streamsize sz(static_cast(val.size())); write(sz); - m_strm.write(reinterpret_cast(val.data()), sz * static_cast(sizeof(T))); + m_strm.write(reinterpret_cast(val.data()), sz * static_cast(sizeof(T))); } private: - postream &m_strm; + std::ostream &m_strm; }; class pbinary_reader { public: - explicit pbinary_reader(pistream &strm) : m_strm(strm) {} + explicit pbinary_reader(std::istream &strm) : m_strm(strm) {} pbinary_reader(pbinary_reader &&src) noexcept : m_strm(src.m_strm) { } COPYASSIGN(pbinary_reader, delete) @@ -659,7 +214,7 @@ public: template void read(T &val) { - m_strm.read(reinterpret_cast(&val), sizeof(T)); + m_strm.read(reinterpret_cast(&val), sizeof(T)); } void read( pstring &s) @@ -678,29 +233,22 @@ public: std::size_t sz = 0; read(sz); val.resize(sz); - m_strm.read(reinterpret_cast(val.data()), static_cast(sizeof(T) * sz)); + m_strm.read(reinterpret_cast(val.data()), static_cast(sizeof(T) * sz)); } private: - pistream &m_strm; + std::istream &m_strm; }; -inline void copystream(postream &dest, pistream &src) +inline void copystream(std::ostream &dest, std::istream &src) { // FIXME: optimize -#if !USE_CSTREAM - std::array buf; // NOLINT(cppcoreguidelines-pro-type-member-init) - pstream::pos_type r; - while ((r=src.read(buf.data(), 1024)) > 0) - dest.write(buf.data(), r); -#else - std::array buf; // NOLINT(cppcoreguidelines-pro-type-member-init) + std::array buf; // NOLINT(cppcoreguidelines-pro-type-member-init) while (!src.eof()) { src.read(buf.data(), 1); dest.write(buf.data(), 1); } -#endif } struct perrlogger @@ -713,16 +261,24 @@ struct perrlogger private: static putf8_fmt_writer &h() { -#if !USE_CSTREAM - static plib::pstderr perr_strm; - static plib::putf8_fmt_writer perr(&perr_strm); -#else static plib::putf8_fmt_writer perr(&std::cerr); -#endif return perr; } }; +// ----------------------------------------------------------------------------- +// c++17 preparation +// ----------------------------------------------------------------------------- + +namespace filesystem +{ + template< class Source > + pstring /*path */ u8path( const Source& source ) + { + return pstring(source); + } + +} } // namespace plib diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp index 990ad0a9537..5be3a30a8a1 100644 --- a/src/lib/netlist/prg/nltool.cpp +++ b/src/lib/netlist/prg/nltool.cpp @@ -11,6 +11,7 @@ #include "netlist/plib/pmain.h" #include "netlist/devices/net_lib.h" #include "netlist/nl_parser.h" +#include "netlist/nl_errstr.h" #include "netlist/nl_setup.h" #include "netlist/solver/nld_solver.h" #include "netlist/tools/nl_convert.h" @@ -18,6 +19,7 @@ #include // scanf #include // scanf #include // scanf +#include #define NLTOOL_VERSION 20190420 @@ -137,20 +139,17 @@ public: { } - plib::unique_ptr stream(const pstring &file) override + plib::unique_ptr stream(const pstring &file) override { pstring name = m_folder + "/" + file; - try + auto strm(plib::make_unique(plib::filesystem::u8path(name))); + if (strm->fail()) + return plib::unique_ptr(nullptr); + else { - auto strm = plib::make_unique(name); + strm->imbue(std::locale::classic()); return std::move(strm); } - catch (const plib::pexception &e) - { - if (dynamic_cast(&e) == nullptr ) - throw; - } - return plib::unique_ptr(nullptr); } private: @@ -330,7 +329,10 @@ static std::vector read_input(const netlist::setup_t &setup, const pstr std::vector ret; if (fname != "") { - plib::putf8_reader r = plib::putf8_reader(plib::pifilestream(fname)); + plib::putf8_reader r = plib::putf8_reader(std::ifstream(plib::filesystem::u8path(fname))); + if (r.stream().fail()) + throw netlist::nl_exception(netlist::MF_FILE_OPEN_ERROR(fname)); + r.stream().imbue(std::locale::classic()); pstring l; while (r.readline(l)) { @@ -385,7 +387,10 @@ void tool_app_t::run() // FIXME: error handling if (opt_loadstate.was_specified()) { - plib::pifilestream strm(opt_loadstate()); + std::ifstream strm(plib::filesystem::u8path(opt_loadstate())); + if (strm.fail()) + throw netlist::nl_exception(netlist::MF_FILE_OPEN_ERROR(opt_loadstate())); + strm.imbue(std::locale::classic()); plib::pbinary_reader reader(strm); std::vector loadstate; reader.read(loadstate); @@ -420,7 +425,11 @@ void tool_app_t::run() if (opt_savestate.was_specified()) { auto savestate = nt.save_state(); - plib::pofilestream strm(opt_savestate()); + std::ofstream strm(plib::filesystem::u8path(opt_savestate()), std::ios_base::binary); + if (strm.fail()) + throw plib::file_open_e(opt_savestate()); + strm.imbue(std::locale::classic()); + plib::pbinary_writer writer(strm); writer.write(savestate); } @@ -728,20 +737,19 @@ void tool_app_t::listdevices() void tool_app_t::convert() { pstring contents; - plib::postringstream ostrm; + std::stringstream ostrm; + ostrm.imbue(std::locale::classic()); if (opt_file() == "-") { -#if !USE_CSTREAM - plib::pstdin f; - plib::copystream(ostrm, f); -#else plib::copystream(ostrm, std::cin); -#endif } else { - plib::pifilestream f(opt_file()); - plib::copystream(ostrm, f); + std::ifstream strm(plib::filesystem::u8path(opt_file())); + if (strm.fail()) + throw netlist::nl_exception(netlist::MF_FILE_OPEN_ERROR(opt_file())); + strm.imbue(std::locale::classic()); + plib::copystream(ostrm, strm); } contents = pstring(ostrm.str()); @@ -874,6 +882,8 @@ int tool_app_t::execute() std::cout << plib::pfmt("{:20}")("Общая ком") << "|" << "\n"; //char x = 'a'; + //auto b= U'щ'; + auto b= U'\U00000449'; std::cout << "b: <" << b << ">"; #endif diff --git a/src/lib/netlist/prg/nlwav.cpp b/src/lib/netlist/prg/nlwav.cpp index 86c7dbe1690..3974dde1f3a 100644 --- a/src/lib/netlist/prg/nlwav.cpp +++ b/src/lib/netlist/prg/nlwav.cpp @@ -24,7 +24,7 @@ class wav_t { public: // XXNOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init) - wav_t(plib::postream &strm, bool is_seekable, std::size_t sr, std::size_t channels) + wav_t(std::ostream &strm, bool is_seekable, std::size_t sr, std::size_t channels) : m_f(strm) , m_stream_is_seekable(is_seekable) /* force "play" to play and warn about eof instead of being silent */ @@ -59,7 +59,7 @@ public: template void write(const T &val) { - m_f.write(reinterpret_cast(&val), sizeof(T)); + m_f.write(reinterpret_cast(&val), sizeof(T)); } void write_sample(int *sample) @@ -107,7 +107,7 @@ private: // data follows }; - plib::postream &m_f; + std::ostream &m_f; bool m_stream_is_seekable; riff_chunk_t m_fh; @@ -157,7 +157,7 @@ public: return success; } - void process(std::vector> &is) + void process(std::vector> &is) { std::vector readers; for (auto &i : is) @@ -240,7 +240,7 @@ private: class wavwriter { public: - wavwriter(plib::postream &fo, bool is_seekable, std::size_t channels, std::size_t sample_rate, double ampa) + wavwriter(std::ostream &fo, bool is_seekable, std::size_t channels, std::size_t sample_rate, double ampa) : mean(channels, 0.0) , means(channels, 0.0) , maxsam(channels, -1e9) @@ -281,7 +281,7 @@ public: private: - plib::postream &m_fo; + std::ostream &m_fo; double m_amp; wav_t m_wo; }; @@ -296,7 +296,7 @@ public: ANALOG }; - vcdwriter(plib::postream &fo, const std::vector &channels, + vcdwriter(std::ostream &fo, const std::vector &channels, format_e format, double high_level = 2.0, double low_level = 1.0) : m_channels(channels.size()) , m_last_time(0) @@ -363,7 +363,7 @@ private: std::size_t m_channels; double m_last_time; - plib::postream &m_fo; + std::ostream &m_fo; std::vector m_ids; pstring m_buf; double m_high_level; @@ -420,11 +420,8 @@ private: plib::option_bool opt_help; plib::option_example opt_ex1; plib::option_example opt_ex2; -#if !USE_CSTREAM - plib::pstdin pin_strm; -#endif - std::vector> m_instrms; - plib::postream *m_outstrm; + std::vector> m_instrms; + std::ostream *m_outstrm; }; void nlwav_app::convert_wav() @@ -502,22 +499,24 @@ int nlwav_app::execute() return 0; } -#if !USE_CSTREAM - m_outstrm = (opt_out() == "-" ? &pout_strm : plib::pnew(opt_out())); -#else - m_outstrm = (opt_out() == "-" ? &std::cout : plib::pnew(opt_out())); -#endif + m_outstrm = (opt_out() == "-" ? &std::cout : plib::pnew(plib::filesystem::u8path(opt_out()))); + if (m_outstrm->fail()) + throw plib::file_open_e(opt_out()); + m_outstrm->imbue(std::locale::classic()); for (auto &oi: opt_args()) { -#if !USE_CSTREAM - plib::unique_ptr fin = (oi == "-" ? - plib::make_unique() - : plib::make_unique(oi)); -#else - //FIXME: - plib::unique_ptr fin = plib::make_unique(oi); -#endif + plib::unique_ptr fin; + + if (oi == "-") + { + auto temp(plib::make_unique()); + plib::copystream(*temp, std::cin); + fin = std::move(temp); + } + else + fin = plib::make_unique(plib::filesystem::u8path(oi)); + fin->imbue(std::locale::classic()); m_instrms.push_back(std::move(fin)); } diff --git a/src/lib/netlist/solver/nld_ms_gcr.h b/src/lib/netlist/solver/nld_ms_gcr.h index 777d5c25267..e227802c1a2 100644 --- a/src/lib/netlist/solver/nld_ms_gcr.h +++ b/src/lib/netlist/solver/nld_ms_gcr.h @@ -262,7 +262,8 @@ namespace devices template pstring matrix_solver_GCR_t::static_compile_name() { - plib::postringstream t; + std::stringstream t; + t.imbue(std::locale::classic()); plib::putf8_fmt_writer w(&t); csc_private(w); std::hash::type>::type> h; @@ -273,7 +274,8 @@ namespace devices template std::pair matrix_solver_GCR_t::create_solver_code() { - plib::postringstream t; + std::stringstream t; + t.imbue(std::locale::classic()); plib::putf8_fmt_writer strm(&t); pstring name = static_compile_name(); @@ -281,7 +283,7 @@ namespace devices strm.writeline("{\n"); csc_private(strm); strm.writeline("}\n"); - return std::pair(name, t.str()); + return std::pair(name, pstring(t.str())); } template diff --git a/src/lib/netlist/tools/nl_convert.cpp b/src/lib/netlist/tools/nl_convert.cpp index ab376b9bcf0..3e705910bf4 100644 --- a/src/lib/netlist/tools/nl_convert.cpp +++ b/src/lib/netlist/tools/nl_convert.cpp @@ -43,7 +43,8 @@ using lib_map_t = std::unordered_map; static lib_map_t read_lib_map(const pstring &lm) { - auto reader = plib::putf8_reader(plib::pistringstream(lm)); + auto reader = plib::putf8_reader(std::istringstream(lm)); + reader.stream().imbue(std::locale::classic()); lib_map_t m; pstring line; while (reader.readline(line)) @@ -62,6 +63,7 @@ nl_convert_base_t::nl_convert_base_t() : out(&m_buf) , m_numberchars("0123456789-+e.") { + m_buf.imbue(std::locale::classic()); m_units = { {"T", "", 1.0e12 }, {"G", "", 1.0e9 }, @@ -484,7 +486,8 @@ void nl_convert_eagle_t::tokenizer::verror(const pstring &msg, int line_num, con void nl_convert_eagle_t::convert(const pstring &contents) { - tokenizer tok(*this, plib::putf8_reader(plib::pistringstream(contents))); + tokenizer tok(*this, plib::putf8_reader(std::istringstream(contents))); + tok.stream().stream().imbue(std::locale::classic()); out("NETLIST_START(dummy)\n"); add_term("GND", "GND"); @@ -631,7 +634,8 @@ void nl_convert_rinf_t::tokenizer::verror(const pstring &msg, int line_num, cons void nl_convert_rinf_t::convert(const pstring &contents) { - tokenizer tok(*this, plib::putf8_reader(plib::pistringstream(contents))); + tokenizer tok(*this, plib::putf8_reader(std::istringstream(contents))); + tok.stream().stream().imbue(std::locale::classic()); auto lm = read_lib_map(s_lib_map); out("NETLIST_START(dummy)\n"); diff --git a/src/lib/netlist/tools/nl_convert.h b/src/lib/netlist/tools/nl_convert.h index f5ae867d68a..e070514d5ed 100644 --- a/src/lib/netlist/tools/nl_convert.h +++ b/src/lib/netlist/tools/nl_convert.h @@ -139,7 +139,7 @@ private: void add_device(plib::unique_ptr dev); - plib::postringstream m_buf; + std::stringstream m_buf; std::vector> m_devs; std::unordered_map > m_nets;