Move from <cstring> to std::copy and friends. (nw)

src/lib/netlist/plib/pfmtlog.cpp

@@ -13,6 +13,8 @@
 #include <cstdarg>
 #include <algorithm>
 
+//* FIXME: remove cstring, replace with pstring */
+
 namespace plib {
 
 plog_dispatch_intf::~plog_dispatch_intf()
@@ -28,7 +30,7 @@ pfmt::pfmt(const pstring fmt)
 		m_allocated = 2 * l;
 		m_str = palloc_array<char>(2 * l);
 	}
-	memcpy(m_str, fmt.c_str(), l);
+	std::copy(fmt.c_str(), fmt.c_str() + l, m_str);
 }
 
 pfmt::~pfmt()
@@ -116,15 +118,16 @@ void pfmt::format_element(const char *f, const char *l, const char *fmt_spec,  .
 			while (new_size > m_allocated)
 				m_allocated *= 2;
 			char *np = palloc_array<char>(m_allocated);
-			memcpy(np, m_str, old_alloc);
+			std::copy(m_str, m_str + old_alloc, np);
 			p = np + (p - m_str);
 			if (m_str != m_str_buf)
 				pfree_array(m_str);
 			m_str = np;
 		}
 		// Make room
-		memmove(p+nl, p+sl, strlen(p) + 1 - sl);
+		//memmove(p+nl, p+sl, strlen(p) + 1 - sl);
-		memcpy(p, buf, nl);
+		std::copy_backward(p + sl, p + strlen(p) + 1, p + nl + strlen(p) + 1 - sl);
+		std::copy(buf, buf + nl, p);
 	}
 	va_end(ap);
 }

src/lib/netlist/plib/pstream.cpp

@@ -9,7 +9,6 @@
 #include "palloc.h"
 
 #include <cstdio>
-#include <cstring>
 #include <cstdlib>
 #include <algorithm>
 
@@ -278,7 +277,7 @@ pimemstream::pos_type pimemstream::vread(void *buf, const pos_type n)
 
 	if (ret > 0)
 	{
-		memcpy(buf, m_mem + m_pos, ret);
+		std::copy(m_mem + m_pos, m_mem + m_pos + ret, (char *) buf);
 		m_pos += ret;
 	}
 
@@ -331,11 +330,11 @@ void pomemstream::vwrite(const void *buf, const pos_type n)
 		{
 			throw out_of_mem_e("pomemstream::vwrite");
 		}
-		memcpy(m_mem, o, m_pos);
+		std::copy(o, o + m_pos, m_mem);
 		pfree_array(o);
 	}
 
-	memcpy(m_mem + m_pos, buf, n);
+	std::copy((char *) buf, (char *) buf + n, m_mem + m_pos);
 	m_pos += n;
 	m_size = std::max(m_pos, m_size);
 }
@@ -354,7 +353,7 @@ void pomemstream::vseek(const pos_type n)
 		{
 			throw out_of_mem_e("pomemstream::vseek");
 		}
-		memcpy(m_mem, o, m_pos);
+		std::copy(o, o + m_pos, m_mem);
 		pfree_array(o);
 	}
 }

src/lib/netlist/plib/pstring.cpp

@@ -9,7 +9,6 @@
 #include "palloc.h"
 #include "plists.h"
 
-#include <cstring>
 #include <algorithm>
 #include <stack>
 #include <cstdlib>
@@ -23,15 +22,25 @@ pstring_t<F>::~pstring_t()
 		sfree(m_ptr);
 }
 
+template <typename T>
+std::size_t strlen_mem(const T *s)
+{
+	std::size_t len(0);
+	while (*s++)
+		++len;
+	return len;
+}
+
+
 template<typename F>
 void pstring_t<F>::pcat(const mem_t *s)
 {
-	std::size_t slen = strlen(s);
+	std::size_t slen = strlen_mem(s);
 	pstr_t *n = salloc(m_ptr->len() + slen);
 	if (m_ptr->len() > 0)
-		std::memcpy(n->str(), m_ptr->str(), m_ptr->len());
+		n->copy_from(m_ptr->str(), m_ptr->len());
 	if (slen > 0)
-		std::memcpy(n->str() + m_ptr->len(), s, slen);
+		std::copy(s, s + slen, n->str() + m_ptr->len());
 	*(n->str() + n->len()) = 0;
 	sfree(m_ptr);
 	m_ptr = n;
@@ -43,9 +52,9 @@ void pstring_t<F>::pcat(const pstring_t &s)
 	std::size_t slen = s.blen();
 	pstr_t *n = salloc(m_ptr->len() + slen);
 	if (m_ptr->len() > 0)
-		std::memcpy(n->str(), m_ptr->str(), m_ptr->len());
+		n->copy_from(m_ptr->str(), m_ptr->len());
 	if (slen > 0)
-		std::memcpy(n->str() + m_ptr->len(), s.c_str(), slen);
+		std::copy(s.c_str(), s.c_str() + slen, n->str() + m_ptr->len());
 	*(n->str() + n->len()) = 0;
 	sfree(m_ptr);
 	m_ptr = n;
@@ -64,7 +73,14 @@ int pstring_t<F>::pcmp(const pstring_t &right) const
 		else
 			return -1;
 	}
-	int ret = memcmp(m_ptr->str(), right.c_str(), l);
+	auto si = this->begin();
+	auto ri = right.begin();
+	while (si != this->end() && *si == *ri)
+	{
+		ri++;
+		si++;
+	}
+	int ret = (si == this->end() ? 0 : *si - *ri);
 	if (ret == 0)
 	{
 		if (this->blen() > right.blen())
@@ -79,10 +95,10 @@ int pstring_t<F>::pcmp(const pstring_t &right) const
 template<typename F>
 void pstring_t<F>::pcopy(const mem_t *from, std::size_t size)
 {
-	pstr_t *n = salloc(size);
+	pstr_t *n = salloc(size * sizeof(mem_t));
 	if (size > 0)
-		std::memcpy(n->str(), from, size);
+		n->copy_from((char *)from, size);
-	*(n->str() + size) = 0;
+	*((mem_t *) n->str() + size) = 0;
 	sfree(m_ptr);
 	m_ptr = n;
 }
@@ -228,7 +244,7 @@ const pstring_t<F> pstring_t<F>::rpad(const pstring_t &ws, const size_type cnt)
 template<typename F>
 void pstring_t<F>::pcopy(const mem_t *from)
 {
-	pcopy(from, strlen(from));
+	pcopy(from, strlen_mem(from));
 }
 
 template<typename F>
@@ -270,7 +286,7 @@ bool pstring_t<F>::startsWith(const pstring_t &arg) const
 	if (arg.blen() > blen())
 		return false;
 	else
-		return (memcmp(arg.c_str(), c_str(), arg.blen()) == 0);
+		return std::equal(arg.c_str(), arg.c_str() + arg.blen(), c_str());
 }
 
 template<typename F>
@@ -279,13 +295,7 @@ bool pstring_t<F>::endsWith(const pstring_t &arg) const
 	if (arg.blen() > blen())
 		return false;
 	else
-		return (memcmp(c_str()+this->blen()-arg.blen(), arg.c_str(), arg.blen()) == 0);
+		return std::equal(arg.c_str(), arg.c_str() + arg.blen(), c_str()+this->blen()-arg.blen());
-}
-
-template<typename F>
-int pstring_t<F>::pcmp(const mem_t *right) const
-{
-	return std::strcmp(m_ptr->str(), right);
 }
 
 // ----------------------------------------------------------------------------------------
@@ -314,7 +324,7 @@ void pstringbuffer::resize(const std::size_t size)
 		while (m_size < size)
 			m_size *= 2;
 		char *new_buf = plib::palloc_array<char>(m_size);
-		std::memcpy(new_buf, m_ptr, m_len + 1);
+		std::copy(m_ptr, m_ptr + m_len + 1, new_buf);
 		plib::pfree_array(m_ptr);
 		m_ptr = new_buf;
 	}
@@ -322,24 +332,24 @@ void pstringbuffer::resize(const std::size_t size)
 
 void pstringbuffer::pcopy(const char *from)
 {
-	std::size_t nl = strlen(from) + 1;
+	std::size_t nl = strlen_mem(from) + 1;
 	resize(nl);
-	std::memcpy(m_ptr, from, nl);
+	std::copy(from, from + nl, m_ptr);
 }
 
 void pstringbuffer::pcopy(const pstring &from)
 {
 	std::size_t nl = from.blen() + 1;
 	resize(nl);
-	std::memcpy(m_ptr, from.c_str(), nl);
+	std::copy(from.c_str(), from.c_str() + nl, m_ptr);
 }
 
 void pstringbuffer::pcat(const char *s)
 {
-	const std::size_t slen = std::strlen(s);
+	const std::size_t slen = strlen_mem(s);
 	const std::size_t nl = m_len + slen + 1;
 	resize(nl);
-	std::memcpy(m_ptr + m_len, s, slen + 1);
+	std::copy(s, s + slen + 1, m_ptr + m_len);
 	m_len += slen;
 }
 
@@ -347,7 +357,7 @@ void pstringbuffer::pcat(const void *m, std::size_t l)
 {
 	const std::size_t nl = m_len + l + 1;
 	resize(nl);
-	std::memcpy(m_ptr + m_len, m, l);
+	std::copy((char *) m, (char *) m + l, m_ptr + m_len);
 	m_len += l;
 	*(m_ptr + m_len) = 0;
 }
@@ -357,7 +367,7 @@ void pstringbuffer::pcat(const pstring &s)
 	const std::size_t slen = s.blen();
 	const std::size_t nl = m_len + slen + 1;
 	resize(nl);
-	std::memcpy(m_ptr + m_len, s.c_str(), slen);
+	std::copy(s.c_str(), s.c_str() + slen, m_ptr + m_len);
 	m_len += slen;
 	m_ptr[m_len] = 0;
 }

src/lib/netlist/plib/pstring.h

@@ -31,6 +31,7 @@ struct pstr_t
 	std::size_t len() const  { return m_len; }
 	void inc() { m_ref_count++; }
 	bool dec_and_check() { --m_ref_count; return m_ref_count == 0; }
+	void copy_from(char *p, std::size_t n) { std::copy(p, p + n, str()); }
 private:
 	int m_ref_count;
 	std::size_t m_len;
@@ -185,8 +186,6 @@ private:
 
 	int pcmp(const pstring_t &right) const;
 
-	int pcmp(const mem_t *right) const;
-
 	void pcopy(const mem_t *from, std::size_t size);
 
 	void pcopy(const mem_t *from);

src/lib/netlist/plib/putil.cpp

@@ -5,10 +5,10 @@
 #include "ptypes.h"
 #include "plists.h"
 
-#include <cstring>
 #include <cstdlib>
 #include <algorithm>
 #include <initializer_list>
+#include <cstring>
 
 namespace plib
 {
@@ -75,7 +75,7 @@ namespace plib
 			std::size_t p = static_cast<std::size_t>(-1);
 			for (std::size_t j=0; j < onstrl.size(); j++)
 			{
-				if (std::memcmp(onstrl[j].c_str(), &(str.c_str()[i]), onstrl[j].blen())==0)
+				if (std::equal(onstrl[j].c_str(), onstrl[j].c_str() + onstrl[j].blen(), &(str.c_str()[i])))
 				{
 					p = j;
 					break;

src/lib/netlist/prg/nltool.cpp

@@ -183,49 +183,47 @@ public:
 		}
 	}
 
-	template<typename T>
+	std::vector<char> save_state()
-	std::vector<T> save_state()
 	{
 		state().pre_save();
 		std::size_t size = 0;
 		for (auto const & s : state().save_list())
-			size += ((s->m_dt.size * s->m_count + sizeof(T) - 1) / sizeof(T));
+			size += s->m_dt.size * s->m_count;
 
-		auto buf = std::vector<T>(size);
+		std::vector<char> buf(size);
-		auto p = buf.data();
+		char *p = buf.data();
 
 		for (auto const & s : state().save_list())
 		{
 			std::size_t sz = s->m_dt.size * s->m_count;
 			if (s->m_dt.is_float || s->m_dt.is_integral)
-				std::memcpy(p, s->m_ptr, sz );
+				std::copy((char *)s->m_ptr, (char *) s->m_ptr + sz, p);
 			else
 				log().fatal("found unsupported save element {1}\n", s->m_name);
-			p += ((sz + sizeof(T) - 1) / sizeof(T));
+			p += sz;
 		}
 		return buf;
 	}
 
-	template<typename T>
+	void load_state(std::vector<char> &buf)
-	void load_state(std::vector<T> &buf)
 	{
 		std::size_t size = 0;
 		for (auto const & s : state().save_list())
-			size += ((s->m_dt.size * s->m_count + sizeof(T) - 1) / sizeof(T));
+			size += s->m_dt.size * s->m_count;
 
 		if (buf.size() != size)
 			throw netlist::nl_exception("Size different during load state.");
 
-		auto p = buf.data();
+		char *p = buf.data();
 
 		for (auto const & s : state().save_list())
 		{
 			std::size_t sz = s->m_dt.size * s->m_count;
 			if (s->m_dt.is_float || s->m_dt.is_integral)
-				std::memcpy(s->m_ptr, p, sz );
+				std::copy(p, p + sz, (char *) s->m_ptr);
 			else
 				log().fatal("found unsupported save element {1}\n", s->m_name);
-			p += ((sz + sizeof(T) - 1) / sizeof(T));
+			p += sz;
 		}
 		state().post_load();
 		rebuild_lists();
@@ -372,7 +370,7 @@ void tool_app_t::run()
 
 	if (opt_savestate.was_specified())
 	{
-		auto savestate = nt.save_state<char>();
+		auto savestate = nt.save_state();
 		plib::pofilestream strm(opt_savestate());
 		plib::pbinary_writer writer(strm);
 		writer.write(savestate);