diff options
Diffstat (limited to '')
| -rw-r--r-- | public/sdk/inc/mfc42/afx.h | 1916 |
1 files changed, 1916 insertions, 0 deletions
diff --git a/public/sdk/inc/mfc42/afx.h b/public/sdk/inc/mfc42/afx.h new file mode 100644 index 000000000..bcbf102f1 --- /dev/null +++ b/public/sdk/inc/mfc42/afx.h @@ -0,0 +1,1916 @@ +// This is a part of the Microsoft Foundation Classes C++ library. +// Copyright (C) 1992-1995 Microsoft Corporation +// All rights reserved. +// +// This source code is only intended as a supplement to the +// Microsoft Foundation Classes Reference and related +// electronic documentation provided with the library. +// See these sources for detailed information regarding the +// Microsoft Foundation Classes product. + +#ifndef __AFX_H__ +#define __AFX_H__ + +#ifndef __cplusplus + #error MFC requires C++ compilation (use a .cpp suffix) +#endif + +///////////////////////////////////////////////////////////////////////////// + +#ifdef _AFX_MINREBUILD +#pragma component(minrebuild, off) +#endif +#ifndef _AFX_FULLTYPEINFO +#pragma component(mintypeinfo, on) +#endif + +#include <afxver_.h> // Target version control + +#ifndef _AFX_NOFORCE_LIBS +#ifndef _MAC + +///////////////////////////////////////////////////////////////////////////// +// Win32 libraries + +#ifndef _AFXDLL + #ifndef _UNICODE + #ifdef _DEBUG + #pragma comment(lib, "nafxcwd.lib") + #else + #pragma comment(lib, "nafxcw.lib") + #endif + #else + #ifdef _DEBUG + #pragma comment(lib, "uafxcwd.lib") + #else + #pragma comment(lib, "uafxcw.lib") + #endif + #endif +#else + #ifndef _UNICODE + #ifdef _DEBUG + #pragma comment(lib, "mfc42d.lib") + #pragma comment(lib, "mfcs42d.lib") + #else + #pragma comment(lib, "mfc42.lib") + #pragma comment(lib, "mfcs42.lib") + #endif + #else + #ifdef _DEBUG + #pragma comment(lib, "mfc42ud.lib") + #pragma comment(lib, "mfcs42ud.lib") + #else + #pragma comment(lib, "mfc42u.lib") + #pragma comment(lib, "mfcs42u.lib") + #endif + #endif +#endif + +#ifdef _DLL + #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) + #pragma comment(lib, "msvcrtd.lib") + #else + #pragma comment(lib, "msvcrt.lib") + #endif +#else +#ifdef _MT + #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) + #pragma comment(lib, "libcmtd.lib") + #else + #pragma comment(lib, "libcmt.lib") + #endif +#else + #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) + #pragma comment(lib, "libcd.lib") + #else + #pragma comment(lib, "libc.lib") + #endif +#endif +#endif + +#pragma comment(lib, "kernel32.lib") +#pragma comment(lib, "user32.lib") +#pragma comment(lib, "gdi32.lib") +#pragma comment(lib, "comdlg32.lib") +#pragma comment(lib, "winspool.lib") +#pragma comment(lib, "advapi32.lib") +#pragma comment(lib, "shell32.lib") +#pragma comment(lib, "comctl32.lib") + +#else //!_MAC + +////////////////////////////////////////////////////////////////////////////// +// Macintosh libraries + +#ifndef _AFXDLL + #ifdef _DEBUG + #ifdef _68K_ + #pragma comment(lib, "nafxcmd.lib") + #else + #pragma comment(lib, "nafxcpd.lib") + #endif + #else + #ifdef _68K_ + #pragma comment(lib, "nafxcm.lib") + #else + #pragma comment(lib, "nafxcp.lib") + #endif + #endif +#else + #ifdef _DEBUG + #ifdef _68K_ + #error _AFXDLL is not supported for 68K Macintosh + #else + #pragma comment(lib, "mfc42pd.lib") + #pragma comment(lib, "mfcs42pd.lib") + #endif + #else + #ifdef _68K_ + #error _AFXDLL is not supported for 68K Macintosh + #else + #pragma comment(lib, "mfc42p.lib") + #pragma comment(lib, "mfcs42p.lib") + #endif + #endif +#endif + +#if !defined(_AFXDLL) && !defined(_USRDLL) + #ifdef _DEBUG + #pragma comment(lib, "wlmd.lib") + #pragma comment(lib, "comctld.lib") + #else + #pragma comment(lib, "wlm.lib") + #pragma comment(lib, "comctl.lib") + #endif + #pragma comment(linker, "/macres:wlm.rsc /macres:commdlg.rsc") + #pragma comment(linker, "/macres:comctl.rsc") + #ifdef _MPPC_ + #pragma comment(lib, "privint.lib") + #pragma comment(lib, "threads.lib") + #pragma comment(lib, "math.lib") + #endif +#else + #ifdef _DEBUG + #pragma comment(lib, "msvcwlmd.lib") + #pragma comment(lib, "msvcctld.lib") + #else + #pragma comment(lib, "msvcwlm.lib") + #pragma comment(lib, "msvcctl.lib") + #endif +#endif + +#ifdef _68K_ + #ifdef _DEBUG + #pragma comment(lib, "swapd.lib") + #else + #pragma comment(lib, "swap.lib") + #endif + #pragma comment(lib, "lsanes.lib") + #pragma comment(lib, "llibcs.lib") + #pragma comment(lib, "osl.lib") +#endif + +#ifdef _MPPC_ + #ifdef _DLL + #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) + #pragma comment(lib, "msvcrtd.lib") + #else + #pragma comment(lib, "msvcrt.lib") + #endif + #else + #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG) + #pragma comment(lib, "libcd.lib") + #else + #pragma comment(lib, "libc.lib") + #endif + #endif +#endif + +#endif //_MAC + +// force inclusion of NOLIB.OBJ for /disallowlib directives +#pragma comment(linker, "/include:__afxForceEXCLUDE") + +// force inclusion of DLLMODUL.OBJ for _USRDLL +#ifdef _USRDLL +#pragma comment(linker, "/include:__afxForceUSRDLL") +#endif + +// force inclusion of STDAFX.OBJ for precompiled types +#ifdef _AFXDLL +#pragma comment(linker, "/include:__afxForceSTDAFX") +#endif + +#endif //!_AFX_NOFORCE_LIBS + +///////////////////////////////////////////////////////////////////////////// +// Classes declared in this file +// in addition to standard primitive data types and various helper macros + +struct CRuntimeClass; // object type information + +class CObject; // the root of all objects classes + + class CException; // the root of all exceptions + class CArchiveException; // archive exception + class CFileException; // file exception + class CSimpleException; + class CMemoryException; // out-of-memory exception + class CNotSupportedException; // feature not supported exception + + class CFile; // raw binary file + class CStdioFile; // buffered stdio text/binary file + class CMemFile; // memory based file + +// Non CObject classes +class CString; // growable string type +class CTimeSpan; // time/date difference +class CTime; // absolute time/date +struct CFileStatus; // file status information +struct CMemoryState; // diagnostic memory support + +class CArchive; // object persistence tool +class CDumpContext; // object diagnostic dumping + +///////////////////////////////////////////////////////////////////////////// +// Other includes from standard "C" runtimes + +#ifndef _INC_STRING + #include <string.h> +#endif +#ifndef _INC_STDIO + #include <stdio.h> +#endif +#ifndef _INC_STDLIB + #include <stdlib.h> +#endif +#ifndef _INC_TIME + #include <time.h> +#endif +#ifndef _INC_LIMITS + #include <limits.h> +#endif +#ifndef _INC_STDDEF + #include <stddef.h> +#endif +#ifndef _INC_STDARG + #include <stdarg.h> +#endif + +#ifndef _AFX_NO_DEBUG_CRT +#ifndef _INC_CRTDBG + #include <crtdbg.h> +#endif +#endif // _AFX_NO_DEBUG_CRT + +#ifdef _AFX_OLD_EXCEPTIONS +// use setjmp and helper functions instead of C++ keywords +#ifndef _INC_SETJMP + #pragma warning(disable: 4611) + #include <setjmp.h> +#endif +#endif + +#ifdef _AFX_PACKING +#pragma pack(push, _AFX_PACKING) +#endif + +///////////////////////////////////////////////////////////////////////////// +// Basic types + +// abstract iteration position +struct __POSITION { }; +typedef __POSITION* POSITION; + +struct _AFX_DOUBLE { BYTE doubleBits[sizeof(double)]; }; +struct _AFX_FLOAT { BYTE floatBits[sizeof(float)]; }; + +// Standard constants +#undef FALSE +#undef TRUE +#undef NULL + +#define FALSE 0 +#define TRUE 1 +#define NULL 0 + +///////////////////////////////////////////////////////////////////////////// +// Diagnostic support + +#ifdef _DEBUG + +BOOL AFXAPI AfxAssertFailedLine(LPCSTR lpszFileName, int nLine); + +void AFX_CDECL AfxTrace(LPCTSTR lpszFormat, ...); +// Note: file names are still ANSI strings (filenames rarely need UNICODE) +void AFXAPI AfxAssertValidObject(const CObject* pOb, + LPCSTR lpszFileName, int nLine); +void AFXAPI AfxDump(const CObject* pOb); // Dump an object from CodeView + +#define TRACE ::AfxTrace +#define THIS_FILE __FILE__ +#define ASSERT(f) \ + do \ + { \ + if (!(f) && AfxAssertFailedLine(THIS_FILE, __LINE__)) \ + AfxDebugBreak(); \ + } while (0) \ + +#define VERIFY(f) ASSERT(f) +#define ASSERT_VALID(pOb) (::AfxAssertValidObject(pOb, THIS_FILE, __LINE__)) +#define DEBUG_ONLY(f) (f) + +// The following trace macros are provided for backward compatiblity +// (they also take a fixed number of parameters which provides +// some amount of extra error checking) +#define TRACE0(sz) ::AfxTrace(_T("%s"), _T(sz)) +#define TRACE1(sz, p1) ::AfxTrace(_T(sz), p1) +#define TRACE2(sz, p1, p2) ::AfxTrace(_T(sz), p1, p2) +#define TRACE3(sz, p1, p2, p3) ::AfxTrace(_T(sz), p1, p2, p3) + +// These AFX_DUMP macros also provided for backward compatibility +#define AFX_DUMP0(dc, sz) dc << _T(sz) +#define AFX_DUMP1(dc, sz, p1) dc << _T(sz) << p1 + +#else // _DEBUG + +#define ASSERT(f) ((void)0) +#define VERIFY(f) ((void)(f)) +#define ASSERT_VALID(pOb) ((void)0) +#define DEBUG_ONLY(f) ((void)0) +inline void AFX_CDECL AfxTrace(LPCTSTR, ...) { } +#define TRACE 1 ? (void)0 : ::AfxTrace +#define TRACE0(sz) +#define TRACE1(sz, p1) +#define TRACE2(sz, p1, p2) +#define TRACE3(sz, p1, p2, p3) + +#endif // !_DEBUG + +#define ASSERT_POINTER(p, type) \ + ASSERT(((p) != NULL) && AfxIsValidAddress((p), sizeof(type), FALSE)) + +#define ASSERT_NULL_OR_POINTER(p, type) \ + ASSERT(((p) == NULL) || AfxIsValidAddress((p), sizeof(type), FALSE)) + +///////////////////////////////////////////////////////////////////////////// +// Turn off warnings for /W4 +// To resume any of these warning: #pragma warning(default: 4xxx) +// which should be placed after the AFX include files +#ifndef ALL_WARNINGS +// warnings generated with common MFC/Windows code +#pragma warning(disable: 4127) // constant expression for TRACE/ASSERT +#pragma warning(disable: 4134) // message map member fxn casts +#pragma warning(disable: 4201) // nameless unions are part of C++ +#pragma warning(disable: 4511) // private copy constructors are good to have +#pragma warning(disable: 4512) // private operator= are good to have +#pragma warning(disable: 4514) // unreferenced inlines are common +#pragma warning(disable: 4710) // private constructors are disallowed +#pragma warning(disable: 4705) // statement has no effect in optimized code +// warnings caused by normal optimizations +#ifndef _DEBUG +#pragma warning(disable: 4701) // local variable *may* be used without init +#pragma warning(disable: 4702) // unreachable code caused by optimizations +#pragma warning(disable: 4791) // loss of debugging info in release version +#endif +// warnings specific to _AFXDLL version +#ifdef _AFXDLL +#pragma warning(disable: 4204) // non-constant aggregate initializer +#endif +#ifdef _AFXDLL +#pragma warning(disable: 4275) // deriving exported class from non-exported +#pragma warning(disable: 4251) // using non-exported as public in exported +#endif +#endif //!ALL_WARNINGS + +#ifdef _DEBUG +#define UNUSED(x) +#else +#define UNUSED(x) x +#endif +#define UNUSED_ALWAYS(x) x + +///////////////////////////////////////////////////////////////////////////// +// Other implementation helpers + +#define BEFORE_START_POSITION ((POSITION)-1L) + +///////////////////////////////////////////////////////////////////////////// +// explicit initialization for general purpose classes + +BOOL AFXAPI AfxInitialize(BOOL bDLL = FALSE, DWORD dwVersion = _MFC_VER); + +#undef AFX_DATA +#define AFX_DATA AFX_CORE_DATA + +///////////////////////////////////////////////////////////////////////////// +// Basic object model + +struct CRuntimeClass +{ +// Attributes + LPCSTR m_lpszClassName; + int m_nObjectSize; + UINT m_wSchema; // schema number of the loaded class + CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class +#ifdef _AFXDLL + CRuntimeClass* (PASCAL* m_pfnGetBaseClass)(); +#else + CRuntimeClass* m_pBaseClass; +#endif + +// Operations + CObject* CreateObject(); + BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const; + +// Implementation + void Store(CArchive& ar) const; + static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum); + + // CRuntimeClass objects linked together in simple list + CRuntimeClass* m_pNextClass; // linked list of registered classes +}; + +///////////////////////////////////////////////////////////////////////////// +// Strings + +#ifndef _OLEAUTO_H_ +#ifdef OLE2ANSI + typedef LPSTR BSTR; +#else + typedef LPWSTR BSTR;// must (semantically) match typedef in oleauto.h +#endif +#endif + +struct CStringData +{ + long nRefs; // reference count + int nDataLength; + int nAllocLength; + // TCHAR data[nAllocLength] + + TCHAR* data() + { return (TCHAR*)(this+1); } +}; + +class CString +{ +public: +// Constructors + CString(); + CString(const CString& stringSrc); + CString(TCHAR ch, int nRepeat = 1); + CString(LPCSTR lpsz); + CString(LPCWSTR lpsz); + CString(LPCTSTR lpch, int nLength); + CString(const unsigned char* psz); + +// Attributes & Operations + // as an array of characters + int GetLength() const; + BOOL IsEmpty() const; + void Empty(); // free up the data + + TCHAR GetAt(int nIndex) const; // 0 based + TCHAR operator[](int nIndex) const; // same as GetAt + void SetAt(int nIndex, TCHAR ch); + operator LPCTSTR() const; // as a C string + + // overloaded assignment + const CString& operator=(const CString& stringSrc); + const CString& operator=(TCHAR ch); +#ifdef _UNICODE + const CString& operator=(char ch); +#endif + const CString& operator=(LPCSTR lpsz); + const CString& operator=(LPCWSTR lpsz); + const CString& operator=(const unsigned char* psz); + + // string concatenation + const CString& operator+=(const CString& string); + const CString& operator+=(TCHAR ch); +#ifdef _UNICODE + const CString& operator+=(char ch); +#endif + const CString& operator+=(LPCTSTR lpsz); + + friend CString AFXAPI operator+(const CString& string1, + const CString& string2); + friend CString AFXAPI operator+(const CString& string, TCHAR ch); + friend CString AFXAPI operator+(TCHAR ch, const CString& string); +#ifdef _UNICODE + friend CString AFXAPI operator+(const CString& string, char ch); + friend CString AFXAPI operator+(char ch, const CString& string); +#endif + friend CString AFXAPI operator+(const CString& string, LPCTSTR lpsz); + friend CString AFXAPI operator+(LPCTSTR lpsz, const CString& string); + + // string comparison + int Compare(LPCTSTR lpsz) const; // straight character + int CompareNoCase(LPCTSTR lpsz) const; // ignore case + int Collate(LPCTSTR lpsz) const; // NLS aware + + // simple sub-string extraction + CString Mid(int nFirst, int nCount) const; + CString Mid(int nFirst) const; + CString Left(int nCount) const; + CString Right(int nCount) const; + + CString SpanIncluding(LPCTSTR lpszCharSet) const; + CString SpanExcluding(LPCTSTR lpszCharSet) const; + + // upper/lower/reverse conversion + void MakeUpper(); + void MakeLower(); + void MakeReverse(); + + // trimming whitespace (either side) + void TrimRight(); + void TrimLeft(); + + // searching (return starting index, or -1 if not found) + // look for a single character match + int Find(TCHAR ch) const; // like "C" strchr + int ReverseFind(TCHAR ch) const; + int FindOneOf(LPCTSTR lpszCharSet) const; + + // look for a specific sub-string + int Find(LPCTSTR lpszSub) const; // like "C" strstr + + // simple formatting + void AFX_CDECL Format(LPCTSTR lpszFormat, ...); + void AFX_CDECL Format(UINT nFormatID, ...); + +#ifndef _MAC + // formatting for localization (uses FormatMessage API) + void AFX_CDECL FormatMessage(LPCTSTR lpszFormat, ...); + void AFX_CDECL FormatMessage(UINT nFormatID, ...); +#endif + + // input and output +#ifdef _DEBUG + friend CDumpContext& AFXAPI operator<<(CDumpContext& dc, + const CString& string); +#endif + friend CArchive& AFXAPI operator<<(CArchive& ar, const CString& string); + friend CArchive& AFXAPI operator>>(CArchive& ar, CString& string); + + // Windows support + BOOL LoadString(UINT nID); // load from string resource + // 255 chars max +#ifndef _UNICODE + // ANSI <-> OEM support (convert string in place) + void AnsiToOem(); + void OemToAnsi(); +#endif + +#ifndef _AFX_NO_BSTR_SUPPORT + // OLE BSTR support (use for OLE automation) + BSTR AllocSysString() const; + BSTR SetSysString(BSTR* pbstr) const; +#endif + + // Access to string implementation buffer as "C" character array + LPTSTR GetBuffer(int nMinBufLength); + void ReleaseBuffer(int nNewLength = -1); + LPTSTR GetBufferSetLength(int nNewLength); + void FreeExtra(); + + // Use LockBuffer/UnlockBuffer to turn refcounting off + LPTSTR LockBuffer(); + void UnlockBuffer(); + +// Implementation +public: + ~CString(); + int GetAllocLength() const; + +protected: + LPTSTR m_pchData; // pointer to ref counted string data + + // implementation helpers + CStringData* GetData() const; + void Init(); + void AllocCopy(CString& dest, int nCopyLen, int nCopyIndex, int nExtraLen) const; + void AllocBuffer(int nLen); + void AssignCopy(int nSrcLen, LPCTSTR lpszSrcData); + void ConcatCopy(int nSrc1Len, LPCTSTR lpszSrc1Data, int nSrc2Len, LPCTSTR lpszSrc2Data); + void ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData); + void FormatV(LPCTSTR lpszFormat, va_list argList); + void CopyBeforeWrite(); + void AllocBeforeWrite(int nLen); + void Release(); + static void PASCAL Release(CStringData* pData); + static int PASCAL SafeStrlen(LPCTSTR lpsz); +}; + +// Compare helpers +BOOL AFXAPI operator==(const CString& s1, const CString& s2); +BOOL AFXAPI operator==(const CString& s1, LPCTSTR s2); +BOOL AFXAPI operator==(LPCTSTR s1, const CString& s2); +BOOL AFXAPI operator!=(const CString& s1, const CString& s2); +BOOL AFXAPI operator!=(const CString& s1, LPCTSTR s2); +BOOL AFXAPI operator!=(LPCTSTR s1, const CString& s2); +BOOL AFXAPI operator<(const CString& s1, const CString& s2); +BOOL AFXAPI operator<(const CString& s1, LPCTSTR s2); +BOOL AFXAPI operator<(LPCTSTR s1, const CString& s2); +BOOL AFXAPI operator>(const CString& s1, const CString& s2); +BOOL AFXAPI operator>(const CString& s1, LPCTSTR s2); +BOOL AFXAPI operator>(LPCTSTR s1, const CString& s2); +BOOL AFXAPI operator<=(const CString& s1, const CString& s2); +BOOL AFXAPI operator<=(const CString& s1, LPCTSTR s2); +BOOL AFXAPI operator<=(LPCTSTR s1, const CString& s2); +BOOL AFXAPI operator>=(const CString& s1, const CString& s2); +BOOL AFXAPI operator>=(const CString& s1, LPCTSTR s2); +BOOL AFXAPI operator>=(LPCTSTR s1, const CString& s2); + +// conversion helpers +int AFX_CDECL _wcstombsz(char* mbstr, const wchar_t* wcstr, size_t count); +int AFX_CDECL _mbstowcsz(wchar_t* wcstr, const char* mbstr, size_t count); + +// Globals +extern AFX_DATA TCHAR afxChNil; +const CString& AFXAPI AfxGetEmptyString(); +#define afxEmptyString AfxGetEmptyString() + +///////////////////////////////////////////////////////////////////////////// +// class CObject is the root of all compliant objects + +class CObject +{ +public: + +// Object model (types, destruction, allocation) + virtual CRuntimeClass* GetRuntimeClass() const; + virtual ~CObject(); // virtual destructors are necessary + + // Diagnostic allocations + void* PASCAL operator new(size_t nSize); + void* PASCAL operator new(size_t, void* p); + void PASCAL operator delete(void* p); + +#if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT) + // for file name/line number tracking using DEBUG_NEW + void* PASCAL operator new(size_t nSize, LPCSTR lpszFileName, int nLine); +#endif + + // Disable the copy constructor and assignment by default so you will get + // compiler errors instead of unexpected behaviour if you pass objects + // by value or assign objects. +protected: + CObject(); +private: + CObject(const CObject& objectSrc); // no implementation + void operator=(const CObject& objectSrc); // no implementation + +// Attributes +public: + BOOL IsSerializable() const; + BOOL IsKindOf(const CRuntimeClass* pClass) const; + +// Overridables + virtual void Serialize(CArchive& ar); + + // Diagnostic Support + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; + +// Implementation +public: + static const AFX_DATA CRuntimeClass classCObject; +#ifdef _AFXDLL + static CRuntimeClass* PASCAL _GetBaseClass(); +#endif +}; + +// Helper macros +#define RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name)) +#define ASSERT_KINDOF(class_name, object) \ + ASSERT((object)->IsKindOf(RUNTIME_CLASS(class_name))) + +// RTTI helper macros/functions +const CObject* AFX_CDECL AfxDynamicDownCast(CRuntimeClass* pClass, const CObject* pObject); +CObject* AFX_CDECL AfxDynamicDownCast(CRuntimeClass* pClass, CObject* pObject); +#define DYNAMIC_DOWNCAST(class_name, object) \ + (class_name*)AfxDynamicDownCast(RUNTIME_CLASS(class_name), object) + +#ifdef _DEBUG +const CObject* AFX_CDECL AfxStaticDownCast(CRuntimeClass* pClass, const CObject* pObject); +CObject* AFX_CDECL AfxStaticDownCast(CRuntimeClass* pClass, CObject* pObject); +#define STATIC_DOWNCAST(class_name, object) \ + ((class_name*)AfxStaticDownCast(RUNTIME_CLASS(class_name), object)) +#else +#define STATIC_DOWNCAST(class_name, object) ((class_name*)object) +#endif + +////////////////////////////////////////////////////////////////////////////// +// Helper macros for declaring CRuntimeClass compatible classes + +#ifdef _AFXDLL +#define DECLARE_DYNAMIC(class_name) \ +protected: \ + static CRuntimeClass* PASCAL _GetBaseClass(); \ +public: \ + static const AFX_DATA CRuntimeClass class##class_name; \ + virtual CRuntimeClass* GetRuntimeClass() const; \ + +#define _DECLARE_DYNAMIC(class_name) \ +protected: \ + static CRuntimeClass* PASCAL _GetBaseClass(); \ +public: \ + static AFX_DATA CRuntimeClass class##class_name; \ + virtual CRuntimeClass* GetRuntimeClass() const; \ + +#else +#define DECLARE_DYNAMIC(class_name) \ +public: \ + static const AFX_DATA CRuntimeClass class##class_name; \ + virtual CRuntimeClass* GetRuntimeClass() const; \ + +#define _DECLARE_DYNAMIC(class_name) \ +public: \ + static AFX_DATA CRuntimeClass class##class_name; \ + virtual CRuntimeClass* GetRuntimeClass() const; \ + +#endif + +// not serializable, but dynamically constructable +#define DECLARE_DYNCREATE(class_name) \ + DECLARE_DYNAMIC(class_name) \ + static CObject* PASCAL CreateObject(); + +#define _DECLARE_DYNCREATE(class_name) \ + _DECLARE_DYNAMIC(class_name) \ + static CObject* PASCAL CreateObject(); + +#define DECLARE_SERIAL(class_name) \ + _DECLARE_DYNCREATE(class_name) \ + friend CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb); + +// generate static object constructor for class registration +struct AFX_CLASSINIT + { AFX_CLASSINIT(CRuntimeClass* pNewClass); }; + +#ifdef _AFXDLL +#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ + CRuntimeClass* PASCAL class_name::_GetBaseClass() \ + { return RUNTIME_CLASS(base_class_name); } \ + const AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ + #class_name, sizeof(class class_name), wSchema, pfnNew, \ + &class_name::_GetBaseClass, NULL }; \ + CRuntimeClass* class_name::GetRuntimeClass() const \ + { return RUNTIME_CLASS(class_name); } \ + +#define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ + CRuntimeClass* PASCAL class_name::_GetBaseClass() \ + { return RUNTIME_CLASS(base_class_name); } \ + AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ + #class_name, sizeof(class class_name), wSchema, pfnNew, \ + &class_name::_GetBaseClass, NULL }; \ + CRuntimeClass* class_name::GetRuntimeClass() const \ + { return RUNTIME_CLASS(class_name); } \ + +#else +#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ + const AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ + #class_name, sizeof(class class_name), wSchema, pfnNew, \ + RUNTIME_CLASS(base_class_name), NULL }; \ + CRuntimeClass* class_name::GetRuntimeClass() const \ + { return RUNTIME_CLASS(class_name); } \ + +#define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \ + AFX_DATADEF CRuntimeClass class_name::class##class_name = { \ + #class_name, sizeof(class class_name), wSchema, pfnNew, \ + RUNTIME_CLASS(base_class_name), NULL }; \ + CRuntimeClass* class_name::GetRuntimeClass() const \ + { return RUNTIME_CLASS(class_name); } \ + +#endif + +#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \ + IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL) + +#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \ + CObject* PASCAL class_name::CreateObject() \ + { return new class_name; } \ + IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \ + class_name::CreateObject) + +#define IMPLEMENT_SERIAL(class_name, base_class_name, wSchema) \ + CObject* PASCAL class_name::CreateObject() \ + { return new class_name; } \ + _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, \ + class_name::CreateObject) \ + static const AFX_CLASSINIT _init_##class_name(RUNTIME_CLASS(class_name)); \ + CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb) \ + { pOb = (class_name*) ar.ReadObject(RUNTIME_CLASS(class_name)); \ + return ar; } \ + +// optional bit for schema number that enables object versioning +#define VERSIONABLE_SCHEMA (0x80000000) + +///////////////////////////////////////////////////////////////////////////// +// other helpers + +// zero fill everything after the vtbl pointer +#define AFX_ZERO_INIT_OBJECT(base_class) \ + memset(((base_class*)this)+1, 0, sizeof(*this) - sizeof(class base_class)); + + +///////////////////////////////////////////////////////////////////////////// +// Exceptions + +class CException : public CObject +{ + // abstract class for dynamic type checking + DECLARE_DYNAMIC(CException) + +public: +// Constructors + CException(); // sets m_bAutoDelete = TRUE + CException(BOOL bAutoDelete); // sets m_bAutoDelete = bAutoDelete + +// Operations + void Delete(); // use to delete exception in 'catch' block + + virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, + PUINT pnHelpContext = NULL); + virtual int ReportError(UINT nType = MB_OK, UINT nMessageID = 0); + +// Implementation (setting m_bAutoDelete to FALSE is advanced) +public: + virtual ~CException(); + BOOL m_bAutoDelete; +#ifdef _DEBUG + void PASCAL operator delete(void* p); +protected: + BOOL m_bReadyForDelete; +#endif +}; + +class CSimpleException : public CException +{ + // base class for resource-critical MFC exceptions + // handles ownership and initialization of an error message + +public: +// Constructors + CSimpleException(); + CSimpleException(BOOL bAutoDelete); + +// Operations + virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, + PUINT pnHelpContext = NULL); + +// Implementation (setting m_bAutoDelete to FALSE is advanced) +public: + virtual ~CSimpleException(); + BOOL m_bAutoDelete; + + void InitString(); // used during MFC initialization + +protected: + BOOL m_bInitialized; + BOOL m_bLoaded; + TCHAR m_szMessage[128]; + UINT m_nResourceID; + +#ifdef _DEBUG + BOOL m_bReadyForDelete; +#endif +}; + +// helper routines for non-C++ EH implementations +#ifdef _AFX_OLD_EXCEPTIONS + BOOL AFXAPI AfxCatchProc(CRuntimeClass* pClass); + void AFXAPI AfxThrow(CException* pException); +#else + // for THROW_LAST auto-delete backward compatiblity + void AFXAPI AfxThrowLastCleanup(); +#endif + +// other out-of-line helper functions +void AFXAPI AfxTryCleanup(); + +#ifndef _AFX_JUMPBUF +// Use portable 'jmp_buf' defined by ANSI by default. +#define _AFX_JUMPBUF jmp_buf +#endif + +// Placed on frame for EXCEPTION linkage, or CException cleanup +struct AFX_EXCEPTION_LINK +{ +#ifdef _AFX_OLD_EXCEPTIONS + union + { + _AFX_JUMPBUF m_jumpBuf; + struct + { + void (PASCAL* pfnCleanup)(AFX_EXCEPTION_LINK* pLink); + void* pvData; // extra data follows + } m_callback; // callback for cleanup (nType != 0) + }; + UINT m_nType; // 0 for setjmp, !=0 for user extension +#endif //!_AFX_OLD_EXCEPTIONS + + AFX_EXCEPTION_LINK* m_pLinkPrev; // previous top, next in handler chain + CException* m_pException; // current exception (NULL in TRY block) + + AFX_EXCEPTION_LINK(); // for initialization and linking + ~AFX_EXCEPTION_LINK() // for cleanup and unlinking + { AfxTryCleanup(); }; +}; + +// Exception global state - never access directly +struct AFX_EXCEPTION_CONTEXT +{ + AFX_EXCEPTION_LINK* m_pLinkTop; + + // Note: most of the exception context is now in the AFX_EXCEPTION_LINK +}; + +#ifndef _PNH_DEFINED +typedef int (__cdecl * _PNH)( size_t ); +#define _PNH_DEFINED +#endif + +_PNH AFXAPI AfxGetNewHandler(); +_PNH AFXAPI AfxSetNewHandler(_PNH pfnNewHandler); +int AFX_CDECL AfxNewHandler(size_t nSize); + +void AFXAPI AfxAbort(); + +#ifdef _AFX_OLD_EXCEPTIONS + +// Obsolete and non-portable: setting terminate handler +// use CWinApp::ProcessWndProcException for Windows apps instead +// can also use set_terminate which is part of C++ standard library +// (these are provided for backward compatibility) +void AFXAPI AfxTerminate(); +typedef void (AFXAPI* AFX_TERM_PROC)(); +AFX_TERM_PROC AFXAPI AfxSetTerminate(AFX_TERM_PROC); + +#endif + +///////////////////////////////////////////////////////////////////////////// +// Exception macros using try, catch and throw +// (for backward compatibility to previous versions of MFC) + +#ifndef _AFX_OLD_EXCEPTIONS + +#define TRY { AFX_EXCEPTION_LINK _afxExceptionLink; try { + +#define CATCH(class, e) } catch (class* e) \ + { ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \ + _afxExceptionLink.m_pException = e; + +#define AND_CATCH(class, e) } catch (class* e) \ + { ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \ + _afxExceptionLink.m_pException = e; + +#define END_CATCH } } + +#define THROW(e) throw e +#define THROW_LAST() (AfxThrowLastCleanup(), throw) + +// Advanced macros for smaller code +#define CATCH_ALL(e) } catch (CException* e) \ + { { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \ + _afxExceptionLink.m_pException = e; + +#define AND_CATCH_ALL(e) } catch (CException* e) \ + { { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \ + _afxExceptionLink.m_pException = e; + +#define END_CATCH_ALL } } } + +#define END_TRY } catch (CException* e) \ + { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \ + _afxExceptionLink.m_pException = e; } } + +#else //_AFX_OLD_EXCEPTIONS + +///////////////////////////////////////////////////////////////////////////// +// Exception macros using setjmp and longjmp +// (for portability to compilers with no support for C++ exception handling) + +#define TRY \ + { AFX_EXCEPTION_LINK _afxExceptionLink; \ + if (::setjmp(_afxExceptionLink.m_jumpBuf) == 0) + +#define CATCH(class, e) \ + else if (::AfxCatchProc(RUNTIME_CLASS(class))) \ + { class* e = (class*)_afxExceptionLink.m_pException; + +#define AND_CATCH(class, e) \ + } else if (::AfxCatchProc(RUNTIME_CLASS(class))) \ + { class* e = (class*)_afxExceptionLink.m_pException; + +#define END_CATCH \ + } else { ::AfxThrow(NULL); } } + +#define THROW(e) AfxThrow(e) +#define THROW_LAST() AfxThrow(NULL) + +// Advanced macros for smaller code +#define CATCH_ALL(e) \ + else { CException* e = _afxExceptionLink.m_pException; + +#define AND_CATCH_ALL(e) \ + } else { CException* e = _afxExceptionLink.m_pException; + +#define END_CATCH_ALL } } + +#define END_TRY } + +#endif //_AFX_OLD_EXCEPTIONS + +///////////////////////////////////////////////////////////////////////////// +// Standard Exception classes + +class CMemoryException : public CSimpleException +{ + DECLARE_DYNAMIC(CMemoryException) +public: + CMemoryException(); + +// Implementation +public: + CMemoryException(BOOL bAutoDelete); + CMemoryException(BOOL bAutoDelete, UINT nResourceID); + virtual ~CMemoryException(); +}; + +class CNotSupportedException : public CSimpleException +{ + DECLARE_DYNAMIC(CNotSupportedException) +public: + CNotSupportedException(); + +// Implementation +public: + CNotSupportedException(BOOL bAutoDelete); + CNotSupportedException(BOOL bAutoDelete, UINT nResourceID); + virtual ~CNotSupportedException(); +}; + +class CArchiveException : public CException +{ + DECLARE_DYNAMIC(CArchiveException) +public: + enum { + none, + generic, + readOnly, + endOfFile, + writeOnly, + badIndex, + badClass, + badSchema + }; + +// Constructor + CArchiveException(int cause = CArchiveException::none, + LPCTSTR lpszArchiveName = NULL); + +// Attributes + int m_cause; + CString m_strFileName; + +// Implementation +public: + virtual ~CArchiveException(); +#ifdef _DEBUG + virtual void Dump(CDumpContext& dc) const; +#endif + virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, + PUINT pnHelpContext = NULL); +}; + +class CFileException : public CException +{ + DECLARE_DYNAMIC(CFileException) + +public: + enum { + none, + generic, + fileNotFound, + badPath, + tooManyOpenFiles, + accessDenied, + invalidFile, + removeCurrentDir, + directoryFull, + badSeek, + hardIO, + sharingViolation, + lockViolation, + diskFull, + endOfFile + }; + +// Constructor + CFileException(int cause = CFileException::none, LONG lOsError = -1, + LPCTSTR lpszArchiveName = NULL); + +// Attributes + int m_cause; + LONG m_lOsError; + CString m_strFileName; + +// Operations + // convert a OS dependent error code to a Cause + static int PASCAL OsErrorToException(LONG lOsError); + static int PASCAL ErrnoToException(int nErrno); + + // helper functions to throw exception after converting to a Cause + static void PASCAL ThrowOsError(LONG lOsError, LPCTSTR lpszFileName = NULL); + static void PASCAL ThrowErrno(int nErrno, LPCTSTR lpszFileName = NULL); + +// Implementation +public: + virtual ~CFileException(); +#ifdef _DEBUG + virtual void Dump(CDumpContext&) const; +#endif + virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, + PUINT pnHelpContext = NULL); +}; + +///////////////////////////////////////////////////////////////////////////// +// Standard exception throws + +void AFXAPI AfxThrowMemoryException(); +void AFXAPI AfxThrowNotSupportedException(); +void AFXAPI AfxThrowArchiveException(int cause, + LPCTSTR lpszArchiveName = NULL); +void AFXAPI AfxThrowFileException(int cause, LONG lOsError = -1, + LPCTSTR lpszFileName = NULL); + +///////////////////////////////////////////////////////////////////////////// +// File - raw unbuffered disk file I/O + +class CFile : public CObject +{ + DECLARE_DYNAMIC(CFile) + +public: +// Flag values + enum OpenFlags { + modeRead = 0x0000, + modeWrite = 0x0001, + modeReadWrite = 0x0002, + shareCompat = 0x0000, + shareExclusive = 0x0010, + shareDenyWrite = 0x0020, + shareDenyRead = 0x0030, + shareDenyNone = 0x0040, + modeNoInherit = 0x0080, + modeCreate = 0x1000, + modeNoTruncate = 0x2000, + typeText = 0x4000, // typeText and typeBinary are used in + typeBinary = (int)0x8000 // derived classes only + }; + + enum Attribute { + normal = 0x00, + readOnly = 0x01, + hidden = 0x02, + system = 0x04, + volume = 0x08, + directory = 0x10, + archive = 0x20 + }; + + enum SeekPosition { begin = 0x0, current = 0x1, end = 0x2 }; + + enum { hFileNull = -1 }; + +// Constructors + CFile(); + CFile(int hFile); + CFile(LPCTSTR lpszFileName, UINT nOpenFlags); + +// Attributes + UINT m_hFile; + operator HFILE() const; + + virtual DWORD GetPosition() const; + BOOL GetStatus(CFileStatus& rStatus) const; + virtual CString GetFileName() const; + virtual CString GetFileTitle() const; + virtual CString GetFilePath() const; + virtual void SetFilePath(LPCTSTR lpszNewName); + +// Operations + virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, + CFileException* pError = NULL); + + static void PASCAL Rename(LPCTSTR lpszOldName, + LPCTSTR lpszNewName); + static void PASCAL Remove(LPCTSTR lpszFileName); + static BOOL PASCAL GetStatus(LPCTSTR lpszFileName, + CFileStatus& rStatus); + static void PASCAL SetStatus(LPCTSTR lpszFileName, + const CFileStatus& status); + + DWORD SeekToEnd(); + void SeekToBegin(); + + // backward compatible ReadHuge and WriteHuge + DWORD ReadHuge(void* lpBuffer, DWORD dwCount); + void WriteHuge(const void* lpBuffer, DWORD dwCount); + +// Overridables + virtual CFile* Duplicate() const; + + virtual LONG Seek(LONG lOff, UINT nFrom); + virtual void SetLength(DWORD dwNewLen); + virtual DWORD GetLength() const; + + virtual UINT Read(void* lpBuf, UINT nCount); + virtual void Write(const void* lpBuf, UINT nCount); + + virtual void LockRange(DWORD dwPos, DWORD dwCount); + virtual void UnlockRange(DWORD dwPos, DWORD dwCount); + + virtual void Abort(); + virtual void Flush(); + virtual void Close(); + +// Implementation +public: + virtual ~CFile(); +#ifdef _DEBUG + virtual void AssertValid() const; + virtual void Dump(CDumpContext& dc) const; +#endif + enum BufferCommand { bufferRead, bufferWrite, bufferCommit, bufferCheck }; + virtual UINT GetBufferPtr(UINT nCommand, UINT nCount = 0, + void** ppBufStart = NULL, void** ppBufMax = NULL); + +protected: + BOOL m_bCloseOnDelete; + CString m_strFileName; +}; + +///////////////////////////////////////////////////////////////////////////// +// STDIO file implementation + +class CStdioFile : public CFile +{ + DECLARE_DYNAMIC(CStdioFile) + +public: +// Constructors + CStdioFile(); + CStdioFile(FILE* pOpenStream); + CStdioFile(LPCTSTR lpszFileName, UINT nOpenFlags); + +// Attributes + FILE* m_pStream; // stdio FILE + // m_hFile from base class is _fileno(m_pStream) + +// Operations + // reading and writing strings + virtual void WriteString(LPCTSTR lpsz); + virtual LPTSTR ReadString(LPTSTR lpsz, UINT nMax); + virtual BOOL ReadString(CString& rString); + +// Implementation +public: + virtual ~CStdioFile(); +#ifdef _DEBUG + void Dump(CDumpContext& dc) const; +#endif + virtual DWORD GetPosition() const; + virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, + CFileException* pError = NULL); + virtual UINT Read(void* lpBuf, UINT nCount); + virtual void Write(const void* lpBuf, UINT nCount); + virtual LONG Seek(LONG lOff, UINT nFrom); + virtual void Abort(); + virtual void Flush(); + virtual void Close(); + + // Unsupported APIs + virtual CFile* Duplicate() const; + virtual void LockRange(DWORD dwPos, DWORD dwCount); + virtual void UnlockRange(DWORD dwPos, DWORD dwCount); +}; + +//////////////////////////////////////////////////////////////////////////// +// Memory based file implementation + +class CMemFile : public CFile +{ + DECLARE_DYNAMIC(CMemFile) + +public: +// Constructors + CMemFile(UINT nGrowBytes = 1024); + CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0); + +// Operations + void Attach(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0); + BYTE* Detach(); + +// Advanced Overridables +protected: + virtual BYTE* Alloc(DWORD nBytes); + virtual BYTE* Realloc(BYTE* lpMem, DWORD nBytes); + virtual BYTE* Memcpy(BYTE* lpMemTarget, const BYTE* lpMemSource, UINT nBytes); + virtual void Free(BYTE* lpMem); + virtual void GrowFile(DWORD dwNewLen); + +// Implementation +protected: + UINT m_nGrowBytes; + DWORD m_nPosition; + DWORD m_nBufferSize; + DWORD m_nFileSize; + BYTE* m_lpBuffer; + BOOL m_bAutoDelete; + +public: + virtual ~CMemFile(); +#ifdef _DEBUG + virtual void Dump(CDumpContext& dc) const; + virtual void AssertValid() const; +#endif + virtual DWORD GetPosition() const; + BOOL GetStatus(CFileStatus& rStatus) const; + virtual LONG Seek(LONG lOff, UINT nFrom); + virtual void SetLength(DWORD dwNewLen); + virtual UINT Read(void* lpBuf, UINT nCount); + virtual void Write(const void* lpBuf, UINT nCount); + virtual void Abort(); + virtual void Flush(); + virtual void Close(); + virtual UINT GetBufferPtr(UINT nCommand, UINT nCount = 0, + void** ppBufStart = NULL, void** ppBufMax = NULL); + + // Unsupported APIs + virtual CFile* Duplicate() const; + virtual void LockRange(DWORD dwPos, DWORD dwCount); + virtual void UnlockRange(DWORD dwPos, DWORD dwCount); +}; + +#ifndef _MAC + +//////////////////////////////////////////////////////////////////////////// +// Local file searches + +class CFileFind : public CObject +{ +public: + CFileFind(); + virtual ~CFileFind(); + +// Attributes +public: + DWORD GetLength() const; +#if defined(_X86_) || defined(_ALPHA_) + __int64 GetLength64() const; +#endif + virtual CString GetFileName() const; + virtual CString GetFilePath() const; + virtual CString GetFileTitle() const; + virtual CString GetFileURL() const; + virtual CString GetRoot() const; + + virtual BOOL GetLastWriteTime(FILETIME* pTimeStamp) const; + virtual BOOL GetLastAccessTime(FILETIME* pTimeStamp) const; + virtual BOOL GetCreationTime(FILETIME* pTimeStamp) const; + virtual BOOL GetLastWriteTime(CTime& refTime) const; + virtual BOOL GetLastAccessTime(CTime& refTime) const; + virtual BOOL GetCreationTime(CTime& refTime) const; + + virtual BOOL MatchesMask(DWORD dwMask) const; + + virtual BOOL IsDots() const; + // these aren't virtual because they all use MatchesMask(), which is + BOOL IsReadOnly() const; + BOOL IsDirectory() const; + BOOL IsCompressed() const; + BOOL IsSystem() const; + BOOL IsHidden() const; + BOOL IsTemporary() const; + BOOL IsNormal() const; + BOOL IsArchived() const; + +// Operations + void Close(); + virtual BOOL FindFile(LPCTSTR pstrName = NULL, DWORD dwUnused = 0); + virtual BOOL FindNextFile(); + +protected: + virtual void CloseContext(); + +// Implementation +protected: + void* m_pFoundInfo; + void* m_pNextInfo; + HANDLE m_hContext; + BOOL m_bGotLast; + CString m_strRoot; + TCHAR m_chDirSeparator; // not '\\' for Internet classes + +#ifdef _DEBUG + void Dump(CDumpContext& dc) const; + void AssertValid() const; +#endif + + DECLARE_DYNAMIC(CFileFind) +}; + +#endif + +///////////////////////////////////////////////////////////////////////////// +// CTimeSpan and CTime + +class CTimeSpan +{ +public: + +// Constructors + CTimeSpan(); + CTimeSpan(time_t time); + CTimeSpan(LONG lDays, int nHours, int nMins, int nSecs); + + CTimeSpan(const CTimeSpan& timeSpanSrc); + const CTimeSpan& operator=(const CTimeSpan& timeSpanSrc); + +// Attributes + // extract parts + LONG GetDays() const; // total # of days + LONG GetTotalHours() const; + int GetHours() const; + LONG GetTotalMinutes() const; + int GetMinutes() const; + LONG GetTotalSeconds() const; + int GetSeconds() const; + +// Operations + // time math + CTimeSpan operator-(CTimeSpan timeSpan) const; + CTimeSpan operator+(CTimeSpan timeSpan) const; + const CTimeSpan& operator+=(CTimeSpan timeSpan); + const CTimeSpan& operator-=(CTimeSpan timeSpan); + BOOL operator==(CTimeSpan timeSpan) const; + BOOL operator!=(CTimeSpan timeSpan) const; + BOOL operator<(CTimeSpan timeSpan) const; + BOOL operator>(CTimeSpan timeSpan) const; + BOOL operator<=(CTimeSpan timeSpan) const; + BOOL operator>=(CTimeSpan timeSpan) const; + +#ifdef _UNICODE + // for compatibility with MFC 3.x + CString Format(LPCSTR pFormat) const; +#endif + CString Format(LPCTSTR pFormat) const; + CString Format(UINT nID) const; + + // serialization +#ifdef _DEBUG + friend CDumpContext& AFXAPI operator<<(CDumpContext& dc,CTimeSpan timeSpan); +#endif + friend CArchive& AFXAPI operator<<(CArchive& ar, CTimeSpan timeSpan); + friend CArchive& AFXAPI operator>>(CArchive& ar, CTimeSpan& rtimeSpan); + +private: + time_t m_timeSpan; + friend class CTime; +}; + +class CTime +{ +public: + +// Constructors + static CTime PASCAL GetCurrentTime(); + + CTime(); + CTime(time_t time); + CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec, + int nDST = -1); + CTime(WORD wDosDate, WORD wDosTime, int nDST = -1); + CTime(const CTime& timeSrc); + + CTime(const SYSTEMTIME& sysTime, int nDST = -1); + CTime(const FILETIME& fileTime, int nDST = -1); + const CTime& operator=(const CTime& timeSrc); + const CTime& operator=(time_t t); + +// Attributes + struct tm* GetGmtTm(struct tm* ptm = NULL) const; + struct tm* GetLocalTm(struct tm* ptm = NULL) const; + + time_t GetTime() const; + int GetYear() const; + int GetMonth() const; // month of year (1 = Jan) + int GetDay() const; // day of month + int GetHour() const; + int GetMinute() const; + int GetSecond() const; + int GetDayOfWeek() const; // 1=Sun, 2=Mon, ..., 7=Sat + +// Operations + // time math + CTimeSpan operator-(CTime time) const; + CTime operator-(CTimeSpan timeSpan) const; + CTime operator+(CTimeSpan timeSpan) const; + const CTime& operator+=(CTimeSpan timeSpan); + const CTime& operator-=(CTimeSpan timeSpan); + BOOL operator==(CTime time) const; + BOOL operator!=(CTime time) const; + BOOL operator<(CTime time) const; + BOOL operator>(CTime time) const; + BOOL operator<=(CTime time) const; + BOOL operator>=(CTime time) const; + + // formatting using "C" strftime + CString Format(LPCTSTR pFormat) const; + CString FormatGmt(LPCTSTR pFormat) const; + CString Format(UINT nFormatID) const; + CString FormatGmt(UINT nFormatID) const; + +#ifdef _UNICODE + // for compatibility with MFC 3.x + CString Format(LPCSTR pFormat) const; + CString FormatGmt(LPCSTR pFormat) const; +#endif + + // serialization +#ifdef _DEBUG + friend CDumpContext& AFXAPI operator<<(CDumpContext& dc, CTime time); +#endif + friend CArchive& AFXAPI operator<<(CArchive& ar, CTime time); + friend CArchive& AFXAPI operator>>(CArchive& ar, CTime& rtime); + +private: + time_t m_time; +}; + +///////////////////////////////////////////////////////////////////////////// +// File status + +struct CFileStatus +{ + CTime m_ctime; // creation date/time of file + CTime m_mtime; // last modification date/time of file + CTime m_atime; // last access date/time of file + LONG m_size; // logical size of file in bytes + BYTE m_attribute; // logical OR of CFile::Attribute enum values + BYTE _m_padding; // pad the structure to a WORD + TCHAR m_szFullName[_MAX_PATH]; // absolute path name + +#ifdef _DEBUG + void Dump(CDumpContext& dc) const; +#endif +}; + +///////////////////////////////////////////////////////////////////////////// +// Diagnostic memory management routines + +// Low level sanity checks for memory blocks +BOOL AFXAPI AfxIsValidAddress(const void* lp, + UINT nBytes, BOOL bReadWrite = TRUE); +BOOL AFXAPI AfxIsValidString(LPCWSTR lpsz, int nLength = -1); +BOOL AFXAPI AfxIsValidString(LPCSTR lpsz, int nLength = -1); + +#if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT) + +// Memory tracking allocation +void* AFX_CDECL operator new(size_t nSize, LPCSTR lpszFileName, int nLine); +#define DEBUG_NEW new(THIS_FILE, __LINE__) + +void* AFXAPI AfxAllocMemoryDebug(size_t nSize, BOOL bIsObject, + LPCSTR lpszFileName, int nLine); +void AFXAPI AfxFreeMemoryDebug(void* pbData, BOOL bIsObject); + +// Dump any memory leaks since program started +BOOL AFXAPI AfxDumpMemoryLeaks(); + +// Return TRUE if valid memory block of nBytes +BOOL AFXAPI AfxIsMemoryBlock(const void* p, UINT nBytes, + LONG* plRequestNumber = NULL); + +// Return TRUE if memory is sane or print out what is wrong +BOOL AFXAPI AfxCheckMemory(); + +#define afxMemDF _crtDbgFlag + +enum AfxMemDF // memory debug/diagnostic flags +{ + allocMemDF = 0x01, // turn on debugging allocator + delayFreeMemDF = 0x02, // delay freeing memory + checkAlwaysMemDF = 0x04 // AfxCheckMemory on every alloc/free +}; + +#ifdef _UNICODE +#define AfxOutputDebugString(lpsz) \ + do \ + { \ + int _convert; _convert = 0; \ + _RPT0(_CRT_WARN, W2CA(lpsz)); \ + } while (0) +#else +#define AfxOutputDebugString(lpsz) _RPT0(_CRT_WARN, lpsz) +#endif + +// turn on/off tracking for a short while +BOOL AFXAPI AfxEnableMemoryTracking(BOOL bTrack); + +// Advanced initialization: for overriding default diagnostics +BOOL AFXAPI AfxDiagnosticInit(void); + +// A failure hook returns whether to permit allocation +typedef BOOL (AFXAPI* AFX_ALLOC_HOOK)(size_t nSize, BOOL bObject, LONG lRequestNumber); + +// Set new hook, return old (never NULL) +AFX_ALLOC_HOOK AFXAPI AfxSetAllocHook(AFX_ALLOC_HOOK pfnAllocHook); + +// Debugger hook on specified allocation request - Obsolete +void AFXAPI AfxSetAllocStop(LONG lRequestNumber); + +// Memory state for snapshots/leak detection +struct CMemoryState +{ +// Attributes + enum blockUsage + { + freeBlock, // memory not used + objectBlock, // contains a CObject derived class object + bitBlock, // contains ::operator new data + crtBlock, + ignoredBlock, + nBlockUseMax // total number of usages + }; + + _CrtMemState m_memState; + LONG m_lCounts[nBlockUseMax]; + LONG m_lSizes[nBlockUseMax]; + LONG m_lHighWaterCount; + LONG m_lTotalCount; + + CMemoryState(); + +// Operations + void Checkpoint(); // fill with current state + BOOL Difference(const CMemoryState& oldState, + const CMemoryState& newState); // fill with difference + void UpdateData(); + + // Output to afxDump + void DumpStatistics() const; + void DumpAllObjectsSince() const; +}; + +// Enumerate allocated objects or runtime classes +void AFXAPI AfxDoForAllObjects(void (AFX_CDECL *pfn)(CObject* pObject, void* pContext), + void* pContext); +void AFXAPI AfxDoForAllClasses(void (AFX_CDECL *pfn)(const CRuntimeClass* pClass, + void* pContext), void* pContext); + +#else + +// non-_DEBUG_ALLOC version that assume everything is OK +#define DEBUG_NEW new +#define AfxCheckMemory() TRUE +#define AfxIsMemoryBlock(p, nBytes) TRUE +#define AfxEnableMemoryTracking(bTrack) FALSE +#define AfxOutputDebugString(lpsz) ::OutputDebugString(lpsz) + +// diagnostic initialization +#ifndef _DEBUG +#define AfxDiagnosticInit() TRUE +#else +BOOL AFXAPI AfxDiagnosticInit(void); +#endif + +#endif // _DEBUG + +///////////////////////////////////////////////////////////////////////////// +// Archives for serializing CObject data + +// needed for implementation +class CPtrArray; +class CMapPtrToPtr; +class CDocument; + +class CArchive +{ +public: +// Flag values + enum Mode { store = 0, load = 1, bNoFlushOnDelete = 2, bNoByteSwap = 4 }; + + CArchive(CFile* pFile, UINT nMode, int nBufSize = 4096, void* lpBuf = NULL); + ~CArchive(); + +// Attributes + BOOL IsLoading() const; + BOOL IsStoring() const; + BOOL IsByteSwapping() const; + BOOL IsBufferEmpty() const; + + CFile* GetFile() const; + UINT GetObjectSchema(); // only valid when reading a CObject* + void SetObjectSchema(UINT nSchema); + + // pointer to document being serialized -- must set to serialize + // COleClientItems in a document! + CDocument* m_pDocument; + +// Operations + UINT Read(void* lpBuf, UINT nMax); + void Write(const void* lpBuf, UINT nMax); + void Flush(); + void Close(); + void Abort(); // close and shutdown without exceptions + + // reading and writing strings + void WriteString(LPCTSTR lpsz); + LPTSTR ReadString(LPTSTR lpsz, UINT nMax); + BOOL ReadString(CString& rString); + +public: + // Object I/O is pointer based to avoid added construction overhead. + // Use the Serialize member function directly for embedded objects. + friend CArchive& AFXAPI operator<<(CArchive& ar, const CObject* pOb); + + friend CArchive& AFXAPI operator>>(CArchive& ar, CObject*& pOb); + friend CArchive& AFXAPI operator>>(CArchive& ar, const CObject*& pOb); + + // insertion operations + CArchive& operator<<(BYTE by); + CArchive& operator<<(WORD w); + CArchive& operator<<(LONG l); + CArchive& operator<<(DWORD dw); + CArchive& operator<<(float f); + CArchive& operator<<(double d); + + CArchive& operator<<(int i); + CArchive& operator<<(short w); + CArchive& operator<<(char ch); + CArchive& operator<<(unsigned u); + + // extraction operations + CArchive& operator>>(BYTE& by); + CArchive& operator>>(WORD& w); + CArchive& operator>>(DWORD& dw); + CArchive& operator>>(LONG& l); + CArchive& operator>>(float& f); + CArchive& operator>>(double& d); + + CArchive& operator>>(int& i); + CArchive& operator>>(short& w); + CArchive& operator>>(char& ch); + CArchive& operator>>(unsigned& u); + + // object read/write + CObject* ReadObject(const CRuntimeClass* pClass); + void WriteObject(const CObject* pOb); + // advanced object mapping (used for forced references) + void MapObject(const CObject* pOb); + + // advanced versioning support + void WriteClass(const CRuntimeClass* pClassRef); + CRuntimeClass* ReadClass(const CRuntimeClass* pClassRefRequested = NULL, + UINT* pSchema = NULL, DWORD* pObTag = NULL); + void SerializeClass(const CRuntimeClass* pClassRef); + + // advanced operations (used when storing/loading many objects) + void SetStoreParams(UINT nHashSize = 2053, UINT nBlockSize = 128); + void SetLoadParams(UINT nGrowBy = 1024); + +// Implementation +public: + BOOL m_bForceFlat; // for COleClientItem implementation (default TRUE) + BOOL m_bDirectBuffer; // TRUE if m_pFile supports direct buffering + void FillBuffer(UINT nBytesNeeded); + void CheckCount(); // throw exception if m_nMapCount is too large + + // special functions for reading and writing (16-bit compatible) counts + DWORD ReadCount(); + void WriteCount(DWORD dwCount); + + // public for advanced use + UINT m_nObjectSchema; + CString m_strFileName; + +protected: + // archive objects cannot be copied or assigned + CArchive(const CArchive& arSrc); + void operator=(const CArchive& arSrc); + + BOOL m_nMode; + BOOL m_bUserBuf; + int m_nBufSize; + CFile* m_pFile; + BYTE* m_lpBufCur; + BYTE* m_lpBufMax; + BYTE* m_lpBufStart; + + // array/map for CObject* and CRuntimeClass* load/store + UINT m_nMapCount; + union + { + CPtrArray* m_pLoadArray; + CMapPtrToPtr* m_pStoreMap; + }; + // map to keep track of mismatched schemas + CMapPtrToPtr* m_pSchemaMap; + + // advanced parameters (controls performance with large archives) + UINT m_nGrowSize; + UINT m_nHashSize; +}; + +///////////////////////////////////////////////////////////////////////////// +// Diagnostic dumping + +class CDumpContext +{ +public: + CDumpContext(CFile* pFile = NULL); + +// Attributes + int GetDepth() const; // 0 => this object, 1 => children objects + void SetDepth(int nNewDepth); + +// Operations + CDumpContext& operator<<(LPCTSTR lpsz); +#ifdef _UNICODE + CDumpContext& operator<<(LPCSTR lpsz); // automatically widened +#else + CDumpContext& operator<<(LPCWSTR lpsz); // automatically thinned +#endif + CDumpContext& operator<<(const void* lp); + CDumpContext& operator<<(const CObject* pOb); + CDumpContext& operator<<(const CObject& ob); + CDumpContext& operator<<(BYTE by); + CDumpContext& operator<<(WORD w); + CDumpContext& operator<<(UINT u); + CDumpContext& operator<<(LONG l); + CDumpContext& operator<<(DWORD dw); + CDumpContext& operator<<(float f); + CDumpContext& operator<<(double d); + CDumpContext& operator<<(int n); + void HexDump(LPCTSTR lpszLine, BYTE* pby, int nBytes, int nWidth); + void Flush(); + +// Implementation +protected: + // dump context objects cannot be copied or assigned + CDumpContext(const CDumpContext& dcSrc); + void operator=(const CDumpContext& dcSrc); + void OutputString(LPCTSTR lpsz); + + int m_nDepth; + +public: + CFile* m_pFile; +}; + +#ifdef _DEBUG +extern AFX_DATA CDumpContext afxDump; +extern AFX_DATA BOOL afxTraceEnabled; +#endif + +///////////////////////////////////////////////////////////////////////////// +// Special include for Win32s compatibility + +#ifdef _AFX_PACKING +#pragma pack(pop) +#endif + +#ifndef __AFXCOLL_H__ + #include <afxcoll.h> + #ifndef __AFXSTATE_H__ + #include <afxstat_.h> // for _AFX_APP_STATE and _AFX_THREAD_STATE + #endif +#endif + +///////////////////////////////////////////////////////////////////////////// +// Inline function declarations + +#ifdef _AFX_ENABLE_INLINES +#define _AFX_INLINE inline +#include <afx.inl> +#endif + +#undef AFX_DATA +#define AFX_DATA + +#ifdef _AFX_MINREBUILD +#pragma component(minrebuild, on) +#endif +#ifndef _AFX_FULLTYPEINFO +#pragma component(mintypeinfo, off) +#endif + +#endif // __AFX_H__ + +///////////////////////////////////////////////////////////////////////////// |