Major plugin refactor and cleanup.

Switched to POCO library for unified platform/library interface.
Deprecated the external module API. It was creating more problems than solving.
Removed most built-in libraries in favor of system libraries for easier maintenance.
Cleaned and secured code with help from static analyzers.

vendor/POCO/Foundation/include/Poco/MemoryStream.h

@@ -0,0 +1,246 @@
+//
+// MemoryStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  MemoryStream
+//
+// Definition of MemoryStreamBuf, MemoryInputStream, MemoryOutputStream
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_MemoryStream_INCLUDED
+#define Foundation_MemoryStream_INCLUDED
+
+
+#include "Poco/Bugcheck.h"
+#include "Poco/Foundation.h"
+#include "Poco/StreamUtil.h"
+#include <streambuf>
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+template <typename ch, typename tr> 
+class BasicMemoryStreamBuf: public std::basic_streambuf<ch, tr>
+	/// BasicMemoryStreamBuf is a simple implementation of a 
+	/// stream buffer for reading and writing from a memory area.
+	///
+	/// This streambuf only supports unidirectional streams.
+	/// In other words, the BasicMemoryStreamBuf can be
+	/// used for the implementation of an istream or an
+	/// ostream, but not for an iostream.
+{
+protected:
+	typedef std::basic_streambuf<ch, tr> Base;
+	typedef std::basic_ios<ch, tr> IOS;
+	typedef ch char_type;
+	typedef tr char_traits;
+	typedef typename Base::int_type int_type;
+	typedef typename Base::pos_type pos_type;
+	typedef typename Base::off_type off_type;
+
+public:
+	BasicMemoryStreamBuf(char_type* pBuffer, std::streamsize bufferSize):
+		_pBuffer(pBuffer),
+		_bufferSize(bufferSize)
+	{
+		this->setg(_pBuffer, _pBuffer, _pBuffer + _bufferSize);
+		this->setp(_pBuffer, _pBuffer + _bufferSize);
+	}
+
+	~BasicMemoryStreamBuf()
+	{
+	}
+
+	virtual int_type overflow(int_type /*c*/)
+	{
+		return char_traits::eof();
+	}
+
+	virtual int_type underflow()
+	{
+		return char_traits::eof();
+	}
+
+	virtual pos_type seekoff(off_type off, std::ios_base::seekdir way, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out)
+	{
+		const pos_type fail = off_type(-1);
+		off_type newoff = off_type(-1);
+
+		if ((which & std::ios_base::in) != 0)
+		{
+			if (this->gptr() == 0)
+				return fail;
+
+			if (way == std::ios_base::beg)
+			{
+				newoff = 0;
+			}
+			else if (way == std::ios_base::cur)
+			{
+				// cur is not valid if both in and out are specified (Condition 3)
+				if ((which & std::ios_base::out) != 0)
+					return fail;
+				newoff = this->gptr() - this->eback();
+			}
+			else if (way == std::ios_base::end)
+			{
+				newoff = this->egptr() - this->eback();
+			}
+			else
+			{
+				poco_bugcheck();
+			}
+
+			if ((newoff + off) < 0 || (this->egptr() - this->eback()) < (newoff + off))
+				return fail;
+			this->setg(this->eback(), this->eback() + newoff + off, this->egptr());
+		}
+
+		if ((which & std::ios_base::out) != 0)
+		{
+			if (this->pptr() == 0)
+				return fail;
+
+			if (way == std::ios_base::beg)
+			{
+				newoff = 0;
+			}
+			else if (way == std::ios_base::cur)
+			{
+				// cur is not valid if both in and out are specified (Condition 3)
+				if ((which & std::ios_base::in) != 0)
+					return fail;
+				newoff = this->pptr() - this->pbase();
+			}
+			else if (way == std::ios_base::end)
+			{
+				newoff = this->epptr() - this->pbase();
+			}
+			else
+			{
+				poco_bugcheck();
+			}
+
+			if (newoff + off < 0 || (this->epptr() - this->pbase()) < newoff + off)
+				return fail;
+			this->pbump((int)(newoff + off - (this->pptr() - this->pbase())));
+		}
+
+		return newoff;
+	}
+
+	virtual int sync()
+	{
+		return 0;
+	}
+	
+	std::streamsize charsWritten() const
+	{
+		return static_cast<std::streamsize>(this->pptr() - this->pbase());
+	}
+
+	void reset()
+		/// Resets the buffer so that current read and write positions
+		/// will be set to the beginning of the buffer.
+	{
+		this->setg(_pBuffer, _pBuffer, _pBuffer + _bufferSize);
+		this->setp(_pBuffer, _pBuffer + _bufferSize);
+	}
+		
+private:
+	char_type*      _pBuffer;
+	std::streamsize _bufferSize;
+
+	BasicMemoryStreamBuf();
+	BasicMemoryStreamBuf(const BasicMemoryStreamBuf&);
+	BasicMemoryStreamBuf& operator = (const BasicMemoryStreamBuf&);
+};
+
+
+//
+// We provide an instantiation for char
+//
+typedef BasicMemoryStreamBuf<char, std::char_traits<char>> MemoryStreamBuf;
+
+
+class Foundation_API MemoryIOS: public virtual std::ios
+	/// The base class for MemoryInputStream and MemoryOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	MemoryIOS(char* pBuffer, std::streamsize bufferSize);
+		/// Creates the basic stream.
+		
+	~MemoryIOS();
+		/// Destroys the stream.
+
+	MemoryStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying streambuf.
+		
+protected:
+	MemoryStreamBuf _buf;
+};
+
+
+class Foundation_API MemoryInputStream: public MemoryIOS, public std::istream
+	/// An input stream for reading from a memory area.
+{
+public:
+	MemoryInputStream(const char* pBuffer, std::streamsize bufferSize);
+		/// Creates a MemoryInputStream for the given memory area,
+		/// ready for reading.
+	
+	~MemoryInputStream();
+		/// Destroys the MemoryInputStream.
+};
+
+
+class Foundation_API MemoryOutputStream: public MemoryIOS, public std::ostream
+	/// An input stream for reading from a memory area.
+{
+public:
+	MemoryOutputStream(char* pBuffer, std::streamsize bufferSize);
+		/// Creates a MemoryOutputStream for the given memory area,
+		/// ready for writing.
+	
+	~MemoryOutputStream();
+		/// Destroys the MemoryInputStream.
+
+	std::streamsize charsWritten() const;
+		/// Returns the number of chars written to the buffer.
+};
+
+
+//
+// inlines
+//
+inline MemoryStreamBuf* MemoryIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+inline std::streamsize MemoryOutputStream::charsWritten() const
+{
+	return _buf.charsWritten();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_MemoryStream_INCLUDED