m_system_cpp.h removed, because there're no C files anymore (hurrah)

1 files changed, 0 insertions, 451 deletions

diff --git a/include/m_system_cpp.h b/include/m_system_cpp.h
deleted file mode 100644
index a65aa9fba4..0000000000
--- a/include/m_system_cpp.h
+++ /dev/null
@@ -1,451 +0,0 @@
-/*

-

-Miranda NG: the free IM client for Microsoft* Windows*

-

-Copyright (C) 2012-20 Miranda NG team (https://miranda-ng.org)

-Copyright (c) 2000-08 Miranda ICQ/IM project,

-all portions of this codebase are copyrighted to the people

-listed in contributors.txt.

-

-This program is free software; you can redistribute it and/or

-modify it under the terms of the GNU General Public License

-as published by the Free Software Foundation; either version 2

-of the License, or (at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

-*/

-#ifndef M_SYSTEM_CPP_H__

-#define M_SYSTEM_CPP_H__ 1

-

-#include <stdlib.h>

-

-#ifndef M_SYSTEM_H__

-	#include "m_system.h"

-#endif

-

-#ifndef M_STRING_H__

-	#include <m_string.h>

-#endif

-

-#if defined(__cplusplus)

-

-///////////////////////////////////////////////////////////////////////////////

-// general lists' templates

-

-struct MIR_CORE_EXPORT MNonCopyable

-{

-	__inline MNonCopyable() {}

-

-	MNonCopyable(const MNonCopyable&) = delete;

-	MNonCopyable& operator=(const MNonCopyable&) = delete;

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// mir_ptr - automatic pointer for buffers, allocated using mir_alloc/mir_calloc

-

-template<class T> class mir_ptr

-{

-protected:

-	T *data;

-

-public:

-	__inline explicit mir_ptr() : data(nullptr) {}

-	__inline explicit mir_ptr(T *_p) : data(_p) {}

-	__inline ~mir_ptr() { mir_free(data); }

-	__inline T* get() const { return data; }

-	__inline T* operator=(T *_p) { if (data) mir_free(data); data = _p; return data; }

-	__inline T* operator->() const { return data; }

-	__inline operator T*() const { return data; }

-	__inline operator INT_PTR() const { return (INT_PTR)data; }

-	__inline T* detach() { T *res = data; data = nullptr; return res; }

-};

-

-typedef mir_ptr<char>  ptrA;

-typedef mir_ptr<wchar_t> ptrW;

-

-///////////////////////////////////////////////////////////////////////////////

-// mir_cs - simple wrapper for the critical sections

-

-class MIR_CORE_EXPORT mir_cs : public MNonCopyable

-{

-	CRITICAL_SECTION m_cs;

-

-public:

-	mir_cs();

-	~mir_cs();

-

-	void Lock();

-	void Unlock();

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// mir_cslock - simple locker for the critical sections

-

-class mir_cslock : public MNonCopyable

-{

-	mir_cs &cs;

-

-public:

-	__inline mir_cslock(mir_cs &_cs) : cs(_cs) { cs.Lock(); }

-	__inline ~mir_cslock() { cs.Unlock(); }

-};

-

-class mir_cslockfull : public MNonCopyable

-{

-	mir_cs &cs;

-	bool bIsLocked = false;

-

-public:

-	__inline void lock() { bIsLocked = true; cs.Lock(); }

-	__inline void unlock() { bIsLocked = false; cs.Unlock(); }

-

-	__inline mir_cslockfull(mir_cs &_cs) : cs(_cs) { lock(); }

-	__inline ~mir_cslockfull() { if (bIsLocked) unlock(); }

-};

-

-//////////////////////////////////////////////////////////////////////////////

-//pass_ptrA, pass_ptrW and pass_ptrT - automatic pointer for passwords

-

-class pass_ptrA : public mir_ptr<char>

-{

-public:

-	__inline explicit pass_ptrA() : mir_ptr(){}

-	__inline explicit pass_ptrA(char *_p) : mir_ptr(_p) {}

-	__inline ~pass_ptrA() { zero(); }

-	__inline char* operator=(char *_p){ zero(); return mir_ptr::operator=(_p); }

-	__inline void zero() {

-		if (data) SecureZeroMemory(data, mir_strlen(data));

-	}

-};

-

-class pass_ptrW : public mir_ptr<wchar_t>

-{

-public:

-	__inline explicit pass_ptrW() : mir_ptr(){}

-	__inline explicit pass_ptrW(wchar_t *_p) : mir_ptr(_p) {}

-	__inline ~pass_ptrW() { zero(); }

-	__inline wchar_t* operator=(wchar_t *_p){ zero(); return mir_ptr::operator=(_p); }

-	__inline void zero() {

-		if (data) SecureZeroMemory(data, mir_wstrlen(data)*sizeof(wchar_t));

-	}

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// basic class for classes that should be cleared inside new()

-

-class MZeroedObject

-{

-public:

-	__inline void* operator new(size_t size)

-	{	return calloc(1, size);

-	}

-

-	__inline void operator delete(void *p)

-	{	free(p);

-	}

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// general lists' templates

-

-#define	NumericKeySortT -1

-#define	HandleKeySortT  -2

-#define	PtrKeySortT     -3

-

-template<class T> struct LIST

-{

-	typedef int (*FTSortFunc)(const T *p1, const T *p2);

-

-	__inline LIST(int aincr, FTSortFunc afunc = nullptr)

-	{

-		memset(this, 0, sizeof(*this));

-		increment = aincr;

-		sortFunc = afunc;

-	}

-

-	__inline LIST(int aincr, INT_PTR id)

-	{

-		memset(this, 0, sizeof(*this));

-		increment = aincr;

-		sortFunc = FTSortFunc(id);

-	}

-

-	__inline LIST(const LIST &x)

-	{

-		items = nullptr;

-		List_Copy((SortedList*)&x, (SortedList*)this, sizeof(T));

-	}

-

-	__inline LIST& operator = (const LIST &x)

-	{

-		destroy();

-		List_Copy((SortedList*)&x, (SortedList*)this, sizeof(T));

-		return *this;

-	}

-

-	__inline ~LIST()

-	{

-		destroy();

-	}

-

-	__inline T*  operator[](int idx) const { return (idx >= 0 && idx < count) ? items[idx] : nullptr; }

-	__inline int getCount(void)      const { return count; }

-	__inline T** getArray(void)      const { return items; }

-

-	__inline int getIndex(T *p) const

-	{

-		int idx;

-		return (!List_GetIndex((SortedList*)this, p, &idx)) ? -1 : idx;

-	}

-

-	class reverse_iterator

-	{

-		int index;

-		T **base;

-

-	public:

-		reverse_iterator(const LIST &_lst) :

-			index(_lst.getCount()-1),

-			base(_lst.getArray())

-		{

-		}

-

-		class iterator

-		{

-			T** ptr;

-		

-		public:

-			iterator(T **_p) : ptr(_p) {}

-			iterator operator++() { --ptr; return *this; }

-			bool operator!=(const iterator &p) { return ptr != p.ptr; }

-			operator T**() const { return ptr; }

-		};

-

-		__inline iterator begin() const { return iterator(base + index); }

-		__inline iterator end() const { return iterator(base-1); }

-		__inline int indexOf(T **p) const { return int(p - base); }

-	};

-

-	__inline void destroy(void)         { List_Destroy((SortedList*)this); }

-	__inline T*   find(T *p) const      { return (T*)List_Find((SortedList*)this, p); }

-	__inline int  indexOf(T *p) const   { return List_IndexOf((SortedList*)this, p); }

-	__inline int  insert(T *p, int idx) { return List_Insert((SortedList*)this, p, idx); }

-	__inline int  remove(int idx)       { return List_Remove((SortedList*)this, idx); }

-

-	__inline int  insert(T *p)          { return List_InsertPtr((SortedList*)this, p); }

-	__inline int  remove(T *p)          { return List_RemovePtr((SortedList*)this, p); }

-

-	__inline int  indexOf(T **p) const  { return int(p - items); }

-	__inline T* removeItem(T **p)

-	{

-		T *savePtr = *p;

-		List_Remove((SortedList*)this, int(p - items));

-		return savePtr;

-	}

-

-	__inline void put(int idx, T *p)   { items[idx] = p; }

-

-	__inline T** begin() const { return items; }

-	__inline T** end() const { return items + count; }

-

-	__inline reverse_iterator rev_iter() const { return reverse_iterator(*this); }

-

-protected:

-	T**        items;

-	int        count, limit, increment;

-	FTSortFunc sortFunc;

-};

-

-template<class T> struct OBJLIST : public LIST<T>

-{

-	typedef int (*FTSortFunc)(const T *p1, const T *p2);

-

-	__inline OBJLIST(int aincr, FTSortFunc afunc = nullptr) :

-		LIST<T>(aincr, afunc)

-		{}

-

-	__inline OBJLIST(int aincr, INT_PTR id) :

-		LIST<T>(aincr, (FTSortFunc) id)

-		{}

-

-	__inline OBJLIST(const OBJLIST &x) :

-		LIST<T>(x.increment, x.sortFunc)

-		{

-			this->items = nullptr;

-			List_ObjCopy((SortedList*)&x, (SortedList*)this, sizeof(T));

-		}

-

-	__inline OBJLIST& operator = (const OBJLIST& x)

-		{

-			destroy();

-			List_ObjCopy((SortedList*)&x, (SortedList*)this, sizeof(T));

-			return *this;

-		}

-

-	~OBJLIST()

-	{

-		destroy();

-	}

-

-	__inline void destroy(void)

-	{

-		for (int i = 0; i < this->count; i++)

-			delete this->items[i];

-

-		List_Destroy((SortedList*)this);

-	}

-

-	__inline int remove(int idx)

-	{

-		delete this->items[idx];

-		return List_Remove((SortedList*)this, idx);

-	}

-

-	__inline int remove(T *p)

-	{

-		int i = this->getIndex(p);

-		if (i != -1) {

-			remove(i);

-			return 1;

-		}

-		return 0;

-	}

-

-	__inline T& operator[](int idx) const { return *this->items[idx]; }

-};

-

-#define __A2W(s) L ## s

-#define _A2W(s) __A2W(s)

-

-class _A2T : public ptrW

-{

-public:

-	__inline _A2T(const char *s) : ptrW(mir_a2u(s)) {}

-	__inline _A2T(const char *s, int cp) : ptrW(mir_a2u_cp(s, cp)) {}

-};

-

-class _T2A : public ptrA

-{

-public:

-	__forceinline _T2A(const wchar_t *s) : ptrA(mir_u2a(s)) {}

-	__forceinline _T2A(const wchar_t *s, int cp) : ptrA(mir_u2a_cp(s, cp)) {}

-};

-

-class T2Utf : public ptrA

-{

-public:

-	__forceinline T2Utf(const wchar_t *str) : ptrA(mir_utf8encodeW(str)) {}

-	__forceinline operator BYTE* () const { return (BYTE*)data; }

-	#ifdef _XSTRING_

-		std::string str() const { return std::string(data); }

-	#endif

-};

-

-class Utf2T : public ptrW

-{

-public:

-	__forceinline Utf2T(const char *str) : ptrW(mir_utf8decodeW(str)) {}

-	__forceinline operator wchar_t* () const { return data; }

-	#ifdef _XSTRING_

-	std::wstring str() const { return std::wstring(data); }

-	#endif

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// basic class for classes that should be cleared inside new()

-

-class MIR_CORE_EXPORT MBinBuffer

-{

-	char *m_buf;

-	size_t m_len;

-

-public:

-	MBinBuffer();

-	~MBinBuffer();

-

-	__forceinline char*  data() const { return m_buf; }

-	__forceinline bool   isEmpty() const { return m_len == 0; }

-	__forceinline size_t length() const { return m_len; }

-

-	// adds a buffer to the end

-	void append(void *pBuf, size_t bufLen);

-

-	// adds a buffer to the beginning

-	void appendBefore(void *pBuf, size_t bufLen);

-

-	// replaces buffer contents

-	void assign(void *pBuf, size_t bufLen);

-

-	// drops a part of buffer

-	void remove(size_t sz);

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// parameter classes for XML, JSON & HTTP requests

-

-struct PARAM

-{

-	const char *szName;

-	__forceinline PARAM(const char *_name) : szName(_name)

-	{}

-};

-

-struct BOOL_PARAM : public PARAM

-{

-	bool bValue;

-	__forceinline BOOL_PARAM(const char *_name, bool _value) :

-		PARAM(_name), bValue(_value)

-	{}

-};

-

-struct INT_PARAM : public PARAM

-{

-	int32_t iValue;

-	__forceinline INT_PARAM(const char *_name, int32_t _value) :

-		PARAM(_name), iValue(_value)

-	{}

-};

-

-struct INT64_PARAM : public PARAM

-{

-	int64_t iValue;

-	__forceinline INT64_PARAM(const char *_name, int64_t _value) :

-		PARAM(_name), iValue(_value)

-	{}

-};

-

-struct CHAR_PARAM : public PARAM

-{

-	const char *szValue;

-	__forceinline CHAR_PARAM(const char *_name, const char *_value) :

-		PARAM(_name), szValue(_value)

-	{}

-};

-

-struct WCHAR_PARAM : public PARAM

-{

-	const wchar_t *wszValue;

-	__forceinline WCHAR_PARAM(const char *_name, const wchar_t *_value) :

-		PARAM(_name), wszValue(_value)

-	{}

-};

-

-///////////////////////////////////////////////////////////////////////////////

-// http support

-

-// works inline, in the same buffer, thus destroying its contents

-// returns the address of buffer passed

-MIR_CORE_DLL(char*) mir_urlDecode(char *szUrl);

-

-MIR_CORE_DLL(CMStringA) mir_urlEncode(const char *szUrl);

-

-#endif

-

-#endif // M_SYSTEM_CPP_H