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/Array.h

@@ -0,0 +1,260 @@
+//
+// Array.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Array
+//
+// Definition of the Array class
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+// ------------------------------------------------------------------------------
+// (C) Copyright Nicolai M. Josuttis 2001.
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+// ------------------------------------------------------------------------------
+
+
+#ifndef Foundation_Array_INCLUDED
+#define Foundation_Array_INCLUDED
+
+
+#include "Poco/Exception.h"
+#include "Poco/Bugcheck.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+template<class T, std::size_t N>
+class Array 
+	/// STL container like C-style array replacement class. 
+	/// 
+	/// This implementation is based on the idea of Nicolai Josuttis.
+	/// His original implementation can be found at http://www.josuttis.com/cppcode/array.html . 
+{
+public:
+	typedef T				value_type;
+	typedef T*				iterator;
+	typedef const T*		const_iterator;
+	typedef T&				reference;
+	typedef const T&		const_reference;
+	typedef std::size_t		size_type;
+	typedef std::ptrdiff_t  difference_type;
+
+	iterator begin()
+	{
+		return elems;
+	}
+
+	const_iterator begin() const
+	{
+		return elems;
+	}
+
+	iterator end()
+	{ 
+		return elems+N;
+	}
+
+	const_iterator end() const
+	{
+		return elems+N;
+	}
+
+	typedef std::reverse_iterator<iterator>			reverse_iterator;
+	typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+
+	reverse_iterator rbegin()
+	{
+		return reverse_iterator(end());
+	}
+
+	const_reverse_iterator rbegin() const
+	{
+		return const_reverse_iterator(end());
+	}
+
+	reverse_iterator rend()
+	{ 
+		return reverse_iterator(begin());
+	}
+
+	const_reverse_iterator rend() const
+	{
+		return const_reverse_iterator(begin());
+	}
+
+	reference operator[](size_type i) 
+		/// Element access without range check. If the index is not small than the given size, the behavior is undefined.
+	{ 
+		poco_assert( i < N && "out of range" ); 
+		return elems[i];
+	}
+
+	const_reference operator[](size_type i) const 
+		/// Element access without range check. If the index is not small than the given size, the behavior is undefined.
+	{	 
+		poco_assert( i < N && "out of range" ); 
+		return elems[i]; 
+	}
+
+	reference at(size_type i)
+		/// Element access with range check. Throws Poco::InvalidArgumentException if the index is over range.
+	{ 
+		if(i>=size())
+			throw Poco::InvalidArgumentException("Array::at() range check failed: index is over range");
+		return elems[i]; 
+	}
+
+	const_reference at(size_type i) const
+		/// Element access with range check. Throws Poco::InvalidArgumentException if the index is over range.
+	{
+		if(i>=size())
+			throw Poco::InvalidArgumentException("Array::at() range check failed: index is over range");
+		return elems[i]; 
+	}
+
+	reference front() 
+	{ 
+		return elems[0]; 
+	}
+
+	const_reference front() const 
+	{
+		return elems[0];
+	}
+
+	reference back() 
+	{ 
+		return elems[N-1]; 
+	}
+
+	const_reference back() const 
+	{ 
+		return elems[N-1]; 
+	}
+
+	static size_type size()
+	{
+		return N; 
+	}
+
+	static bool empty()
+	{ 
+		return false; 
+	}
+
+	static size_type max_size()
+	{ 
+		return N; 
+	}
+
+	enum { static_size = N };
+
+	void swap (Array<T,N>& y) 
+	{
+		std::swap_ranges(begin(),end(),y.begin());
+	}
+
+	const T* data() const
+		/// Direct access to data (read-only)
+	{ 
+		return elems; 
+	}
+
+	T* data()
+	{ 
+		return elems;
+	}
+
+	T* c_array()
+	{ 
+		/// Use array as C array (direct read/write access to data)
+		return elems;
+	}
+
+	template <typename Other>
+	Array<T,N>& operator= (const Array<Other,N>& rhs)
+		/// Assignment with type conversion 
+	{
+		std::copy(rhs.begin(),rhs.end(), begin());
+		return *this;
+	}
+
+	void assign (const T& value)
+		/// Assign one value to all elements
+	{
+		std::fill_n(begin(),size(),value);
+	}
+
+public:
+	T elems[N];	
+		/// Fixed-size array of elements of type T, public specifier used to make this class a aggregate.
+
+};
+
+
+// comparisons
+template<class T, std::size_t N>
+bool operator== (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return std::equal(x.begin(), x.end(), y.begin());
+}
+
+
+template<class T, std::size_t N>
+bool operator< (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+}
+
+
+template<class T, std::size_t N>
+bool operator!= (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return !(x==y);
+}
+
+
+template<class T, std::size_t N>
+bool operator> (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return y<x;
+}
+
+
+template<class T, std::size_t N>
+bool operator<= (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return !(y<x);
+}
+
+
+template<class T, std::size_t N>
+bool operator>= (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return !(x<y);
+}
+
+
+template<class T, std::size_t N>
+inline void swap (Array<T,N>& x, Array<T,N>& y) 
+	/// global swap()
+{
+	x.swap(y);
+}
+
+
+}// namespace Poco
+
+
+#endif // Foundation_Array_INCLUDED
+