home *** CD-ROM | disk | FTP | other *** search
/ Total C++ 2 / TOTALCTWO.iso / borland / mfcinc.pak / AFX.H next >
C/C++ Source or Header  |  1997-05-06  |  53KB  |  1,821 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1995 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #ifndef __AFX_H__
  12. #define __AFX_H__
  13.  
  14. #ifndef __cplusplus
  15.     #error MFC requires C++ compilation (use a .cpp suffix)
  16. #endif
  17.  
  18. /////////////////////////////////////////////////////////////////////////////
  19.  
  20. #ifdef _AFX_MINREBUILD
  21. #pragma component(minrebuild, off)
  22. #endif
  23. #ifndef _AFX_FULLTYPEINFO
  24. #pragma component(mintypeinfo, on)
  25. #endif
  26.  
  27. #include <afxver_.h>        // Target version control
  28.  
  29. #ifndef _AFX_NOFORCE_LIBS
  30. #ifndef _MAC
  31.  
  32. /////////////////////////////////////////////////////////////////////////////
  33. // Win32 libraries
  34.  
  35. #ifndef __BORLANDC__
  36. #ifndef _AFXDLL
  37.     #ifndef _UNICODE
  38.         #ifdef _DEBUG
  39.             #pragma comment(lib, "nafxcwd.lib")
  40.         #else
  41.             #pragma comment(lib, "nafxcw.lib")
  42.         #endif
  43.     #else
  44.         #ifdef _DEBUG
  45.             #pragma comment(lib, "uafxcwd.lib")
  46.         #else
  47.             #pragma comment(lib, "uafxcw.lib")
  48.         #endif
  49.     #endif
  50. #else
  51.     #ifndef _UNICODE
  52.         #ifdef _DEBUG
  53.             #pragma comment(lib, "mfc40d.lib")
  54.             #pragma comment(lib, "mfcs40d.lib")
  55.         #else
  56.             #pragma comment(lib, "mfc40.lib")
  57.             #pragma comment(lib, "mfcs40.lib")
  58.         #endif
  59.     #else
  60.         #ifdef _DEBUG
  61.             #pragma comment(lib, "mfc40ud.lib")
  62.             #pragma comment(lib, "mfcs40ud.lib")
  63.         #else
  64.             #pragma comment(lib, "mfc40u.lib")
  65.             #pragma comment(lib, "mfcs40u.lib")
  66.         #endif
  67.     #endif
  68. #endif
  69.  
  70. #ifdef _DLL
  71.     #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
  72.         #pragma comment(lib, "msvcrtd.lib")
  73.     #else
  74.         #pragma comment(lib, "msvcrt.lib")
  75.     #endif
  76. #else
  77. #ifdef _MT
  78.     #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
  79.         #pragma comment(lib, "libcmtd.lib")
  80.     #else
  81.         #pragma comment(lib, "libcmt.lib")
  82.     #endif
  83. #else
  84.     #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
  85.         #pragma comment(lib, "libcd.lib")
  86.     #else
  87.         #pragma comment(lib, "libc.lib")
  88.     #endif
  89. #endif
  90. #endif
  91.  
  92. #pragma comment(lib, "kernel32.lib")
  93. #pragma comment(lib, "user32.lib")
  94. #pragma comment(lib, "gdi32.lib")
  95. #pragma comment(lib, "comdlg32.lib")
  96. #pragma comment(lib, "winspool.lib")
  97. #pragma comment(lib, "advapi32.lib")
  98. #pragma comment(lib, "shell32.lib")
  99. #pragma comment(lib, "comctl32.lib")
  100.  
  101. #endif //!__BORLANDC__
  102. #else  //!_MAC
  103.  
  104. //////////////////////////////////////////////////////////////////////////////
  105. // Macintosh libraries
  106.  
  107. #ifndef _AFXDLL
  108.     #ifdef _DEBUG
  109.         #ifdef _68K_
  110.             #pragma comment(lib, "nafxcmd.lib")
  111.         #else
  112.             #pragma comment(lib, "nafxcpd.lib")
  113.         #endif
  114.     #else
  115.         #ifdef _68K_
  116.             #pragma comment(lib, "nafxcm.lib")
  117.         #else
  118.             #pragma comment(lib, "nafxcp.lib")
  119.         #endif
  120.     #endif
  121. #else
  122.     #ifdef _DEBUG
  123.         #ifdef _68K_
  124.             #error _AFXDLL is not supported for 68K Macintosh
  125.         #else
  126.             #pragma comment(lib, "mfc40pd.lib")
  127.             #pragma comment(lib, "mfcs40pd.lib")
  128.         #endif
  129.     #else
  130.         #ifdef _68K_
  131.             #error _AFXDLL is not supported for 68K Macintosh
  132.         #else
  133.             #pragma comment(lib, "mfc40p.lib")
  134.             #pragma comment(lib, "mfcs40p.lib")
  135.         #endif
  136.     #endif
  137. #endif
  138.  
  139. #if !defined(_AFXDLL) && !defined(_USRDLL)
  140.     #ifdef _DEBUG
  141.         #pragma comment(lib, "wlmd.lib")
  142.         #pragma comment(lib, "comctld.lib")
  143.     #else
  144.         #pragma comment(lib, "wlm.lib")
  145.         #pragma comment(lib, "comctl.lib")
  146.     #endif
  147.     #pragma comment(linker, "/macres:wlm.rsc /macres:commdlg.rsc")
  148.     #pragma comment(linker, "/macres:comctl.rsc")
  149.     #ifdef _MPPC_
  150.         #pragma comment(lib, "privint.lib")
  151.         #pragma comment(lib, "threads.lib")
  152.         #pragma comment(lib, "math.lib")
  153.     #endif
  154. #else
  155.     #ifdef _DEBUG
  156.         #pragma comment(lib, "msvcwlmd.lib")
  157.         #pragma comment(lib, "msvcctld.lib")
  158.     #else
  159.         #pragma comment(lib, "msvcwlm.lib")
  160.         #pragma comment(lib, "msvcctl.lib")
  161.     #endif
  162. #endif
  163.  
  164. #ifdef _68K_
  165.     #ifdef _DEBUG
  166.         #pragma comment(lib, "swapd.lib")
  167.     #else
  168.         #pragma comment(lib, "swap.lib")
  169.     #endif
  170.     #pragma comment(lib, "lsanes.lib")
  171.     #pragma comment(lib, "llibcs.lib")
  172.     #pragma comment(lib, "osl.lib")
  173. #endif
  174.  
  175. #ifdef _MPPC_
  176.     #ifdef _DLL
  177.         #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
  178.             #pragma comment(lib, "msvcrtd.lib")
  179.         #else
  180.             #pragma comment(lib, "msvcrt.lib")
  181.         #endif
  182.     #else
  183.         #if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
  184.             #pragma comment(lib, "libcd.lib")
  185.         #else
  186.             #pragma comment(lib, "libc.lib")
  187.         #endif
  188.     #endif
  189. #endif
  190.  
  191. #endif //_MAC
  192.  
  193. // force inclusion of NOLIB.OBJ for /disallowlib directives
  194. #pragma comment(linker, "/include:__afxForceEXCLUDE")
  195.  
  196. // force inclusion of DLLMODUL.OBJ for _USRDLL
  197. #ifdef _USRDLL
  198. #pragma comment(linker, "/include:__afxForceUSRDLL")
  199. #endif
  200.  
  201. // force inclusion of STDAFX.OBJ for precompiled types
  202. #ifdef _AFXDLL
  203. #pragma comment(linker, "/include:__afxForceSTDAFX")
  204. #endif
  205.  
  206. #endif //!_AFX_NOFORCE_LIBS
  207.  
  208. /////////////////////////////////////////////////////////////////////////////
  209. // Classes declared in this file
  210. //   in addition to standard primitive data types and various helper macros
  211.  
  212. struct CRuntimeClass;          // object type information
  213.  
  214. class CObject;                        // the root of all objects classes
  215.  
  216.     class CException;                 // the root of all exceptions
  217.         class CArchiveException;      // archive exception
  218.         class CFileException;         // file exception
  219.         class CSimpleException;
  220.             class CMemoryException;       // out-of-memory exception
  221.             class CNotSupportedException; // feature not supported exception
  222.  
  223.     class CFile;                      // raw binary file
  224.         class CStdioFile;             // buffered stdio text/binary file
  225.         class CMemFile;               // memory based file
  226.  
  227. // Non CObject classes
  228. class CString;                        // growable string type
  229. class CTimeSpan;                      // time/date difference
  230. class CTime;                          // absolute time/date
  231. struct CFileStatus;                   // file status information
  232. struct CMemoryState;                  // diagnostic memory support
  233.  
  234. class CArchive;                       // object persistence tool
  235. class CDumpContext;                   // object diagnostic dumping
  236.  
  237. /////////////////////////////////////////////////////////////////////////////
  238. // Other includes from standard "C" runtimes
  239.  
  240. #ifndef _INC_STRING
  241.     #include <string.h>
  242. #endif
  243. #ifndef _INC_STDIO
  244.     #include <stdio.h>
  245. #endif
  246. #ifndef _INC_STDLIB
  247.     #include <stdlib.h>
  248. #endif
  249. #ifndef _INC_TIME
  250.     #include <time.h>
  251. #endif
  252. #ifndef _INC_LIMITS
  253.     #include <limits.h>
  254. #endif
  255. #ifndef _INC_STDDEF
  256.     #include <stddef.h>
  257. #endif
  258. #ifndef _INC_STDARG
  259.     #include <stdarg.h>
  260. #endif
  261.  
  262. #ifndef _AFX_NO_DEBUG_CRT
  263. #ifndef _INC_CRTDBG
  264.     #include <crtdbg.h>
  265. #endif
  266. #endif // _AFX_NO_DEBUG_CRT
  267.  
  268. #ifdef _AFX_OLD_EXCEPTIONS
  269. // use setjmp and helper functions instead of C++ keywords
  270. #ifndef _INC_SETJMP
  271.     #pragma warning(disable: 4611)
  272.     #include <setjmp.h>
  273. #endif
  274. #endif
  275.  
  276. #ifdef _AFX_PACKING
  277. #pragma pack(push, _AFX_PACKING)
  278. #endif
  279.  
  280. /////////////////////////////////////////////////////////////////////////////
  281. // Basic types
  282.  
  283. // abstract iteration position
  284. struct __POSITION { int unused; };
  285. typedef __POSITION* POSITION;
  286.  
  287. #define CPlex CPlexNew
  288. struct CPlex;
  289.  
  290. struct _AFX_DOUBLE  { BYTE doubleBits[sizeof(double)]; };
  291. struct _AFX_FLOAT   { BYTE floatBits[sizeof(float)]; };
  292.  
  293. // Standard constants
  294. #undef FALSE
  295. #undef TRUE
  296. #undef NULL
  297.  
  298. #define FALSE   0
  299. #define TRUE    1
  300. #define NULL    0
  301.  
  302. /////////////////////////////////////////////////////////////////////////////
  303. // Diagnostic support
  304.  
  305. #ifdef _DEBUG
  306.  
  307. BOOL AFXAPI AfxAssertFailedLine(LPCSTR lpszFileName, int nLine);
  308.  
  309. void AFX_CDECL AfxTrace(LPCTSTR lpszFormat, ...);
  310. // Note: file names are still ANSI strings (filenames rarely need UNICODE)
  311. void AFXAPI AfxAssertValidObject(const CObject* pOb,
  312.                 LPCSTR lpszFileName, int nLine);
  313. void AFXAPI AfxDump(const CObject* pOb); // Dump an object from CodeView
  314.  
  315. #define TRACE              ::AfxTrace
  316. #define THIS_FILE          __FILE__
  317. #define ASSERT(f) \
  318.     do \
  319.     { \
  320.     if (!(f) && AfxAssertFailedLine(THIS_FILE, __LINE__)) \
  321.         AfxDebugBreak(); \
  322.     } while (0) \
  323.  
  324. #define VERIFY(f)          ASSERT(f)
  325. #define ASSERT_VALID(pOb)  (::AfxAssertValidObject(pOb, THIS_FILE, __LINE__))
  326. #define DEBUG_ONLY(f)      (f)
  327.  
  328. // The following trace macros are provided for backward compatiblity
  329. //  (they also take a fixed number of parameters which provides
  330. //   some amount of extra error checking)
  331. #define TRACE0(sz)              ::AfxTrace(_T("%s"), _T(sz))
  332. #define TRACE1(sz, p1)          ::AfxTrace(_T(sz), p1)
  333. #define TRACE2(sz, p1, p2)      ::AfxTrace(_T(sz), p1, p2)
  334. #define TRACE3(sz, p1, p2, p3)  ::AfxTrace(_T(sz), p1, p2, p3)
  335.  
  336. // These AFX_DUMP macros also provided for backward compatibility
  337. #define AFX_DUMP0(dc, sz)   dc << _T(sz)
  338. #define AFX_DUMP1(dc, sz, p1) dc << _T(sz) << p1
  339.  
  340. #else   // _DEBUG
  341.  
  342. #define ASSERT(f)          ((void)0)
  343. #define VERIFY(f)          ((void)(f))
  344. #define ASSERT_VALID(pOb)  ((void)0)
  345. #define DEBUG_ONLY(f)      ((void)0)
  346. inline void AFX_CDECL AfxTrace(LPCTSTR, ...) { }
  347. #define TRACE              1 ? (void)0 : ::AfxTrace
  348. #define TRACE0(sz)
  349. #define TRACE1(sz, p1)
  350. #define TRACE2(sz, p1, p2)
  351. #define TRACE3(sz, p1, p2, p3)
  352.  
  353. #endif // !_DEBUG
  354.  
  355. #define ASSERT_POINTER(p, type) \
  356.     ASSERT(((p) != NULL) && AfxIsValidAddress((p), sizeof(type), FALSE))
  357.  
  358. #define ASSERT_NULL_OR_POINTER(p, type) \
  359.     ASSERT(((p) == NULL) || AfxIsValidAddress((p), sizeof(type), FALSE))
  360.  
  361. /////////////////////////////////////////////////////////////////////////////
  362. // Turn off warnings for /W4
  363. // To resume any of these warning: #pragma warning(default: 4xxx)
  364. // which should be placed after the AFX include files
  365. #ifndef ALL_WARNINGS
  366. // warnings generated with common MFC/Windows code
  367. #pragma warning(disable: 4127)  // constant expression for TRACE/ASSERT
  368. #pragma warning(disable: 4134)  // message map member fxn casts
  369. #pragma warning(disable: 4201)  // nameless unions are part of C++
  370. #pragma warning(disable: 4511)  // private copy constructors are good to have
  371. #pragma warning(disable: 4512)  // private operator= are good to have
  372. #pragma warning(disable: 4514)  // unreferenced inlines are common
  373. #pragma warning(disable: 4710)  // private constructors are disallowed
  374. #pragma warning(disable: 4705)  // statement has no effect in optimized code
  375. // warnings caused by normal optimizations
  376. #ifndef _DEBUG
  377. #pragma warning(disable: 4701)  // local variable *may* be used without init
  378. #pragma warning(disable: 4702)  // unreachable code caused by optimizations
  379. #pragma warning(disable: 4791)  // loss of debugging info in retail version
  380. #endif
  381. // warnings specific to _AFXDLL version
  382. #ifdef _AFXDLL
  383. #pragma warning(disable: 4204)  // non-constant aggregate initializer
  384. #endif
  385. #ifdef _AFXDLL
  386. #pragma warning(disable: 4275)  // deriving exported class from non-exported
  387. #pragma warning(disable: 4251)  // using non-exported as public in exported
  388. #endif
  389. #endif //!ALL_WARNINGS
  390.  
  391. #ifdef _DEBUG
  392. #define UNUSED(x)
  393. #else
  394. #define UNUSED(x) x
  395. #endif
  396. #define UNUSED_ALWAYS(x) x
  397.  
  398. /////////////////////////////////////////////////////////////////////////////
  399. // Other implementation helpers
  400.  
  401. #define BEFORE_START_POSITION ((POSITION)-1L)
  402.  
  403. /////////////////////////////////////////////////////////////////////////////
  404. // explicit initialization for general purpose classes
  405.  
  406. BOOL AFXAPI AfxInitialize(BOOL bDLL = FALSE, DWORD dwVersion = _MFC_VER);
  407.  
  408. #undef AFX_DATA
  409. #define AFX_DATA AFX_CORE_DATA
  410.  
  411. /////////////////////////////////////////////////////////////////////////////
  412. // Basic object model
  413.  
  414. struct CRuntimeClass
  415. {
  416. // Attributes
  417.     LPCSTR m_lpszClassName;
  418.     int m_nObjectSize;
  419.     UINT m_wSchema; // schema number of the loaded class
  420.     CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class
  421. #ifdef _AFXDLL
  422.     CRuntimeClass* (PASCAL* m_pfnGetBaseClass)();
  423. #else
  424.     CRuntimeClass* m_pBaseClass;
  425. #endif
  426.  
  427. // Operations
  428.     CObject* CreateObject();
  429.     BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;
  430.  
  431. // Implementation
  432.     void Store(CArchive& ar) const;
  433.     static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);
  434.  
  435.     // CRuntimeClass objects linked together in simple list
  436.     CRuntimeClass* m_pNextClass;       // linked list of registered classes
  437. };
  438.  
  439. /////////////////////////////////////////////////////////////////////////////
  440. // Strings
  441.  
  442. #ifndef _OLEAUTO_H_
  443. #ifdef OLE2ANSI
  444.     typedef LPSTR BSTR;
  445. #else
  446.     typedef LPWSTR BSTR;// must (semantically) match typedef in oleauto.h
  447. #endif
  448. #endif
  449.  
  450. struct CStringData
  451. {
  452.     long nRefs;     // reference count
  453.     int nDataLength;
  454.     int nAllocLength;
  455.     // TCHAR data[nAllocLength]
  456.  
  457.     TCHAR* data()
  458.         { return (TCHAR*)(this+1); }
  459. };
  460.  
  461. class CString
  462. {
  463. public:
  464. // Constructors
  465.     CString();
  466.     CString(const CString& stringSrc);
  467.     CString(TCHAR ch, int nRepeat = 1);
  468.     CString(LPCSTR lpsz);
  469.     CString(LPCWSTR lpsz);
  470.     CString(LPCTSTR lpch, int nLength);
  471.     CString(const unsigned char* psz);
  472.  
  473. // Attributes & Operations
  474.     // as an array of characters
  475.     int GetLength() const;
  476.     BOOL IsEmpty() const;
  477.     void Empty();                       // free up the data
  478.  
  479.     TCHAR GetAt(int nIndex) const;      // 0 based
  480.     TCHAR operator[](int nIndex) const; // same as GetAt
  481.     void SetAt(int nIndex, TCHAR ch);
  482.     operator LPCTSTR() const;           // as a C string
  483.  
  484.     // overloaded assignment
  485.     const CString& operator=(const CString& stringSrc);
  486.     const CString& operator=(TCHAR ch);
  487. #ifdef _UNICODE
  488.     const CString& operator=(char ch);
  489. #endif
  490.     const CString& operator=(LPCSTR lpsz);
  491.     const CString& operator=(LPCWSTR lpsz);
  492.     const CString& operator=(const unsigned char* psz);
  493.  
  494.     // string concatenation
  495.     const CString& operator+=(const CString& string);
  496.     const CString& operator+=(TCHAR ch);
  497. #ifdef _UNICODE
  498.     const CString& operator+=(char ch);
  499. #endif
  500.     const CString& operator+=(LPCTSTR lpsz);
  501.  
  502.     friend CString AFXAPI operator+(const CString& string1,
  503.             const CString& string2);
  504.     friend CString AFXAPI operator+(const CString& string, TCHAR ch);
  505.     friend CString AFXAPI operator+(TCHAR ch, const CString& string);
  506. #ifdef _UNICODE
  507.     friend CString AFXAPI operator+(const CString& string, char ch);
  508.     friend CString AFXAPI operator+(char ch, const CString& string);
  509. #endif
  510.     friend CString AFXAPI operator+(const CString& string, LPCTSTR lpsz);
  511.     friend CString AFXAPI operator+(LPCTSTR lpsz, const CString& string);
  512.  
  513.     // string comparison
  514.     int Compare(LPCTSTR lpsz) const;         // straight character
  515.     int CompareNoCase(LPCTSTR lpsz) const;   // ignore case
  516.     int Collate(LPCTSTR lpsz) const;         // NLS aware
  517.  
  518.     // simple sub-string extraction
  519.     CString Mid(int nFirst, int nCount) const;
  520.     CString Mid(int nFirst) const;
  521.     CString Left(int nCount) const;
  522.     CString Right(int nCount) const;
  523.  
  524.     CString SpanIncluding(LPCTSTR lpszCharSet) const;
  525.     CString SpanExcluding(LPCTSTR lpszCharSet) const;
  526.  
  527.     // upper/lower/reverse conversion
  528.     void MakeUpper();
  529.     void MakeLower();
  530.     void MakeReverse();
  531.  
  532.     // trimming whitespace (either side)
  533.     void TrimRight();
  534.     void TrimLeft();
  535.  
  536.     // searching (return starting index, or -1 if not found)
  537.     // look for a single character match
  538.     int Find(TCHAR ch) const;               // like "C" strchr
  539.     int ReverseFind(TCHAR ch) const;
  540.     int FindOneOf(LPCTSTR lpszCharSet) const;
  541.  
  542.     // look for a specific sub-string
  543.     int Find(LPCTSTR lpszSub) const;        // like "C" strstr
  544.  
  545.     // simple formatting
  546.     void AFX_CDECL Format(LPCTSTR lpszFormat, ...);
  547.     void AFX_CDECL Format(UINT nFormatID, ...);
  548.  
  549. #ifndef _MAC
  550.     // formatting for localization (uses FormatMessage API)
  551.     void AFX_CDECL FormatMessage(LPCTSTR lpszFormat, ...);
  552.     void AFX_CDECL FormatMessage(UINT nFormatID, ...);
  553. #endif
  554.  
  555.     // input and output
  556. #ifdef _DEBUG
  557.     friend CDumpContext& AFXAPI operator<<(CDumpContext& dc,
  558.                 const CString& string);
  559. #endif
  560.     friend CArchive& AFXAPI operator<<(CArchive& ar, const CString& string);
  561.     friend CArchive& AFXAPI operator>>(CArchive& ar, CString& string);
  562.  
  563.     // Windows support
  564.     BOOL LoadString(UINT nID);          // load from string resource
  565.                                         // 255 chars max
  566. #ifndef _UNICODE
  567.     // ANSI <-> OEM support (convert string in place)
  568.     void AnsiToOem();
  569.     void OemToAnsi();
  570. #endif
  571.  
  572. #ifndef _AFX_NO_BSTR_SUPPORT
  573.     // OLE BSTR support (use for OLE automation)
  574.     BSTR AllocSysString() const;
  575.     BSTR SetSysString(BSTR* pbstr) const;
  576. #endif
  577.  
  578.     // Access to string implementation buffer as "C" character array
  579.     LPTSTR GetBuffer(int nMinBufLength);
  580.     void ReleaseBuffer(int nNewLength = -1);
  581.     LPTSTR GetBufferSetLength(int nNewLength);
  582.     void FreeExtra();
  583.  
  584.     // Use LockBuffer/UnlockBuffer to turn refcounting off
  585.     LPTSTR LockBuffer();
  586.     void UnlockBuffer();
  587.  
  588. // Implementation
  589. public:
  590.     ~CString();
  591.     int GetAllocLength() const;
  592.  
  593. protected:
  594.     LPTSTR m_pchData;   // pointer to ref counted string data
  595.  
  596.     // implementation helpers
  597.     CStringData* GetData() const;
  598.     void Init();
  599.     void AllocCopy(CString& dest, int nCopyLen, int nCopyIndex, int nExtraLen) const;
  600.     void AllocBuffer(int nLen);
  601.     void AssignCopy(int nSrcLen, LPCTSTR lpszSrcData);
  602.     void ConcatCopy(int nSrc1Len, LPCTSTR lpszSrc1Data, int nSrc2Len, LPCTSTR lpszSrc2Data);
  603.     void ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData);
  604.     void FormatV(LPCTSTR lpszFormat, va_list argList);
  605.     void CopyBeforeWrite();
  606.     void AllocBeforeWrite(int nLen);
  607.     void Release();
  608.     static void PASCAL Release(CStringData* pData);
  609.     static int PASCAL SafeStrlen(LPCTSTR lpsz);
  610. };
  611.  
  612. // Compare helpers
  613. BOOL AFXAPI operator==(const CString& s1, const CString& s2);
  614. BOOL AFXAPI operator==(const CString& s1, LPCTSTR s2);
  615. BOOL AFXAPI operator==(LPCTSTR s1, const CString& s2);
  616. BOOL AFXAPI operator!=(const CString& s1, const CString& s2);
  617. BOOL AFXAPI operator!=(const CString& s1, LPCTSTR s2);
  618. BOOL AFXAPI operator!=(LPCTSTR s1, const CString& s2);
  619. BOOL AFXAPI operator<(const CString& s1, const CString& s2);
  620. BOOL AFXAPI operator<(const CString& s1, LPCTSTR s2);
  621. BOOL AFXAPI operator<(LPCTSTR s1, const CString& s2);
  622. BOOL AFXAPI operator>(const CString& s1, const CString& s2);
  623. BOOL AFXAPI operator>(const CString& s1, LPCTSTR s2);
  624. BOOL AFXAPI operator>(LPCTSTR s1, const CString& s2);
  625. BOOL AFXAPI operator<=(const CString& s1, const CString& s2);
  626. BOOL AFXAPI operator<=(const CString& s1, LPCTSTR s2);
  627. BOOL AFXAPI operator<=(LPCTSTR s1, const CString& s2);
  628. BOOL AFXAPI operator>=(const CString& s1, const CString& s2);
  629. BOOL AFXAPI operator>=(const CString& s1, LPCTSTR s2);
  630. BOOL AFXAPI operator>=(LPCTSTR s1, const CString& s2);
  631.  
  632. // conversion helpers
  633. int AFX_CDECL _wcstombsz(char* mbstr, const wchar_t* wcstr, size_t count);
  634. int AFX_CDECL _mbstowcsz(wchar_t* wcstr, const char* mbstr, size_t count);
  635.  
  636. // Globals
  637. extern AFX_DATA TCHAR afxChNil;
  638. const CString& AFXAPI AfxGetEmptyString();
  639. #define afxEmptyString AfxGetEmptyString()
  640.  
  641. /////////////////////////////////////////////////////////////////////////////
  642. // class CObject is the root of all compliant objects
  643.  
  644. class CObject
  645. {
  646. public:
  647.  
  648. // Object model (types, destruction, allocation)
  649.     virtual CRuntimeClass* GetRuntimeClass() const;
  650.     virtual ~CObject();  // virtual destructors are necessary
  651.  
  652.     // Diagnostic allocations
  653.     void* PASCAL operator new(size_t nSize);
  654.     void* PASCAL operator new(size_t, void* p);
  655.     void PASCAL operator delete(void* p);
  656.  
  657. #if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT)
  658.     // for file name/line number tracking using DEBUG_NEW
  659.     void* PASCAL operator new(size_t nSize, LPCSTR lpszFileName, int nLine);
  660. #endif
  661.  
  662.     // Disable the copy constructor and assignment by default so you will get
  663.     //   compiler errors instead of unexpected behaviour if you pass objects
  664.     //   by value or assign objects.
  665. protected:
  666.     CObject();
  667. private:
  668.     CObject(const CObject& objectSrc);              // no implementation
  669.     void operator=(const CObject& objectSrc);       // no implementation
  670.  
  671. // Attributes
  672. public:
  673.     BOOL IsSerializable() const;
  674.     BOOL IsKindOf(const CRuntimeClass* pClass) const;
  675.  
  676. // Overridables
  677.     virtual void Serialize(CArchive& ar);
  678.  
  679.     // Diagnostic Support
  680.     virtual void AssertValid() const;
  681.     virtual void Dump(CDumpContext& dc) const;
  682.  
  683. // Implementation
  684. public:
  685.     static AFX_DATA CRuntimeClass classCObject;
  686. #ifdef _AFXDLL
  687.     static CRuntimeClass* PASCAL _GetBaseClass();
  688. #endif
  689. };
  690.  
  691. // Helper macros
  692. #define RUNTIME_CLASS(class_name) (&class_name::class##class_name)
  693. #define ASSERT_KINDOF(class_name, object) \
  694.     ASSERT((object)->IsKindOf(RUNTIME_CLASS(class_name)))
  695.  
  696. // RTTI helper macros/functions
  697. const CObject* AFX_CDECL AfxDynamicDownCast(CRuntimeClass* pClass, const CObject* pObject);
  698. CObject* AFX_CDECL AfxDynamicDownCast(CRuntimeClass* pClass, CObject* pObject);
  699. #define DYNAMIC_DOWNCAST(class_name, object) \
  700.     (class_name*)AfxDynamicDownCast(RUNTIME_CLASS(class_name), object)
  701.  
  702. #ifdef _DEBUG
  703. const CObject* AFX_CDECL AfxStaticDownCast(CRuntimeClass* pClass, const CObject* pObject);
  704. CObject* AFX_CDECL AfxStaticDownCast(CRuntimeClass* pClass, CObject* pObject);
  705. #define STATIC_DOWNCAST(class_name, object) \
  706.     ((class_name*)AfxStaticDownCast(RUNTIME_CLASS(class_name), object))
  707. #else
  708. #define STATIC_DOWNCAST(class_name, object) ((class_name*)object)
  709. #endif
  710.  
  711. //////////////////////////////////////////////////////////////////////////////
  712. // Helper macros for declaring CRuntimeClass compatible classes
  713.  
  714. #ifdef _AFXDLL
  715. #define DECLARE_DYNAMIC(class_name) \
  716. protected: \
  717.     static CRuntimeClass* PASCAL _GetBaseClass(); \
  718. public: \
  719.     static AFX_DATA CRuntimeClass class##class_name; \
  720.     virtual CRuntimeClass* GetRuntimeClass() const; \
  721.  
  722. #else
  723. #define DECLARE_DYNAMIC(class_name) \
  724. public: \
  725.     static AFX_DATA CRuntimeClass class##class_name; \
  726.     virtual CRuntimeClass* GetRuntimeClass() const; \
  727.  
  728. #endif
  729.  
  730. // not serializable, but dynamically constructable
  731. #define DECLARE_DYNCREATE(class_name) \
  732.     DECLARE_DYNAMIC(class_name) \
  733.     static CObject* PASCAL CreateObject();
  734.  
  735. #define DECLARE_SERIAL(class_name) \
  736.     DECLARE_DYNCREATE(class_name) \
  737.     friend CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb);
  738.  
  739. // generate static object constructor for class registration
  740. struct AFX_CLASSINIT
  741.     { AFX_CLASSINIT(CRuntimeClass* pNewClass); };
  742.  
  743. #ifdef _AFXDLL
  744. #define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
  745.     CRuntimeClass* PASCAL class_name::_GetBaseClass() \
  746.         { return RUNTIME_CLASS(base_class_name); } \
  747.     AFX_DATADEF CRuntimeClass class_name::class##class_name = { \
  748.         #class_name, sizeof(class class_name), wSchema, pfnNew, \
  749.             &class_name::_GetBaseClass, NULL }; \
  750.     static const AFX_CLASSINIT _init_##class_name(&class_name::class##class_name); \
  751.     CRuntimeClass* class_name::GetRuntimeClass() const \
  752.         { return &class_name::class##class_name; } \
  753.  
  754. #else
  755. #define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
  756.     AFX_DATADEF CRuntimeClass class_name::class##class_name = { \
  757.         #class_name, sizeof(class class_name), wSchema, pfnNew, \
  758.             RUNTIME_CLASS(base_class_name), NULL }; \
  759.     static const AFX_CLASSINIT _init_##class_name(&class_name::class##class_name); \
  760.     CRuntimeClass* class_name::GetRuntimeClass() const \
  761.         { return &class_name::class##class_name; } \
  762.  
  763. #endif
  764.  
  765. #define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
  766.     _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL)
  767.  
  768. #define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
  769.     CObject* PASCAL class_name::CreateObject() \
  770.         { return new class_name; } \
  771.     _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
  772.         class_name::CreateObject)
  773.  
  774. #define IMPLEMENT_SERIAL(class_name, base_class_name, wSchema) \
  775.     CObject* PASCAL class_name::CreateObject() \
  776.         { return new class_name; } \
  777.     _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, \
  778.         class_name::CreateObject) \
  779.     CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb) \
  780.         { pOb = (class_name*) ar.ReadObject(RUNTIME_CLASS(class_name)); \
  781.             return ar; } \
  782.  
  783. // optional bit for schema number that enables object versioning
  784. #define VERSIONABLE_SCHEMA  (0x80000000)
  785.  
  786. /////////////////////////////////////////////////////////////////////////////
  787. // other helpers
  788.  
  789. // zero fill everything after the vtbl pointer
  790. #define AFX_ZERO_INIT_OBJECT(base_class) \
  791.     memset(((base_class*)this)+1, 0, sizeof(*this) - sizeof(class base_class));
  792.  
  793.  
  794. /////////////////////////////////////////////////////////////////////////////
  795. // Exceptions
  796.  
  797. class CException : public CObject
  798. {
  799.     // abstract class for dynamic type checking
  800.     DECLARE_DYNAMIC(CException)
  801.  
  802. public:
  803. // Constructors
  804.     CException();   // sets m_bAutoDelete = TRUE
  805.     CException(BOOL bAutoDelete);   // sets m_bAutoDelete = bAutoDelete
  806.  
  807. // Operations
  808.     void Delete();  // use to delete exception in 'catch' block
  809.  
  810.     virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
  811.         PUINT pnHelpContext = NULL);
  812.     virtual int ReportError(UINT nType = MB_OK, UINT nMessageID = 0);
  813.  
  814. // Implementation (setting m_bAutoDelete to FALSE is advanced)
  815. public:
  816.     virtual ~CException();
  817.     BOOL m_bAutoDelete;
  818. #ifdef _DEBUG
  819.     void PASCAL operator delete(void* p);
  820. protected:
  821.     BOOL m_bReadyForDelete;
  822. #endif
  823. };
  824.  
  825. class CSimpleException : public CException
  826. {
  827.     // base class for resource-critical MFC exceptions
  828.     // handles ownership and initialization of an error message
  829.  
  830. public:
  831. // Constructors
  832.     CSimpleException();
  833.     CSimpleException(BOOL bAutoDelete);
  834.  
  835. // Operations
  836.     virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
  837.         PUINT pnHelpContext = NULL);
  838.  
  839. // Implementation (setting m_bAutoDelete to FALSE is advanced)
  840. public:
  841.     virtual ~CSimpleException();
  842.     BOOL m_bAutoDelete;
  843.  
  844.     void InitString();      // used during MFC initialization
  845.  
  846. protected:
  847.     BOOL m_bInitialized;
  848.     BOOL m_bLoaded;
  849.     TCHAR m_szMessage[128];
  850.     UINT m_nResourceID;
  851.  
  852. #ifdef _DEBUG
  853.     BOOL m_bReadyForDelete;
  854. #endif
  855. };
  856.  
  857. // helper routines for non-C++ EH implementations
  858. #ifdef _AFX_OLD_EXCEPTIONS
  859.     BOOL AFXAPI AfxCatchProc(CRuntimeClass* pClass);
  860.     void AFXAPI AfxThrow(CException* pException);
  861. #else
  862.     // for THROW_LAST auto-delete backward compatiblity
  863.     void AFXAPI AfxThrowLastCleanup();
  864. #endif
  865.  
  866. // other out-of-line helper functions
  867. void AFXAPI AfxTryCleanup();
  868.  
  869. #ifndef _AFX_JUMPBUF
  870. // Use portable 'jmp_buf' defined by ANSI by default.
  871. #define _AFX_JUMPBUF jmp_buf
  872. #endif
  873.  
  874. // Placed on frame for EXCEPTION linkage, or CException cleanup
  875. struct AFX_EXCEPTION_LINK
  876. {
  877. #ifdef _AFX_OLD_EXCEPTIONS
  878.     union
  879.     {
  880.         _AFX_JUMPBUF m_jumpBuf;
  881.         struct
  882.         {
  883.             void (PASCAL* pfnCleanup)(AFX_EXCEPTION_LINK* pLink);
  884.             void* pvData;       // extra data follows
  885.         } m_callback;       // callback for cleanup (nType != 0)
  886.     };
  887.     UINT m_nType;               // 0 for setjmp, !=0 for user extension
  888. #endif //!_AFX_OLD_EXCEPTIONS
  889.  
  890.     AFX_EXCEPTION_LINK* m_pLinkPrev;    // previous top, next in handler chain
  891.     CException* m_pException;   // current exception (NULL in TRY block)
  892.  
  893.     AFX_EXCEPTION_LINK();       // for initialization and linking
  894.     ~AFX_EXCEPTION_LINK()       // for cleanup and unlinking
  895.         { AfxTryCleanup(); };
  896. };
  897.  
  898. // Exception global state - never access directly
  899. struct AFX_EXCEPTION_CONTEXT
  900. {
  901.     AFX_EXCEPTION_LINK* m_pLinkTop;
  902.  
  903.     // Note: most of the exception context is now in the AFX_EXCEPTION_LINK
  904. };
  905.  
  906. #ifndef _PNH_DEFINED
  907. typedef int (__cdecl * _PNH)( size_t );
  908. #define _PNH_DEFINED
  909. #endif
  910.  
  911. _PNH AFXAPI AfxGetNewHandler();
  912. _PNH AFXAPI AfxSetNewHandler(_PNH pfnNewHandler);
  913. int AFX_CDECL AfxNewHandler(size_t nSize);
  914.  
  915. void AFXAPI AfxAbort();
  916.  
  917. #ifdef _AFX_OLD_EXCEPTIONS
  918.  
  919. // Obsolete and non-portable: setting terminate handler
  920. //  use CWinApp::ProcessWndProcException for Windows apps instead
  921. //  can also use set_terminate which is part of C++ standard library
  922. //      (these are provided for backward compatibility)
  923. void AFXAPI AfxTerminate();
  924. typedef void (AFXAPI* AFX_TERM_PROC)();
  925. AFX_TERM_PROC AFXAPI AfxSetTerminate(AFX_TERM_PROC);
  926.  
  927. #endif
  928.  
  929. /////////////////////////////////////////////////////////////////////////////
  930. // Exception macros using try, catch and throw
  931. //  (for backward compatibility to previous versions of MFC)
  932.  
  933. #ifndef _AFX_OLD_EXCEPTIONS
  934.  
  935. #define TRY { AFX_EXCEPTION_LINK _afxExceptionLink; try {
  936.  
  937. #define CATCH(class, e) } catch (class* e) \
  938.     { ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \
  939.         _afxExceptionLink.m_pException = e;
  940.  
  941. #define AND_CATCH(class, e) } catch (class* e) \
  942.     { ASSERT(e->IsKindOf(RUNTIME_CLASS(class))); \
  943.         _afxExceptionLink.m_pException = e;
  944.  
  945. #define END_CATCH } }
  946.  
  947. #define THROW(e) throw e
  948. #define THROW_LAST() (AfxThrowLastCleanup(), throw)
  949.  
  950. // Advanced macros for smaller code
  951. #define CATCH_ALL(e) } catch (CException* e) \
  952.     { { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \
  953.         _afxExceptionLink.m_pException = e;
  954.  
  955. #define AND_CATCH_ALL(e) } catch (CException* e) \
  956.     { { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \
  957.         _afxExceptionLink.m_pException = e;
  958.  
  959. #define END_CATCH_ALL } } }
  960.  
  961. #define END_TRY } catch (CException* e) \
  962.     { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); \
  963.         _afxExceptionLink.m_pException = e; } }
  964.  
  965. #else //_AFX_OLD_EXCEPTIONS
  966.  
  967. /////////////////////////////////////////////////////////////////////////////
  968. // Exception macros using setjmp and longjmp
  969. //  (for portability to compilers with no support for C++ exception handling)
  970.  
  971. #define TRY \
  972.     { AFX_EXCEPTION_LINK _afxExceptionLink; \
  973.     if (::setjmp(_afxExceptionLink.m_jumpBuf) == 0)
  974.  
  975. #define CATCH(class, e) \
  976.     else if (::AfxCatchProc(RUNTIME_CLASS(class))) \
  977.     { class* e = (class*)_afxExceptionLink.m_pException;
  978.  
  979. #define AND_CATCH(class, e) \
  980.     } else if (::AfxCatchProc(RUNTIME_CLASS(class))) \
  981.     { class* e = (class*)_afxExceptionLink.m_pException;
  982.  
  983. #define END_CATCH \
  984.     } else { ::AfxThrow(NULL); } }
  985.  
  986. #define THROW(e) AfxThrow(e)
  987. #define THROW_LAST() AfxThrow(NULL)
  988.  
  989. // Advanced macros for smaller code
  990. #define CATCH_ALL(e) \
  991.     else { CException* e = _afxExceptionLink.m_pException;
  992.  
  993. #define AND_CATCH_ALL(e) \
  994.     } else { CException* e = _afxExceptionLink.m_pException;
  995.  
  996. #define END_CATCH_ALL } }
  997.  
  998. #define END_TRY }
  999.  
  1000. #endif //_AFX_OLD_EXCEPTIONS
  1001.  
  1002. /////////////////////////////////////////////////////////////////////////////
  1003. // Standard Exception classes
  1004.  
  1005. class CMemoryException : public CSimpleException
  1006. {
  1007.     DECLARE_DYNAMIC(CMemoryException)
  1008. public:
  1009.     CMemoryException();
  1010.  
  1011. // Implementation
  1012. public:
  1013.     CMemoryException(BOOL bAutoDelete);
  1014.     CMemoryException(BOOL bAutoDelete, UINT nResourceID);
  1015.     virtual ~CMemoryException();
  1016. };
  1017.  
  1018. class CNotSupportedException : public CSimpleException
  1019. {
  1020.     DECLARE_DYNAMIC(CNotSupportedException)
  1021. public:
  1022.     CNotSupportedException();
  1023.  
  1024. // Implementation
  1025. public:
  1026.     CNotSupportedException(BOOL bAutoDelete);
  1027.     CNotSupportedException(BOOL bAutoDelete, UINT nResourceID);
  1028.     virtual ~CNotSupportedException();
  1029. };
  1030.  
  1031. class CArchiveException : public CException
  1032. {
  1033.     DECLARE_DYNAMIC(CArchiveException)
  1034. public:
  1035.     enum {
  1036.         none,
  1037.         generic,
  1038.         readOnly,
  1039.         endOfFile,
  1040.         writeOnly,
  1041.         badIndex,
  1042.         badClass,
  1043.         badSchema
  1044.     };
  1045.  
  1046. // Constructor
  1047.     CArchiveException(int cause = CArchiveException::none,
  1048.         LPCTSTR lpszArchiveName = NULL);
  1049.  
  1050. // Attributes
  1051.     int m_cause;
  1052.     CString m_strFileName;
  1053.  
  1054. // Implementation
  1055. public:
  1056.     virtual ~CArchiveException();
  1057. #ifdef _DEBUG
  1058.     virtual void Dump(CDumpContext& dc) const;
  1059. #endif
  1060.     virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
  1061.         PUINT pnHelpContext = NULL);
  1062. };
  1063.  
  1064. class CFileException : public CException
  1065. {
  1066.     DECLARE_DYNAMIC(CFileException)
  1067.  
  1068. public:
  1069.     enum {
  1070.         none,
  1071.         generic,
  1072.         fileNotFound,
  1073.         badPath,
  1074.         tooManyOpenFiles,
  1075.         accessDenied,
  1076.         invalidFile,
  1077.         removeCurrentDir,
  1078.         directoryFull,
  1079.         badSeek,
  1080.         hardIO,
  1081.         sharingViolation,
  1082.         lockViolation,
  1083.         diskFull,
  1084.         endOfFile
  1085.     };
  1086.  
  1087. // Constructor
  1088.     CFileException(int cause = CFileException::none, LONG lOsError = -1,
  1089.         LPCTSTR lpszArchiveName = NULL);
  1090.  
  1091. // Attributes
  1092.     int     m_cause;
  1093.     LONG    m_lOsError;
  1094.     CString m_strFileName;
  1095.  
  1096. // Operations
  1097.     // convert a OS dependent error code to a Cause
  1098.     static int PASCAL OsErrorToException(LONG lOsError);
  1099.     static int PASCAL ErrnoToException(int nErrno);
  1100.  
  1101.     // helper functions to throw exception after converting to a Cause
  1102.     static void PASCAL ThrowOsError(LONG lOsError, LPCTSTR lpszFileName = NULL);
  1103.     static void PASCAL ThrowErrno(int nErrno, LPCTSTR lpszFileName = NULL);
  1104.  
  1105. // Implementation
  1106. public:
  1107.     virtual ~CFileException();
  1108. #ifdef _DEBUG
  1109.     virtual void Dump(CDumpContext&) const;
  1110. #endif
  1111.     virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
  1112.         PUINT pnHelpContext = NULL);
  1113. };
  1114.  
  1115. /////////////////////////////////////////////////////////////////////////////
  1116. // Standard exception throws
  1117.  
  1118. void AFXAPI AfxThrowMemoryException();
  1119. void AFXAPI AfxThrowNotSupportedException();
  1120. void AFXAPI AfxThrowArchiveException(int cause,
  1121.     LPCTSTR lpszArchiveName = NULL);
  1122. void AFXAPI AfxThrowFileException(int cause, LONG lOsError = -1,
  1123.     LPCTSTR lpszFileName = NULL);
  1124.  
  1125. /////////////////////////////////////////////////////////////////////////////
  1126. // File - raw unbuffered disk file I/O
  1127.  
  1128. class CFile : public CObject
  1129. {
  1130.     DECLARE_DYNAMIC(CFile)
  1131.  
  1132. public:
  1133. // Flag values
  1134.     enum OpenFlags {
  1135.         modeRead =          0x0000,
  1136.         modeWrite =         0x0001,
  1137.         modeReadWrite =     0x0002,
  1138.         shareCompat =       0x0000,
  1139.         shareExclusive =    0x0010,
  1140.         shareDenyWrite =    0x0020,
  1141.         shareDenyRead =     0x0030,
  1142.         shareDenyNone =     0x0040,
  1143.         modeNoInherit =     0x0080,
  1144.         modeCreate =        0x1000,
  1145.         modeNoTruncate =    0x2000,
  1146.         typeText =          0x4000, // typeText and typeBinary are used in
  1147.         typeBinary =   (int)0x8000 // derived classes only
  1148.         };
  1149.  
  1150.     enum Attribute {
  1151.         normal =    0x00,
  1152.         readOnly =  0x01,
  1153.         hidden =    0x02,
  1154.         system =    0x04,
  1155.         volume =    0x08,
  1156.         directory = 0x10,
  1157.         archive =   0x20
  1158.         };
  1159.  
  1160.     enum SeekPosition { begin = 0x0, current = 0x1, end = 0x2 };
  1161.  
  1162.     enum { hFileNull = -1 };
  1163.  
  1164. // Constructors
  1165.     CFile();
  1166.     CFile(int hFile);
  1167.     CFile(LPCTSTR lpszFileName, UINT nOpenFlags);
  1168.  
  1169. // Attributes
  1170.     UINT m_hFile;
  1171.     operator HFILE() const;
  1172.  
  1173.     virtual DWORD GetPosition() const;
  1174.     BOOL GetStatus(CFileStatus& rStatus) const;
  1175.     virtual CString GetFileName() const;
  1176.     virtual CString GetFileTitle() const;
  1177.     virtual CString GetFilePath() const;
  1178.     virtual void SetFilePath(LPCTSTR lpszNewName);
  1179.  
  1180. // Operations
  1181.     virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags,
  1182.         CFileException* pError = NULL);
  1183.  
  1184.     static void PASCAL Rename(LPCTSTR lpszOldName,
  1185.                 LPCTSTR lpszNewName);
  1186.     static void PASCAL Remove(LPCTSTR lpszFileName);
  1187.     static BOOL PASCAL GetStatus(LPCTSTR lpszFileName,
  1188.                 CFileStatus& rStatus);
  1189.     static void PASCAL SetStatus(LPCTSTR lpszFileName,
  1190.                 const CFileStatus& status);
  1191.  
  1192.     DWORD SeekToEnd();
  1193.     void SeekToBegin();
  1194.  
  1195.     // backward compatible ReadHuge and WriteHuge
  1196.     DWORD ReadHuge(void* lpBuffer, DWORD dwCount);
  1197.     void WriteHuge(const void* lpBuffer, DWORD dwCount);
  1198.  
  1199. // Overridables
  1200.     virtual CFile* Duplicate() const;
  1201.  
  1202.     virtual LONG Seek(LONG lOff, UINT nFrom);
  1203.     virtual void SetLength(DWORD dwNewLen);
  1204.     virtual DWORD GetLength() const;
  1205.  
  1206.     virtual UINT Read(void* lpBuf, UINT nCount);
  1207.     virtual void Write(const void* lpBuf, UINT nCount);
  1208.  
  1209.     virtual void LockRange(DWORD dwPos, DWORD dwCount);
  1210.     virtual void UnlockRange(DWORD dwPos, DWORD dwCount);
  1211.  
  1212.     virtual void Abort();
  1213.     virtual void Flush();
  1214.     virtual void Close();
  1215.  
  1216. // Implementation
  1217. public:
  1218.     virtual ~CFile();
  1219. #ifdef _DEBUG
  1220.     virtual void AssertValid() const;
  1221.     virtual void Dump(CDumpContext& dc) const;
  1222. #endif
  1223.     enum BufferCommand { bufferRead, bufferWrite, bufferCommit, bufferCheck };
  1224.     virtual UINT GetBufferPtr(UINT nCommand, UINT nCount = 0,
  1225.         void** ppBufStart = NULL, void** ppBufMax = NULL);
  1226.  
  1227. protected:
  1228.     BOOL m_bCloseOnDelete;
  1229.     CString m_strFileName;
  1230. };
  1231.  
  1232. /////////////////////////////////////////////////////////////////////////////
  1233. // STDIO file implementation
  1234.  
  1235. class CStdioFile : public CFile
  1236. {
  1237.     DECLARE_DYNAMIC(CStdioFile)
  1238.  
  1239. public:
  1240. // Constructors
  1241.     CStdioFile();
  1242.     CStdioFile(FILE* pOpenStream);
  1243.     CStdioFile(LPCTSTR lpszFileName, UINT nOpenFlags);
  1244.  
  1245. // Attributes
  1246.     FILE* m_pStream;    // stdio FILE
  1247.                         // m_hFile from base class is _fileno(m_pStream)
  1248.  
  1249. // Operations
  1250.     // reading and writing strings
  1251.     virtual void WriteString(LPCTSTR lpsz);
  1252.     virtual LPTSTR ReadString(LPTSTR lpsz, UINT nMax);
  1253.     BOOL ReadString(CString& rString);
  1254.  
  1255. // Implementation
  1256. public:
  1257.     virtual ~CStdioFile();
  1258. #ifdef _DEBUG
  1259.     void Dump(CDumpContext& dc) const;
  1260. #endif
  1261.     virtual DWORD GetPosition() const;
  1262.     virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags,
  1263.         CFileException* pError = NULL);
  1264.     virtual UINT Read(void* lpBuf, UINT nCount);
  1265.     virtual void Write(const void* lpBuf, UINT nCount);
  1266.     virtual LONG Seek(LONG lOff, UINT nFrom);
  1267.     virtual void Abort();
  1268.     virtual void Flush();
  1269.     virtual void Close();
  1270.  
  1271.     // Unsupported APIs
  1272.     virtual CFile* Duplicate() const;
  1273.     virtual void LockRange(DWORD dwPos, DWORD dwCount);
  1274.     virtual void UnlockRange(DWORD dwPos, DWORD dwCount);
  1275. };
  1276.  
  1277. ////////////////////////////////////////////////////////////////////////////
  1278. // Memory based file implementation
  1279.  
  1280. class CMemFile : public CFile
  1281. {
  1282.     DECLARE_DYNAMIC(CMemFile)
  1283.  
  1284. public:
  1285. // Constructors
  1286.     CMemFile(UINT nGrowBytes = 1024);
  1287.     CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0);
  1288.  
  1289. // Operations
  1290.     void Attach(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes = 0);
  1291.     BYTE* Detach();
  1292.  
  1293. // Advanced Overridables
  1294. protected:
  1295.     virtual BYTE* Alloc(DWORD nBytes);
  1296.     virtual BYTE* Realloc(BYTE* lpMem, DWORD nBytes);
  1297.     virtual BYTE* Memcpy(BYTE* lpMemTarget, const BYTE* lpMemSource, UINT nBytes);
  1298.     virtual void Free(BYTE* lpMem);
  1299.     virtual void GrowFile(DWORD dwNewLen);
  1300.  
  1301. // Implementation
  1302. protected:
  1303.     UINT m_nGrowBytes;
  1304.     DWORD m_nPosition;
  1305.     DWORD m_nBufferSize;
  1306.     DWORD m_nFileSize;
  1307.     BYTE* m_lpBuffer;
  1308.     BOOL m_bAutoDelete;
  1309.  
  1310. public:
  1311.     virtual ~CMemFile();
  1312. #ifdef _DEBUG
  1313.     virtual void Dump(CDumpContext& dc) const;
  1314.     virtual void AssertValid() const;
  1315. #endif
  1316.     virtual DWORD GetPosition() const;
  1317.     BOOL GetStatus(CFileStatus& rStatus) const;
  1318.     virtual LONG Seek(LONG lOff, UINT nFrom);
  1319.     virtual void SetLength(DWORD dwNewLen);
  1320.     virtual UINT Read(void* lpBuf, UINT nCount);
  1321.     virtual void Write(const void* lpBuf, UINT nCount);
  1322.     virtual void Abort();
  1323.     virtual void Flush();
  1324.     virtual void Close();
  1325.     virtual UINT GetBufferPtr(UINT nCommand, UINT nCount = 0,
  1326.         void** ppBufStart = NULL, void** ppBufMax = NULL);
  1327.  
  1328.     // Unsupported APIs
  1329.     virtual CFile* Duplicate() const;
  1330.     virtual void LockRange(DWORD dwPos, DWORD dwCount);
  1331.     virtual void UnlockRange(DWORD dwPos, DWORD dwCount);
  1332. };
  1333.  
  1334. /////////////////////////////////////////////////////////////////////////////
  1335. // CTimeSpan and CTime
  1336.  
  1337. class CTimeSpan
  1338. {
  1339. public:
  1340.  
  1341. // Constructors
  1342.     CTimeSpan();
  1343.     CTimeSpan(time_t time);
  1344.     CTimeSpan(LONG lDays, int nHours, int nMins, int nSecs);
  1345.  
  1346.     CTimeSpan(const CTimeSpan& timeSpanSrc);
  1347.     const CTimeSpan& operator=(const CTimeSpan& timeSpanSrc);
  1348.  
  1349. // Attributes
  1350.     // extract parts
  1351.     LONG GetDays() const;   // total # of days
  1352.     LONG GetTotalHours() const;
  1353.     int GetHours() const;
  1354.     LONG GetTotalMinutes() const;
  1355.     int GetMinutes() const;
  1356.     LONG GetTotalSeconds() const;
  1357.     int GetSeconds() const;
  1358.  
  1359. // Operations
  1360.     // time math
  1361.     CTimeSpan operator-(CTimeSpan timeSpan) const;
  1362.     CTimeSpan operator+(CTimeSpan timeSpan) const;
  1363.     const CTimeSpan& operator+=(CTimeSpan timeSpan);
  1364.     const CTimeSpan& operator-=(CTimeSpan timeSpan);
  1365.     BOOL operator==(CTimeSpan timeSpan) const;
  1366.     BOOL operator!=(CTimeSpan timeSpan) const;
  1367.     BOOL operator<(CTimeSpan timeSpan) const;
  1368.     BOOL operator>(CTimeSpan timeSpan) const;
  1369.     BOOL operator<=(CTimeSpan timeSpan) const;
  1370.     BOOL operator>=(CTimeSpan timeSpan) const;
  1371.  
  1372. #ifdef _UNICODE
  1373.     // for compatibility with MFC 3.x
  1374.     CString Format(LPCSTR pFormat) const;
  1375. #endif
  1376.     CString Format(LPCTSTR pFormat) const;
  1377.     CString Format(UINT nID) const;
  1378.  
  1379.     // serialization
  1380. #ifdef _DEBUG
  1381.     friend CDumpContext& AFXAPI operator<<(CDumpContext& dc,CTimeSpan timeSpan);
  1382. #endif
  1383.     friend CArchive& AFXAPI operator<<(CArchive& ar, CTimeSpan timeSpan);
  1384.     friend CArchive& AFXAPI operator>>(CArchive& ar, CTimeSpan& rtimeSpan);
  1385.  
  1386. private:
  1387.     time_t m_timeSpan;
  1388.     friend class CTime;
  1389. };
  1390.  
  1391. class CTime
  1392. {
  1393. public:
  1394.  
  1395. // Constructors
  1396.     static CTime PASCAL GetCurrentTime();
  1397.  
  1398.     CTime();
  1399.     CTime(time_t time);
  1400.     CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec,
  1401.         int nDST = -1);
  1402.     CTime(WORD wDosDate, WORD wDosTime, int nDST = -1);
  1403.     CTime(const CTime& timeSrc);
  1404.  
  1405.     CTime(const SYSTEMTIME& sysTime, int nDST = -1);
  1406.     CTime(const FILETIME& fileTime, int nDST = -1);
  1407.     const CTime& operator=(const CTime& timeSrc);
  1408.     const CTime& operator=(time_t t);
  1409.  
  1410. // Attributes
  1411.     struct tm* GetGmtTm(struct tm* ptm = NULL) const;
  1412.     struct tm* GetLocalTm(struct tm* ptm = NULL) const;
  1413.  
  1414.     time_t GetTime() const;
  1415.     int GetYear() const;
  1416.     int GetMonth() const;       // month of year (1 = Jan)
  1417.     int GetDay() const;         // day of month
  1418.     int GetHour() const;
  1419.     int GetMinute() const;
  1420.     int GetSecond() const;
  1421.     int GetDayOfWeek() const;   // 1=Sun, 2=Mon, ..., 7=Sat
  1422.  
  1423. // Operations
  1424.     // time math
  1425.     CTimeSpan operator-(CTime time) const;
  1426.     CTime operator-(CTimeSpan timeSpan) const;
  1427.     CTime operator+(CTimeSpan timeSpan) const;
  1428.     const CTime& operator+=(CTimeSpan timeSpan);
  1429.     const CTime& operator-=(CTimeSpan timeSpan);
  1430.     BOOL operator==(CTime time) const;
  1431.     BOOL operator!=(CTime time) const;
  1432.     BOOL operator<(CTime time) const;
  1433.     BOOL operator>(CTime time) const;
  1434.     BOOL operator<=(CTime time) const;
  1435.     BOOL operator>=(CTime time) const;
  1436.  
  1437.     // formatting using "C" strftime
  1438.     CString Format(LPCTSTR pFormat) const;
  1439.     CString FormatGmt(LPCTSTR pFormat) const;
  1440.     CString Format(UINT nFormatID) const;
  1441.     CString FormatGmt(UINT nFormatID) const;
  1442.  
  1443. #ifdef _UNICODE
  1444.     // for compatibility with MFC 3.x
  1445.     CString Format(LPCSTR pFormat) const;
  1446.     CString FormatGmt(LPCSTR pFormat) const;
  1447. #endif
  1448.  
  1449.     // serialization
  1450. #ifdef _DEBUG
  1451.     friend CDumpContext& AFXAPI operator<<(CDumpContext& dc, CTime time);
  1452. #endif
  1453.     friend CArchive& AFXAPI operator<<(CArchive& ar, CTime time);
  1454.     friend CArchive& AFXAPI operator>>(CArchive& ar, CTime& rtime);
  1455.  
  1456. private:
  1457.     time_t m_time;
  1458. };
  1459.  
  1460. /////////////////////////////////////////////////////////////////////////////
  1461. // File status
  1462.  
  1463. struct CFileStatus
  1464. {
  1465.     CTime m_ctime;          // creation date/time of file
  1466.     CTime m_mtime;          // last modification date/time of file
  1467.     CTime m_atime;          // last access date/time of file
  1468.     LONG m_size;            // logical size of file in bytes
  1469.     BYTE m_attribute;       // logical OR of CFile::Attribute enum values
  1470.     BYTE _m_padding;        // pad the structure to a WORD
  1471.     TCHAR m_szFullName[_MAX_PATH]; // absolute path name
  1472.  
  1473. #ifdef _DEBUG
  1474.     void Dump(CDumpContext& dc) const;
  1475. #endif
  1476. };
  1477.  
  1478. /////////////////////////////////////////////////////////////////////////////
  1479. // Diagnostic memory management routines
  1480.  
  1481. // Low level sanity checks for memory blocks
  1482. BOOL AFXAPI AfxIsValidAddress(const void* lp,
  1483.             UINT nBytes, BOOL bReadWrite = TRUE);
  1484. BOOL AFXAPI AfxIsValidString(LPCWSTR lpsz, int nLength = -1);
  1485. BOOL AFXAPI AfxIsValidString(LPCSTR lpsz, int nLength = -1);
  1486.  
  1487. #if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT)
  1488.  
  1489. // Memory tracking allocation
  1490. void* AFX_CDECL operator new(size_t nSize, LPCSTR lpszFileName, int nLine);
  1491. #define DEBUG_NEW new(THIS_FILE, __LINE__)
  1492.  
  1493. void* AFXAPI AfxAllocMemoryDebug(size_t nSize, BOOL bIsObject,
  1494.     LPCSTR lpszFileName, int nLine);
  1495. void AFXAPI AfxFreeMemoryDebug(void* pbData, BOOL bIsObject);
  1496.  
  1497. // Dump any memory leaks since program started
  1498. BOOL AFXAPI AfxDumpMemoryLeaks();
  1499.  
  1500. // Return TRUE if valid memory block of nBytes
  1501. BOOL AFXAPI AfxIsMemoryBlock(const void* p, UINT nBytes,
  1502.     LONG* plRequestNumber = NULL);
  1503.  
  1504. // Return TRUE if memory is sane or print out what is wrong
  1505. BOOL AFXAPI AfxCheckMemory();
  1506.  
  1507. #define afxMemDF _crtDbgFlag
  1508.  
  1509. enum AfxMemDF // memory debug/diagnostic flags
  1510. {
  1511.     allocMemDF          = 0x01,         // turn on debugging allocator
  1512.     delayFreeMemDF      = 0x02,         // delay freeing memory
  1513.     checkAlwaysMemDF    = 0x04          // AfxCheckMemory on every alloc/free
  1514. };
  1515.  
  1516. #ifdef _UNICODE
  1517. #define AfxOutputDebugString(lpsz) \
  1518.     do \
  1519.     { \
  1520.         int _convert; _convert = 0; \
  1521.         _RPT0(_CRT_WARN, W2CA(lpsz)); \
  1522.     } while (0)
  1523. #else
  1524. #define AfxOutputDebugString(lpsz) _RPT0(_CRT_WARN, lpsz)
  1525. #endif
  1526.  
  1527. // turn on/off tracking for a short while
  1528. BOOL AFXAPI AfxEnableMemoryTracking(BOOL bTrack);
  1529.  
  1530. // Advanced initialization: for overriding default diagnostics
  1531. BOOL AFXAPI AfxDiagnosticInit(void);
  1532.  
  1533. // A failure hook returns whether to permit allocation
  1534. typedef BOOL (AFXAPI* AFX_ALLOC_HOOK)(size_t nSize, BOOL bObject, LONG lRequestNumber);
  1535.  
  1536. // Set new hook, return old (never NULL)
  1537. AFX_ALLOC_HOOK AFXAPI AfxSetAllocHook(AFX_ALLOC_HOOK pfnAllocHook);
  1538.  
  1539. // Debugger hook on specified allocation request - Obsolete
  1540. void AFXAPI AfxSetAllocStop(LONG lRequestNumber);
  1541.  
  1542. // Memory state for snapshots/leak detection
  1543. struct CMemoryState
  1544. {
  1545. // Attributes
  1546.     enum blockUsage
  1547.     {
  1548.         freeBlock,    // memory not used
  1549.         objectBlock,  // contains a CObject derived class object
  1550.         bitBlock,     // contains ::operator new data
  1551.         crtBlock,
  1552.         ignoredBlock,
  1553.         nBlockUseMax  // total number of usages
  1554.     };
  1555.  
  1556.     _CrtMemState m_memState;
  1557.     LONG m_lCounts[nBlockUseMax];
  1558.     LONG m_lSizes[nBlockUseMax];
  1559.     LONG m_lHighWaterCount;
  1560.     LONG m_lTotalCount;
  1561.  
  1562.     CMemoryState();
  1563.  
  1564. // Operations
  1565.     void Checkpoint();  // fill with current state
  1566.     BOOL Difference(const CMemoryState& oldState,
  1567.                     const CMemoryState& newState);  // fill with difference
  1568.     void UpdateData();
  1569.  
  1570.     // Output to afxDump
  1571.     void DumpStatistics() const;
  1572.     void DumpAllObjectsSince() const;
  1573. };
  1574.  
  1575. // Enumerate allocated objects or runtime classes
  1576. void AFXAPI AfxDoForAllObjects(void (AFX_CDECL *pfn)(CObject* pObject, void* pContext),
  1577.     void* pContext);
  1578. void AFXAPI AfxDoForAllClasses(void (AFX_CDECL *pfn)(const CRuntimeClass* pClass,
  1579.     void* pContext), void* pContext);
  1580.  
  1581. #else
  1582.  
  1583. // non-_DEBUG_ALLOC version that assume everything is OK
  1584. #define DEBUG_NEW new
  1585. #define AfxCheckMemory() TRUE
  1586. #define AfxIsMemoryBlock(p, nBytes) TRUE
  1587. #define AfxEnableMemoryTracking(bTrack) FALSE
  1588. #define AfxOutputDebugString(lpsz) ::OutputDebugString(lpsz)
  1589.  
  1590. // diagnostic initialization
  1591. #ifndef _DEBUG
  1592. #define AfxDiagnosticInit() TRUE
  1593. #else
  1594. BOOL AFXAPI AfxDiagnosticInit(void);
  1595. #endif
  1596.  
  1597. #endif // _DEBUG
  1598.  
  1599. /////////////////////////////////////////////////////////////////////////////
  1600. // Archives for serializing CObject data
  1601.  
  1602. // needed for implementation
  1603. class CPtrArray;
  1604. class CMapPtrToPtr;
  1605. class CDocument;
  1606.  
  1607. class CArchive
  1608. {
  1609. public:
  1610. // Flag values
  1611.     enum Mode { store = 0, load = 1, bNoFlushOnDelete = 2, bNoByteSwap = 4 };
  1612.  
  1613.     CArchive(CFile* pFile, UINT nMode, int nBufSize = 4096, void* lpBuf = NULL);
  1614.     ~CArchive();
  1615.  
  1616. // Attributes
  1617.     BOOL IsLoading() const;
  1618.     BOOL IsStoring() const;
  1619.     BOOL IsByteSwapping() const;
  1620.     BOOL IsBufferEmpty() const;
  1621.  
  1622.     CFile* GetFile() const;
  1623.     UINT GetObjectSchema(); // only valid when reading a CObject*
  1624.     void SetObjectSchema(UINT nSchema);
  1625.  
  1626.     // pointer to document being serialized -- must set to serialize
  1627.     //  COleClientItems in a document!
  1628.     CDocument* m_pDocument;
  1629.  
  1630. // Operations
  1631.     UINT Read(void* lpBuf, UINT nMax);
  1632.     void Write(const void* lpBuf, UINT nMax);
  1633.     void Flush();
  1634.     void Close();
  1635.     void Abort();   // close and shutdown without exceptions
  1636.  
  1637.     // reading and writing strings
  1638.     void WriteString(LPCTSTR lpsz);
  1639.     LPTSTR ReadString(LPTSTR lpsz, UINT nMax);
  1640.     BOOL ReadString(CString& rString);
  1641.  
  1642. public:
  1643.     // Object I/O is pointer based to avoid added construction overhead.
  1644.     // Use the Serialize member function directly for embedded objects.
  1645.     friend CArchive& AFXAPI operator<<(CArchive& ar, const CObject* pOb);
  1646.  
  1647.     friend CArchive& AFXAPI operator>>(CArchive& ar, CObject*& pOb);
  1648.     friend CArchive& AFXAPI operator>>(CArchive& ar, const CObject*& pOb);
  1649.  
  1650.     // insertion operations
  1651.     CArchive& operator<<(BYTE by);
  1652.     CArchive& operator<<(WORD w);
  1653.     CArchive& operator<<(LONG l);
  1654.     CArchive& operator<<(DWORD dw);
  1655.     CArchive& operator<<(float f);
  1656.     CArchive& operator<<(double d);
  1657.  
  1658.     CArchive& operator<<(int i);
  1659.     CArchive& operator<<(short w);
  1660.     CArchive& operator<<(char ch);
  1661.     CArchive& operator<<(unsigned u);
  1662.  
  1663.     // extraction operations
  1664.     CArchive& operator>>(BYTE& by);
  1665.     CArchive& operator>>(WORD& w);
  1666.     CArchive& operator>>(DWORD& dw);
  1667.     CArchive& operator>>(LONG& l);
  1668.     CArchive& operator>>(float& f);
  1669.     CArchive& operator>>(double& d);
  1670.  
  1671.     CArchive& operator>>(int& i);
  1672.     CArchive& operator>>(short& w);
  1673.     CArchive& operator>>(char& ch);
  1674.     CArchive& operator>>(unsigned& u);
  1675.  
  1676.     // object read/write
  1677.     CObject* ReadObject(const CRuntimeClass* pClass);
  1678.     void WriteObject(const CObject* pOb);
  1679.     // advanced object mapping (used for forced references)
  1680.     void MapObject(const CObject* pOb);
  1681.  
  1682.     // advanced versioning support
  1683.     void WriteClass(const CRuntimeClass* pClassRef);
  1684.     CRuntimeClass* ReadClass(const CRuntimeClass* pClassRefRequested = NULL,
  1685.         UINT* pSchema = NULL, DWORD* pObTag = NULL);
  1686.     void SerializeClass(const CRuntimeClass* pClassRef);
  1687.  
  1688.     // advanced operations (used when storing/loading many objects)
  1689.     void SetStoreParams(UINT nHashSize = 2053, UINT nBlockSize = 128);
  1690.     void SetLoadParams(UINT nGrowBy = 1024);
  1691.  
  1692. // Implementation
  1693. public:
  1694.     BOOL m_bForceFlat;  // for COleClientItem implementation (default TRUE)
  1695.     BOOL m_bDirectBuffer;   // TRUE if m_pFile supports direct buffering
  1696.     void FillBuffer(UINT nBytesNeeded);
  1697.     void CheckCount();  // throw exception if m_nMapCount is too large
  1698.  
  1699.     // special functions for reading and writing (16-bit compatible) counts
  1700.     DWORD ReadCount();
  1701.     void WriteCount(DWORD dwCount);
  1702.  
  1703.     // public for advanced use
  1704.     UINT m_nObjectSchema;
  1705.     CString m_strFileName;
  1706.  
  1707. protected:
  1708.     // archive objects cannot be copied or assigned
  1709.     CArchive(const CArchive& arSrc);
  1710.     void operator=(const CArchive& arSrc);
  1711.  
  1712.     BOOL m_nMode;
  1713.     BOOL m_bUserBuf;
  1714.     int m_nBufSize;
  1715.     CFile* m_pFile;
  1716.     BYTE* m_lpBufCur;
  1717.     BYTE* m_lpBufMax;
  1718.     BYTE* m_lpBufStart;
  1719.  
  1720.     // array/map for CObject* and CRuntimeClass* load/store
  1721.     UINT m_nMapCount;
  1722.     union
  1723.     {
  1724.         CPtrArray* m_pLoadArray;
  1725.         CMapPtrToPtr* m_pStoreMap;
  1726.     };
  1727.     // map to keep track of mismatched schemas
  1728.     CMapPtrToPtr* m_pSchemaMap;
  1729.  
  1730.     // advanced parameters (controls performance with large archives)
  1731.     UINT m_nGrowSize;
  1732.     UINT m_nHashSize;
  1733. };
  1734.  
  1735. /////////////////////////////////////////////////////////////////////////////
  1736. // Diagnostic dumping
  1737.  
  1738. class CDumpContext
  1739. {
  1740. public:
  1741.     CDumpContext(CFile* pFile = NULL);
  1742.  
  1743. // Attributes
  1744.     int GetDepth() const;      // 0 => this object, 1 => children objects
  1745.     void SetDepth(int nNewDepth);
  1746.  
  1747. // Operations
  1748.     CDumpContext& operator<<(LPCTSTR lpsz);
  1749. #ifdef _UNICODE
  1750.     CDumpContext& operator<<(LPCSTR lpsz);  // automatically widened
  1751. #else
  1752.     CDumpContext& operator<<(LPCWSTR lpsz); // automatically thinned
  1753. #endif
  1754.     CDumpContext& operator<<(const void* lp);
  1755.     CDumpContext& operator<<(const CObject* pOb);
  1756.     CDumpContext& operator<<(const CObject& ob);
  1757.     CDumpContext& operator<<(BYTE by);
  1758.     CDumpContext& operator<<(WORD w);
  1759.     CDumpContext& operator<<(UINT u);
  1760.     CDumpContext& operator<<(LONG l);
  1761.     CDumpContext& operator<<(DWORD dw);
  1762.     CDumpContext& operator<<(float f);
  1763.     CDumpContext& operator<<(double d);
  1764.     CDumpContext& operator<<(int n);
  1765.     void HexDump(LPCTSTR lpszLine, BYTE* pby, int nBytes, int nWidth);
  1766.     void Flush();
  1767.  
  1768. // Implementation
  1769. protected:
  1770.     // dump context objects cannot be copied or assigned
  1771.     CDumpContext(const CDumpContext& dcSrc);
  1772.     void operator=(const CDumpContext& dcSrc);
  1773.     void OutputString(LPCTSTR lpsz);
  1774.  
  1775.     int m_nDepth;
  1776.  
  1777. public:
  1778.     CFile* m_pFile;
  1779. };
  1780.  
  1781. #ifdef _DEBUG
  1782. extern AFX_DATA CDumpContext afxDump;
  1783. extern AFX_DATA BOOL afxTraceEnabled;
  1784. #endif
  1785.  
  1786. /////////////////////////////////////////////////////////////////////////////
  1787. // Special include for Win32s compatibility
  1788.  
  1789. #ifdef _AFX_PACKING
  1790. #pragma pack(pop)
  1791. #endif
  1792.  
  1793. #ifndef __AFXCOLL_H__
  1794.     #include <afxcoll.h>
  1795.     #ifndef __AFXSTATE_H__
  1796.         #include <afxstat_.h> // for _AFX_APP_STATE and _AFX_THREAD_STATE
  1797.     #endif
  1798. #endif
  1799.  
  1800. /////////////////////////////////////////////////////////////////////////////
  1801. // Inline function declarations
  1802.  
  1803. #ifdef _AFX_ENABLE_INLINES
  1804. #define _AFX_INLINE inline
  1805. #include <afx.inl>
  1806. #endif
  1807.  
  1808. #undef AFX_DATA
  1809. #define AFX_DATA
  1810.  
  1811. #ifdef _AFX_MINREBUILD
  1812. #pragma component(minrebuild, on)
  1813. #endif
  1814. #ifndef _AFX_FULLTYPEINFO
  1815. #pragma component(mintypeinfo, off)
  1816. #endif
  1817.  
  1818. #endif // __AFX_H__
  1819.  
  1820. /////////////////////////////////////////////////////////////////////////////
  1821.