![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to afx.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / mfc / include|
Return to afx.h CVS log | Up to [WindowsNT SDKs] / mstools / mfc / include |
1.1 ! root 1: // Microsoft Foundation Classes C++ library. ! 2: // Copyright (C) 1992 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 Microsoft ! 7: // QuickHelp 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: #define _MFC_VER 0x0100 /* Microsoft Foundation Classes */ ! 15: #define _AFX 1 /* Microsoft Application Framework Classes */ ! 16: ! 17: #ifndef __cplusplus ! 18: #error Microsoft Foundation Classes require C++ compilation (use a .cpp suffix) ! 19: #endif ! 20: ! 21: ///////////////////////////////////////////////////////////////////////////// ! 22: // Classes declared in this file ! 23: // in addition to standard primitive data types and various helper macros ! 24: ! 25: struct CRuntimeClass; // object type information ! 26: ! 27: class CObject; // the root of all objects classes ! 28: ! 29: class CException; // the root of all exceptions ! 30: class CMemoryException; // out-of-memory exception ! 31: class CNotSupportedException; // feature not supported exception ! 32: class CArchiveException; // archive exception ! 33: class CFileException; // file exception ! 34: ! 35: class CFile; // raw binary file ! 36: class CStdioFile; // buffered stdio text/binary file ! 37: class CMemFile; // memory based file ! 38: ! 39: // Non CObject classes ! 40: class CString; // growable string type ! 41: class CTimeSpan; // time/date difference ! 42: class CTime; // absolute time/date ! 43: struct CFileStatus; // file status information ! 44: struct CMemoryState; // diagnostic memory support ! 45: ! 46: class CArchive; // object persistence tool ! 47: class CDumpContext; // object diagnostic dumping ! 48: ! 49: ///////////////////////////////////////////////////////////////////////////// ! 50: // Other includes from standard "C" runtimes ! 51: ! 52: ! 53: #include <string.h> ! 54: #include <stdio.h> ! 55: #include <stdlib.h> ! 56: #include <time.h> ! 57: ! 58: ///////////////////////////////////////////////////////////////////////////// ! 59: // Target version control ! 60: ! 61: // For target version (one of) ! 62: // _WINDOWS : for Microsoft Windows target (defined by #include <afxwin.h>) ! 63: // _DOS : for Microsoft DOS (non Windows) target ! 64: // _NTWIN : with _WINDOWS is a Windows NT GUI application, by itself is a ! 65: // character application (only <afx.h> applies) ! 66: // ! 67: // Additional build options: ! 68: // _DEBUG : debug versions (full diagnostics) ! 69: // ! 70: // Internal version flags: ! 71: // _DOSWIN : for Microsoft Windows and DOS target code (internal) ! 72: // _NEARDATA : ambient near data pointers needing far overloads ! 73: ! 74: #if !defined(_WINDOWS) && !defined(_DOS) && !defined(_NTWIN) ! 75: #error Please define one of _WINDOWS or _DOS or _NTWIN ! 76: #endif ! 77: ! 78: #if defined(_WINDOWS) && defined(_DOS) ! 79: #error Please define only one of _WINDOWS or _DOS ! 80: #endif ! 81: ! 82: #ifndef _NTWIN ! 83: #ifdef _WINDOWS ! 84: #define _DOSWIN ! 85: #endif ! 86: ! 87: #ifdef _DOS ! 88: #define _DOSWIN ! 89: #endif ! 90: #endif // _NTWIN ! 91: ! 92: #if defined(_M_I86SM) || defined(_M_I86MM) ! 93: #define _NEARDATA ! 94: #endif ! 95: ! 96: ///////////////////////////////////////////////////////////////////////////// ! 97: // Standard preprocessor symbols: ! 98: ! 99: ! 100: #ifdef _DOSWIN ! 101: #ifndef PASCAL ! 102: #define PASCAL _pascal ! 103: #endif ! 104: ! 105: #ifndef CDECL ! 106: #define CDECL _cdecl ! 107: #endif ! 108: ! 109: #ifndef FAR ! 110: #define FAR _far ! 111: #endif ! 112: ! 113: #ifndef NEAR ! 114: #define NEAR _near ! 115: #endif ! 116: ! 117: #else ! 118: ! 119: extern "C" { ! 120: #include <excpt.h> ! 121: #include <windef.h> ! 122: #include <winbase.h> ! 123: } ! 124: ! 125: #define BASED_CODE ! 126: #undef _NEARDATA ! 127: ! 128: #ifndef PASCAL ! 129: #define PASCAL pascal ! 130: #endif ! 131: ! 132: #ifndef CDECL ! 133: #define CDECL cdecl ! 134: #endif ! 135: ! 136: #ifndef FAR ! 137: #define FAR far ! 138: #endif ! 139: ! 140: #ifndef NEAR ! 141: #define NEAR near ! 142: #endif ! 143: ! 144: #define _huge ! 145: #define huge ! 146: #define pascal ! 147: #define cdecl ! 148: #define near ! 149: #define far ! 150: ! 151: #define _fstrcpy strcpy ! 152: #define _fstrlen strlen ! 153: #define _fstrcmp strcmp ! 154: #define _fstrcat strcat ! 155: #define _fstrncpy strncpy ! 156: #define _fstrncmp strncmp ! 157: #define _fmemcpy memcpy ! 158: #define _fmalloc malloc ! 159: #define _frealloc realloc ! 160: #define _ffree free ! 161: ! 162: #undef GetCurrentTime ! 163: extern "C" unsigned long GetTickCount(void); ! 164: inline unsigned long GetCurrentTime(void) ! 165: { return ::GetTickCount(); } ! 166: ! 167: #endif ! 168: ! 169: ///////////////////////////////////////////////////////////////////////////// ! 170: // Basic types (from Windows) ! 171: ! 172: typedef unsigned char BYTE; // 8-bit unsigned entity ! 173: typedef unsigned short WORD; // 16-bit unsigned number ! 174: typedef unsigned int UINT; // machine sized unsigned number (preferred) ! 175: typedef long LONG; // 32-bit signed number ! 176: typedef unsigned long DWORD; // 32-bit unsigned number ! 177: typedef int BOOL; // BOOLean (0 or !=0) ! 178: ! 179: typedef void* POSITION; // abstract iteration position ! 180: ! 181: // Standard constants ! 182: #define FALSE 0 ! 183: #define TRUE 1 ! 184: #define NULL 0 ! 185: ! 186: ///////////////////////////////////////////////////////////////////////////// ! 187: // Diagnostic support ! 188: ! 189: ! 190: #ifdef _DEBUG ! 191: ! 192: extern "C" ! 193: { ! 194: void CDECL AfxTrace(const char* pszFormat, ...); ! 195: void PASCAL AfxAssertFailedLine(const char FAR* lpszFileName, int nLine); ! 196: void PASCAL AfxAssertValidObject(const CObject* pOb); ! 197: } ! 198: #define TRACE ::AfxTrace ! 199: #define THIS_FILE __FILE__ ! 200: #define ASSERT(f) ((f) ? (void)0 : \ ! 201: ::AfxAssertFailedLine(THIS_FILE, __LINE__)) ! 202: #define VERIFY(f) ASSERT(f) ! 203: #define ASSERT_VALID(pOb) (::AfxAssertValidObject(pOb)) ! 204: ! 205: #else ! 206: ! 207: #define ASSERT(f) ((void)0) ! 208: #define VERIFY(f) ((void)(f)) ! 209: #define ASSERT_VALID(pOb) ((void)0) ! 210: inline void CDECL AfxTrace(const char* /* pszFormat */, ...) { } ! 211: #define TRACE 1 ? (void)0 : ::AfxTrace ! 212: ! 213: #endif // _DEBUG ! 214: ! 215: // Explicit extern for version API/Windows 3.0 loader problem ! 216: #ifdef _WINDOWS ! 217: extern "C" int FAR PASCAL __export _afx_version(); ! 218: #else ! 219: extern "C" int FAR PASCAL _afx_version(); ! 220: #endif ! 221: ! 222: // Turn off warnings for /W4 ! 223: // To resume any of these warning: #pragma warning(default: 4xxx) ! 224: // which should be placed after the AFX include files ! 225: #ifndef ALL_WARNINGS ! 226: #pragma warning(disable: 4001) // nameless unions are part of C++ ! 227: #pragma warning(disable: 4134) // message map member fxn casts ! 228: #pragma warning(disable: 4505) // optimize away locals ! 229: #pragma warning(disable: 4510) // default constructors are bad to have ! 230: #pragma warning(disable: 4511) // private copy constructors are good to have ! 231: #pragma warning(disable: 4512) // private operator= are good to have ! 232: #ifdef STRICT ! 233: #pragma warning(disable: 4305) // STRICT handles are near*, integer truncation ! 234: #endif ! 235: #endif ! 236: ! 237: ///////////////////////////////////////////////////////////////////////////// ! 238: // Basic object model ! 239: ! 240: struct CRuntimeClass ! 241: { ! 242: // Attributes ! 243: const char* m_pszClassName; ! 244: int m_nObjectSize; ! 245: UINT m_wSchema; // schema number of the loaded class ! 246: void (PASCAL *m_pfnConstruct)(void* p); // NULL => abstract class ! 247: CRuntimeClass* m_pBaseClass; ! 248: ! 249: // Operations ! 250: CObject* CreateObject(); ! 251: BOOL ConstructObject(void* pThis); ! 252: void Store(CArchive& ar); ! 253: static CRuntimeClass* Load(CArchive& ar, UINT* pwSchema); ! 254: ! 255: // Implementation ! 256: static CRuntimeClass* pFirstClass; // start of class list ! 257: CRuntimeClass* m_pNextClass; // linked list of registered classes ! 258: }; ! 259: ! 260: ! 261: ///////////////////////////////////////////////////////////////////////////// ! 262: // class CObject is the root of all compliant objects ! 263: ! 264: #if defined(_M_I86MM) ! 265: // force vtables to be in far code segments for medium model ! 266: class FAR CObjectRoot ! 267: { ! 268: protected: ! 269: virtual CRuntimeClass* GetRuntimeClass() NEAR const = 0; ! 270: }; ! 271: ! 272: #pragma warning(disable: 4149) // don't warn for medium model change ! 273: class NEAR CObject : public CObjectRoot ! 274: #else ! 275: class CObject ! 276: #endif ! 277: { ! 278: public: ! 279: ! 280: // Object model (types, destruction, allocation) ! 281: virtual CRuntimeClass* GetRuntimeClass() const; ! 282: virtual ~CObject(); // virtual destructors are necessary ! 283: ! 284: // Diagnostic allocations ! 285: void* operator new(size_t, void* p); ! 286: void* operator new(size_t nSize); ! 287: void operator delete(void* p); ! 288: ! 289: #ifdef _DEBUG ! 290: // for file name/line number tracking using DEBUG_NEW ! 291: void* operator new(size_t nSize, const char FAR* lpszFileName, int nLine); ! 292: #endif ! 293: ! 294: // Disable the copy constructor and assignment by default so you will get ! 295: // compiler errors instead of unexpected behaviour if you pass objects ! 296: // by value or assign objects. ! 297: protected: ! 298: CObject(); ! 299: private: ! 300: CObject(const CObject& objectSrc); ! 301: void operator=(const CObject& objectSrc); ! 302: ! 303: // Attributes ! 304: public: ! 305: BOOL IsSerializable() const; ! 306: ! 307: // Overridables ! 308: virtual void Serialize(CArchive& ar); ! 309: ! 310: // Diagnostic Support ! 311: virtual void AssertValid() const; ! 312: virtual void Dump(CDumpContext& dc) const; ! 313: ! 314: // Implementation ! 315: public: ! 316: // dynamic type checking/construction support ! 317: BOOL IsKindOf(const CRuntimeClass* pClass) const; ! 318: static void PASCAL Construct(void* pMemory); ! 319: ! 320: static CRuntimeClass NEAR classCObject; ! 321: }; ! 322: ! 323: #if defined(_M_I86MM) ! 324: #pragma warning(default: 4149) // base class now ambient ! 325: #endif ! 326: ! 327: ! 328: // Helper macros ! 329: #define RUNTIME_CLASS(class_name) \ ! 330: (&class_name::class##class_name) ! 331: ! 332: ///////////////////////////////////////////////////////////////////////////// ! 333: // Helper macros for declaring compliant classes ! 334: ! 335: #define DECLARE_DYNAMIC(class_name) \ ! 336: public: \ ! 337: static CRuntimeClass NEAR class##class_name; \ ! 338: virtual CRuntimeClass* GetRuntimeClass() const; ! 339: ! 340: #define DECLARE_SERIAL(class_name) \ ! 341: DECLARE_DYNAMIC(class_name) \ ! 342: static void PASCAL Construct(void* p); \ ! 343: friend CArchive& operator>>(CArchive& ar, class_name* &pOb); ! 344: ! 345: // generate static object constructor for class registration ! 346: struct NEAR CClassInit ! 347: { CClassInit(CRuntimeClass* pNewClass); }; ! 348: ! 349: #define IMPLEMENT_DYNAMIC(class_name, base_class_name) \ ! 350: CRuntimeClass NEAR class_name::class##class_name = { \ ! 351: #class_name, sizeof(class_name), 0xFFFF, NULL, \ ! 352: &base_class_name::class##base_class_name, NULL }; \ ! 353: static CClassInit _init_##class_name(&class_name::class##class_name);\ ! 354: CRuntimeClass* class_name::GetRuntimeClass() const \ ! 355: { return &class_name::class##class_name; } \ ! 356: // end of IMPLEMENT_DYNAMIC ! 357: ! 358: #define IMPLEMENT_SERIAL(class_name, base_class_name, wSchema) \ ! 359: void PASCAL class_name::Construct(void* p) \ ! 360: { new(p) class_name; } \ ! 361: CRuntimeClass NEAR class_name::class##class_name = { \ ! 362: #class_name, sizeof(class_name), wSchema, \ ! 363: &class_name::Construct, \ ! 364: &base_class_name::class##base_class_name, NULL }; \ ! 365: static CClassInit _init_##class_name(&class_name::class##class_name);\ ! 366: CRuntimeClass* class_name::GetRuntimeClass() const \ ! 367: { return &class_name::class##class_name; } \ ! 368: CArchive& operator>>(CArchive& ar, class_name* &pOb) \ ! 369: { ar >> (CObject*&) pOb; \ ! 370: if ((pOb != NULL) && !pOb->IsKindOf(RUNTIME_CLASS(class_name))) \ ! 371: AfxThrowArchiveException(CArchiveException::badClass);\ ! 372: return ar; } \ ! 373: // end of IMPLEMENT_SERIAL ! 374: ! 375: ///////////////////////////////////////////////////////////////////////////// ! 376: // setjmp for Windows and C++ ! 377: ! 378: #ifdef _NTWIN ! 379: typedef int jmp_buf[8]; ! 380: #else ! 381: typedef int jmp_buf[9]; ! 382: #endif ! 383: ! 384: #ifdef _NTWIN ! 385: #define setjmp _setjmp ! 386: #endif ! 387: ! 388: #if defined(_WINDOWS) && defined(_DOSWIN) ! 389: extern "C" int far pascal Catch(int FAR*); ! 390: #define setjmp ::Catch ! 391: #else ! 392: extern "C" int __cdecl setjmp(jmp_buf); ! 393: #endif ! 394: ! 395: ! 396: ///////////////////////////////////////////////////////////////////////////// ! 397: // Exceptions ! 398: ! 399: typedef void (CDECL *AFX_TERM_PROC)(); ! 400: struct CExceptionLink; ! 401: ! 402: AFX_TERM_PROC AfxSetTerminate(AFX_TERM_PROC); ! 403: ! 404: void CDECL AfxAbort(); ! 405: void CDECL AfxTerminate(); ! 406: ! 407: class CException : public CObject ! 408: { ! 409: // abstract class for dynamic type checking ! 410: DECLARE_DYNAMIC(CException) ! 411: }; ! 412: ! 413: // Exception global state - never access directly ! 414: struct CExceptionContext ! 415: { ! 416: CException* m_pCurrent; ! 417: BOOL m_bDeleteWhenDone; ! 418: CExceptionLink* m_pLinkTop; ! 419: ! 420: void Throw(CException* pNewException); ! 421: void Throw(CException* pNewException, BOOL bShared); ! 422: void ThrowLast(); ! 423: ! 424: void Cleanup(); // call to free up exception ! 425: }; ! 426: extern CExceptionContext NEAR afxExceptionContext; ! 427: ! 428: // Placed on frame for EXCEPTION linkage ! 429: struct CExceptionLink ! 430: { ! 431: CExceptionLink* m_pLinkPrev;// previous top, next in handler chain ! 432: jmp_buf m_jumpBuf; // arg for setjmp/longjmp ! 433: ! 434: CExceptionLink(CExceptionLink* NEAR& rLinkTop); ! 435: ~CExceptionLink(); ! 436: }; ! 437: ! 438: ///////////////////////////////////////////////////////////////////////////// ! 439: // Exception helper macros ! 440: ! 441: #define TRY \ ! 442: { \ ! 443: CExceptionLink _afxExLink(afxExceptionContext.m_pLinkTop); \ ! 444: if (setjmp(_afxExLink.m_jumpBuf) == 0) \ ! 445: ! 446: #define CATCH(class, e) \ ! 447: else { if (afxExceptionContext.m_pCurrent->IsKindOf(RUNTIME_CLASS(class)))\ ! 448: { class* e = (class*) afxExceptionContext.m_pCurrent; ! 449: ! 450: #define AND_CATCH(class, e) \ ! 451: } else if (afxExceptionContext.m_pCurrent->IsKindOf(RUNTIME_CLASS(class)))\ ! 452: { class* e = (class*) afxExceptionContext.m_pCurrent; ! 453: ! 454: #define END_CATCH \ ! 455: } else { THROW(afxExceptionContext.m_pCurrent); } \ ! 456: afxExceptionContext.Cleanup(); } } ! 457: ! 458: #define THROW(e) \ ! 459: afxExceptionContext.Throw(e); ! 460: #define THROW_LAST() \ ! 461: afxExceptionContext.ThrowLast(); ! 462: ! 463: ///////////////////////////////////////////////////////////////////////////// ! 464: // Standard Exception classes ! 465: ! 466: class CMemoryException : public CException ! 467: { ! 468: DECLARE_DYNAMIC(CMemoryException) ! 469: public: ! 470: CMemoryException(); ! 471: }; ! 472: ! 473: class CNotSupportedException : public CException ! 474: { ! 475: DECLARE_DYNAMIC(CNotSupportedException) ! 476: public: ! 477: CNotSupportedException(); ! 478: }; ! 479: ! 480: class CArchiveException : public CException ! 481: { ! 482: DECLARE_DYNAMIC(CArchiveException) ! 483: public: ! 484: enum { ! 485: none, ! 486: generic, ! 487: readOnly, ! 488: endOfFile, ! 489: writeOnly, ! 490: badIndex, ! 491: badClass, ! 492: badSchema ! 493: }; ! 494: ! 495: // Constructor ! 496: CArchiveException(int cause = CArchiveException::none); ! 497: ! 498: // Attributes ! 499: int m_cause; ! 500: ! 501: #ifdef _DEBUG ! 502: virtual void Dump(CDumpContext& dc) const; ! 503: #endif ! 504: }; ! 505: ! 506: class CFileException : public CException ! 507: { ! 508: DECLARE_DYNAMIC(CFileException) ! 509: ! 510: public: ! 511: enum { ! 512: none, ! 513: generic, ! 514: fileNotFound, ! 515: badPath, ! 516: tooManyOpenFiles, ! 517: accessDenied, ! 518: invalidFile, ! 519: removeCurrentDir, ! 520: directoryFull, ! 521: badSeek, ! 522: hardIO, ! 523: sharingViolation, ! 524: lockViolation, ! 525: diskFull, ! 526: endOfFile, ! 527: }; ! 528: ! 529: // Constructors ! 530: ! 531: CFileException(int cause = CFileException::none, LONG lOsError = -1); ! 532: ! 533: // Attributes ! 534: int m_cause; ! 535: LONG m_lOsError; ! 536: ! 537: // Operations ! 538: ! 539: // convert a OS dependent error code to a Cause ! 540: static int OsErrorToException(LONG lOsError); ! 541: static int ErrnoToException(int nErrno); ! 542: ! 543: // helper functions to throw exception after converting to a Cause ! 544: static void ThrowOsError(LONG lOsError); ! 545: static void ThrowErrno(int nErrno); ! 546: ! 547: #ifdef _DEBUG ! 548: virtual void Dump(CDumpContext&) const; ! 549: #endif ! 550: }; ! 551: ! 552: ///////////////////////////////////////////////////////////////////////////// ! 553: // Standard exception throws ! 554: ! 555: void PASCAL AfxThrowMemoryException(); ! 556: void PASCAL AfxThrowNotSupportedException(); ! 557: void PASCAL AfxThrowArchiveException(int cause); ! 558: void PASCAL AfxThrowFileException(int cause, LONG lOsError = -1); ! 559: ! 560: ! 561: ///////////////////////////////////////////////////////////////////////////// ! 562: // File - raw unbuffered disk file I/O ! 563: ! 564: class CFile : public CObject ! 565: { ! 566: DECLARE_DYNAMIC(CFile) ! 567: ! 568: public: ! 569: // Flag values ! 570: enum OpenFlags { ! 571: modeRead = 0x0000, ! 572: modeWrite = 0x0001, ! 573: modeReadWrite = 0x0002, ! 574: shareCompat = 0x0000, ! 575: shareExclusive = 0x0010, ! 576: shareDenyWrite = 0x0020, ! 577: shareDenyRead = 0x0030, ! 578: shareDenyNone = 0x0040, ! 579: modeNoInherit = 0x0080, ! 580: modeCreate = 0x1000, ! 581: typeText = 0x4000, // typeText and typeBinary are used in ! 582: typeBinary = (int)0x8000 // derived classes only ! 583: }; ! 584: ! 585: enum Attribute { ! 586: normal = 0x00, ! 587: readOnly = 0x01, ! 588: hidden = 0x02, ! 589: system = 0x04, ! 590: volume = 0x08, ! 591: directory = 0x10, ! 592: archive = 0x20 ! 593: }; ! 594: ! 595: enum SeekPosition { begin = 0x0, current = 0x1, end = 0x2 }; ! 596: ! 597: enum {hFileNull = -1}; ! 598: ! 599: // Constructors ! 600: CFile(); ! 601: CFile(int hFile); ! 602: CFile(const char* pszFileName, UINT nOpenFlags); ! 603: ! 604: // Attributes ! 605: UINT m_hFile; ! 606: ! 607: virtual DWORD GetPosition() const; ! 608: virtual BOOL GetStatus(CFileStatus& rStatus) const; ! 609: ! 610: // Operations ! 611: virtual BOOL Open(const char* pszFileName, UINT nOpenFlags, CFileException* pError = NULL); ! 612: ! 613: static void Rename(const char* pszOldName, const char* pszNewName); ! 614: static void Remove(const char* pszFileName); ! 615: static BOOL GetStatus(const char* pszFileName, CFileStatus& rStatus); ! 616: static void SetStatus(const char* pszFileName, const CFileStatus& status); ! 617: ! 618: DWORD SeekToEnd(); ! 619: void SeekToBegin(); ! 620: ! 621: // Overridables ! 622: virtual CFile* Duplicate() const; ! 623: ! 624: virtual LONG Seek(LONG lOff, UINT nFrom); ! 625: virtual void SetLength(DWORD dwNewLen); ! 626: virtual DWORD GetLength() const; ! 627: ! 628: virtual UINT Read(void FAR* lpBuf, UINT nCount); ! 629: virtual void Write(const void FAR* lpBuf, UINT nCount); ! 630: ! 631: virtual void LockRange(DWORD dwPos, DWORD dwCount); ! 632: virtual void UnlockRange(DWORD dwPos, DWORD dwCount); ! 633: ! 634: virtual void Flush(); ! 635: virtual void Close(); ! 636: ! 637: #ifdef _DEBUG ! 638: virtual void AssertValid() const; ! 639: virtual void Dump(CDumpContext& dc) const; ! 640: #endif ! 641: ! 642: // Implementation ! 643: virtual ~CFile(); ! 644: protected: ! 645: BOOL m_bCloseOnDelete; ! 646: }; ! 647: ! 648: ///////////////////////////////////////////////////////////////////////////// ! 649: // STDIO file implementation ! 650: ! 651: class CStdioFile : public CFile ! 652: { ! 653: DECLARE_DYNAMIC(CStdioFile) ! 654: ! 655: public: ! 656: // Constructors ! 657: CStdioFile(); ! 658: CStdioFile(FILE* pOpenStream); ! 659: CStdioFile(const char* pszFileName, UINT nOpenFlags); ! 660: ! 661: // Attributes ! 662: FILE* m_pStream; // stdio FILE ! 663: // m_hFile from base class is _fileno(m_pStream) ! 664: ! 665: virtual DWORD GetPosition() const; ! 666: ! 667: // Overridables ! 668: virtual BOOL Open(const char* pszFileName, UINT nOpenFlags, CFileException* pError = NULL); ! 669: virtual UINT Read(void FAR* lpBuf, UINT nCount); ! 670: virtual void Write(const void FAR* lpBuf, UINT nCount); ! 671: virtual LONG Seek(LONG lOff, UINT nFrom); ! 672: virtual void Flush(); ! 673: virtual void Close(); ! 674: ! 675: virtual void WriteString(const char FAR* lpsz); // write a string, like "C" fputs ! 676: virtual char FAR* ReadString(char FAR* lpsz, UINT nMax); // like "C" fgets ! 677: ! 678: // Unsupported APIs ! 679: virtual CFile* Duplicate() const; ! 680: virtual void LockRange(DWORD dwPos, DWORD dwCount); ! 681: virtual void UnlockRange(DWORD dwPos, DWORD dwCount); ! 682: ! 683: ! 684: #ifdef _DEBUG ! 685: void Dump(CDumpContext& dc) const; ! 686: #endif ! 687: // Implementation ! 688: virtual ~CStdioFile(); ! 689: }; ! 690: ! 691: //////////////////////////////////////////////////////////////////////////// ! 692: // Memory based file implementation ! 693: ! 694: class CMemFile : public CFile ! 695: { ! 696: DECLARE_DYNAMIC(CMemFile) ! 697: ! 698: public: ! 699: // Constructors ! 700: CMemFile(UINT nGrowBytes = 1024); ! 701: ! 702: // Attributes ! 703: virtual DWORD GetPosition() const; ! 704: virtual BOOL GetStatus(CFileStatus& rStatus) const; ! 705: ! 706: // Overridables ! 707: virtual LONG Seek(LONG lOff, UINT nFrom); ! 708: virtual void SetLength(DWORD dwNewLen); ! 709: virtual UINT Read(void FAR* lpBuf, UINT nCount); ! 710: virtual void Write(const void FAR* lpBuf, UINT nCount); ! 711: virtual void Flush(); ! 712: virtual void Close(); ! 713: ! 714: #ifdef _DEBUG ! 715: virtual void Dump(CDumpContext& dc) const; ! 716: virtual void AssertValid() const; ! 717: #endif ! 718: ! 719: // Unsupported APIs ! 720: virtual CFile* Duplicate() const; ! 721: virtual void LockRange(DWORD dwPos, DWORD dwCount); ! 722: virtual void UnlockRange(DWORD dwPos, DWORD dwCount); ! 723: ! 724: ! 725: // Implementation ! 726: virtual ~CMemFile(); ! 727: ! 728: protected: ! 729: virtual BYTE FAR* Alloc(UINT nBytes); ! 730: virtual BYTE FAR* Realloc(BYTE FAR* lpMem, UINT nBytes); ! 731: virtual BYTE FAR* Memcpy(BYTE FAR* lpMemTarget, const BYTE FAR* lpMemSource, UINT nCount); ! 732: virtual void Free(BYTE FAR* lpMem); ! 733: virtual void GrowFile(DWORD dwNewLen); ! 734: ! 735: UINT m_nGrowBytes; ! 736: UINT m_nPosition; ! 737: UINT m_nBufferSize; ! 738: UINT m_nFileSize; ! 739: BYTE FAR* m_lpBuffer; ! 740: }; ! 741: ! 742: ///////////////////////////////////////////////////////////////////////////// ! 743: // Strings ! 744: ! 745: class CString ! 746: { ! 747: public: ! 748: ! 749: // Constructors ! 750: CString(); ! 751: CString(const CString& stringSrc); ! 752: CString(char ch, int nRepeat = 1); ! 753: CString(const char* psz); ! 754: CString(const char* pch, int nLength); ! 755: #ifdef _NEARDATA ! 756: // Additional versions for far string data ! 757: CString(const char FAR* lpsz); ! 758: CString(const char FAR* lpch, int nLength); ! 759: #endif ! 760: ~CString(); ! 761: ! 762: // Attributes & Operations ! 763: ! 764: // as an array of characters ! 765: int GetLength() const; ! 766: BOOL IsEmpty() const; ! 767: void Empty(); // free up the data ! 768: ! 769: char GetAt(int nIndex) const; // 0 based ! 770: char operator[](int nIndex) const; // same as GetAt ! 771: void SetAt(int nIndex, char ch); ! 772: operator const char*() const; // as a C string ! 773: ! 774: // overloaded assignment ! 775: const CString& operator=(const CString& stringSrc); ! 776: const CString& operator=(char ch); ! 777: const CString& operator=(const char* psz); ! 778: ! 779: // string concatenation ! 780: const CString& operator+=(const CString& string); ! 781: const CString& operator+=(char ch); ! 782: const CString& operator+=(const char* psz); ! 783: ! 784: friend CString operator+(const CString& string1, const CString& string2); ! 785: friend CString operator+(const CString& string, char ch); ! 786: friend CString operator+(char ch, const CString& string); ! 787: friend CString operator+(const CString& string, const char* psz); ! 788: friend CString operator+(const char* psz, const CString& string); ! 789: ! 790: // string comparison ! 791: int Compare(const char* psz) const; // straight character ! 792: int CompareNoCase(const char* psz) const; // ignore case ! 793: int Collate(const char* psz) const; // NLS aware ! 794: ! 795: // simple sub-string extraction ! 796: CString Mid(int nFirst, int nCount) const; ! 797: CString Mid(int nFirst) const; ! 798: CString Left(int nCount) const; ! 799: CString Right(int nCount) const; ! 800: ! 801: CString SpanIncluding(const char* pszCharSet) const; ! 802: CString SpanExcluding(const char* pszCharSet) const; ! 803: ! 804: // upper/lower/reverse conversion ! 805: void MakeUpper(); ! 806: void MakeLower(); ! 807: void MakeReverse(); ! 808: ! 809: // searching (return starting index, or -1 if not found) ! 810: // look for a single character match ! 811: int Find(char ch) const; // like "C" strchr ! 812: int ReverseFind(char ch) const; ! 813: int FindOneOf(const char* pszCharSet) const; ! 814: ! 815: // look for a specific sub-string ! 816: int Find(const char* pszSub) const; // like "C" strstr ! 817: ! 818: // input and output ! 819: #ifdef _DEBUG ! 820: friend CDumpContext& operator<<(CDumpContext&, const CString& string); ! 821: #endif ! 822: friend CArchive& operator<<(CArchive& ar, const CString& string); ! 823: friend CArchive& operator>>(CArchive& ar, CString& string); ! 824: ! 825: // Windows support ! 826: #ifdef _WINDOWS ! 827: BOOL LoadString(UINT nID); // load from string resource ! 828: // 255 chars max ! 829: // ANSI<->OEM support (convert string in place) ! 830: void AnsiToOem(); ! 831: void OemToAnsi(); ! 832: #endif //_WINDOWS ! 833: ! 834: // Access to string implementation buffer as "C" character array ! 835: char* GetBuffer(int nMinBufLength); ! 836: void ReleaseBuffer(int nNewLength = -1); ! 837: char* GetBufferSetLength(int nNewLength); ! 838: ! 839: // Implementation ! 840: protected: ! 841: // lengths/sizes in characters ! 842: // (note: an extra character is always allocated) ! 843: char* m_pchData; // actual string (zero terminated) ! 844: int m_nDataLength; // does not include terminating 0 ! 845: int m_nAllocLength; // does not include terminating 0 ! 846: ! 847: // implementation helpers ! 848: void Init(); ! 849: void AllocCopy(CString& dest, int nCopyLen, int nCopyIndex, int nExtraLen) const; ! 850: void AllocBuffer(int nLen); ! 851: void AssignCopy(int nSrcLen, const char* pszSrcData); ! 852: void ConcatCopy(int nSrc1Len, const char* pszSrc1Data, int nSrc2Len, const char* pszSrc2Data); ! 853: void ConcatInPlace(int nSrcLen, const char* pszSrcData); ! 854: }; ! 855: ! 856: ! 857: // Compare helpers ! 858: BOOL operator==(const CString& s1, const CString& s2); ! 859: BOOL operator==(const CString& s1, const char* s2); ! 860: BOOL operator==(const char* s1, const CString& s2); ! 861: BOOL operator!=(const CString& s1, const CString& s2); ! 862: BOOL operator!=(const CString& s1, const char* s2); ! 863: BOOL operator!=(const char* s1, const CString& s2); ! 864: BOOL operator<(const CString& s1, const CString& s2); ! 865: BOOL operator<(const CString& s1, const char* s2); ! 866: BOOL operator<(const char* s1, const CString& s2); ! 867: BOOL operator>(const CString& s1, const CString& s2); ! 868: BOOL operator>(const CString& s1, const char* s2); ! 869: BOOL operator>(const char* s1, const CString& s2); ! 870: BOOL operator<=(const CString& s1, const CString& s2); ! 871: BOOL operator<=(const CString& s1, const char* s2); ! 872: BOOL operator<=(const char* s1, const CString& s2); ! 873: BOOL operator>=(const CString& s1, const CString& s2); ! 874: BOOL operator>=(const CString& s1, const char* s2); ! 875: BOOL operator>=(const char* s1, const CString& s2); ! 876: ! 877: ///////////////////////////////////////////////////////////////////////////// ! 878: // CTimeSpan and CTime ! 879: ! 880: class CTimeSpan ! 881: { ! 882: public: ! 883: ! 884: // Constructors ! 885: CTimeSpan(); ! 886: CTimeSpan(time_t time); ! 887: CTimeSpan(LONG lDays, int nHours, int nMins, int nSecs); ! 888: ! 889: CTimeSpan(const CTimeSpan& timeSpanSrc); ! 890: const CTimeSpan& operator=(const CTimeSpan& timeSpanSrc); ! 891: ! 892: // Attributes ! 893: // extract parts ! 894: LONG GetDays() const; // total # of days ! 895: LONG GetTotalHours() const; ! 896: int GetHours() const; ! 897: LONG GetTotalMinutes() const; ! 898: int GetMinutes() const; ! 899: LONG GetTotalSeconds() const; ! 900: int GetSeconds() const; ! 901: ! 902: // Operations ! 903: // time math ! 904: CTimeSpan operator-(CTimeSpan timeSpan) const; ! 905: CTimeSpan operator+(CTimeSpan timeSpan) const; ! 906: const CTimeSpan& operator+=(CTimeSpan timeSpan); ! 907: const CTimeSpan& operator-=(CTimeSpan timeSpan); ! 908: BOOL operator==(CTimeSpan timeSpan) const; ! 909: BOOL operator!=(CTimeSpan timeSpan) const; ! 910: BOOL operator<(CTimeSpan timeSpan) const; ! 911: BOOL operator>(CTimeSpan timeSpan) const; ! 912: BOOL operator<=(CTimeSpan timeSpan) const; ! 913: BOOL operator>=(CTimeSpan timeSpan) const; ! 914: ! 915: #ifndef _WINDLL ! 916: CString Format(const char* pFormat); ! 917: #endif //!_WINDLL ! 918: ! 919: // serialization ! 920: #ifdef _DEBUG ! 921: friend CDumpContext& operator<<(CDumpContext& dc, CTimeSpan timeSpan); ! 922: #endif ! 923: friend CArchive& operator<<(CArchive& ar, CTimeSpan timeSpan); ! 924: friend CArchive& operator>>(CArchive& ar, CTimeSpan& rtimeSpan); ! 925: ! 926: private: ! 927: time_t m_timeSpan; ! 928: friend class CTime; ! 929: }; ! 930: ! 931: ! 932: class CTime ! 933: { ! 934: public: ! 935: ! 936: // Constructors ! 937: static CTime GetCurrentTime(); ! 938: ! 939: CTime(); ! 940: CTime(time_t time); ! 941: CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec); ! 942: CTime(WORD wDosDate, WORD wDosTime); ! 943: CTime(const CTime& timeSrc); ! 944: ! 945: #ifdef _NTWIN ! 946: struct _SYSTEMTIME; ! 947: struct _FILETIME; ! 948: CTime(const _SYSTEMTIME& sysTime); ! 949: CTime(const _FILETIME& fileTime); ! 950: #endif ! 951: ! 952: const CTime& operator=(const CTime& timeSrc); ! 953: const CTime& operator=(time_t t); ! 954: ! 955: // Attributes ! 956: struct tm* GetGmtTm(struct tm* ptm = NULL) const; ! 957: struct tm* GetLocalTm(struct tm* ptm = NULL) const; ! 958: ! 959: time_t GetTime() const; ! 960: int GetYear() const; ! 961: int GetMonth() const; // month of year (1 = Jan) ! 962: int GetDay() const; // day of month ! 963: int GetHour() const; ! 964: int GetMinute() const; ! 965: int GetSecond() const; ! 966: int GetDayOfWeek() const; // 1=Sun, 2=Mon, ..., 7=Sat ! 967: ! 968: // Operations ! 969: // time math ! 970: CTimeSpan operator-(CTime time) const; ! 971: CTime operator-(CTimeSpan timeSpan) const; ! 972: CTime operator+(CTimeSpan timeSpan) const; ! 973: const CTime& operator+=(CTimeSpan timeSpan); ! 974: const CTime& operator-=(CTimeSpan timeSpan); ! 975: BOOL operator==(CTime time) const; ! 976: BOOL operator!=(CTime time) const; ! 977: BOOL operator<(CTime time) const; ! 978: BOOL operator>(CTime time) const; ! 979: BOOL operator<=(CTime time) const; ! 980: BOOL operator>=(CTime time) const; ! 981: ! 982: // formatting using "C" strftime ! 983: #ifndef _WINDLL ! 984: CString Format(const char* pFormat); ! 985: CString FormatGmt(const char* pFormat); ! 986: #endif //!_WINDLL ! 987: ! 988: // serialization ! 989: #ifdef _DEBUG ! 990: friend CDumpContext& operator<<(CDumpContext& dc, CTime time); ! 991: #endif ! 992: friend CArchive& operator<<(CArchive& ar, CTime time); ! 993: friend CArchive& operator>>(CArchive& ar, CTime& rtime); ! 994: ! 995: private: ! 996: time_t m_time; ! 997: }; ! 998: ! 999: ///////////////////////////////////////////////////////////////////////////// ! 1000: // File status ! 1001: ! 1002: struct CFileStatus ! 1003: { ! 1004: CTime m_ctime; // creation date/time of file ! 1005: CTime m_mtime; // last modification date/time of file ! 1006: CTime m_atime; // last access date/time of file ! 1007: LONG m_size; // logical size of file in bytes ! 1008: BYTE m_attribute; // logical OR of CFile::Attribute enum values ! 1009: BYTE _m_padding; // pad the structure to a WORD ! 1010: char m_szFullName[_MAX_PATH]; // absolute path name ! 1011: ! 1012: #ifdef _DEBUG ! 1013: void Dump(CDumpContext& dc) const; ! 1014: #endif ! 1015: }; ! 1016: ! 1017: ! 1018: ///////////////////////////////////////////////////////////////////////////// ! 1019: // Diagnostic memory management routines ! 1020: ! 1021: #ifdef _DEBUG ! 1022: ! 1023: extern "C" BOOL AfxDiagnosticInit(void); ! 1024: ! 1025: // Memory tracking allocation ! 1026: void* operator new(size_t nSize, const char FAR* lpszFileName, int nLine); ! 1027: #define DEBUG_NEW new(THIS_FILE, __LINE__) ! 1028: ! 1029: // Low level sanity checks for memory blocks ! 1030: extern "C" BOOL FAR PASCAL AfxIsValidAddress(const void FAR* lp, ! 1031: UINT nBytes, BOOL bReadWrite = TRUE); ! 1032: #ifdef _NEARDATA ! 1033: inline BOOL PASCAL AfxIsValidAddress(const void NEAR* np, ! 1034: UINT nBytes, BOOL bReadWrite = TRUE) ! 1035: { return np != NULL && ::AfxIsValidAddress((const void FAR*)np, ! 1036: nBytes, bReadWrite); } ! 1037: #endif ! 1038: ! 1039: // Return TRUE if valid memory block of nBytes ! 1040: BOOL PASCAL AfxIsMemoryBlock(const void* p, UINT nBytes, LONG* plRequestNumber = NULL); ! 1041: ! 1042: // Return TRUE if memory is sane or print out what is wrong ! 1043: BOOL PASCAL AfxCheckMemory(); ! 1044: ! 1045: // Options for tuning the allocation diagnostics ! 1046: extern "C" ! 1047: { ! 1048: extern int afxMemDF; // global variable for easy setting in debugger ! 1049: } ! 1050: ! 1051: enum AfxMemDF // memory debug/diagnostic flags ! 1052: { ! 1053: allocMemDF = 0x01, // turn on debugging allocator ! 1054: delayFreeMemDF = 0x02, // delay freeing memory memory ! 1055: checkAlwaysMemDF = 0x04, // AfxCheckMemory on every alloc/free ! 1056: }; ! 1057: ! 1058: // turn on/off tracking for a short while ! 1059: BOOL PASCAL AfxEnableMemoryTracking(BOOL bTrack); ! 1060: ! 1061: // Memory allocator failure simulation and control (_DEBUG only) ! 1062: ! 1063: // A failure hook returns whether to permit allocation ! 1064: typedef BOOL (PASCAL * AFX_ALLOC_HOOK)(size_t nSize, BOOL bObject, LONG lRequestNumber); ! 1065: ! 1066: // Set new hook, return old (never NULL) ! 1067: AFX_ALLOC_HOOK AfxSetAllocHook(AFX_ALLOC_HOOK pfnAllocHook); ! 1068: ! 1069: // Debugger hook on specified allocation request ! 1070: void PASCAL AfxSetAllocStop(LONG lRequestNumber); ! 1071: ! 1072: // Memory state for snapshots/leak detection ! 1073: struct CMemoryState ! 1074: { ! 1075: // Attributes ! 1076: enum blockUsage ! 1077: { ! 1078: freeBlock, // not used ! 1079: objectBlock, // contains a CObject derived class object ! 1080: bitBlock, // contains ::operator new data ! 1081: nBlockUseMax, // total number of usages ! 1082: }; ! 1083: ! 1084: struct CBlockHeader* m_pBlockHeader; ! 1085: LONG m_lCounts[nBlockUseMax]; ! 1086: LONG m_lSizes[nBlockUseMax]; ! 1087: LONG m_lHighWaterCount; ! 1088: LONG m_lTotalCount; ! 1089: ! 1090: CMemoryState(); ! 1091: ! 1092: // Operations ! 1093: void Checkpoint(); // fill with current state ! 1094: BOOL Difference(const CMemoryState& oldState, ! 1095: const CMemoryState& newState); // fill with difference ! 1096: ! 1097: // Output to afxDump ! 1098: void DumpStatistics() const; ! 1099: void DumpAllObjectsSince() const; ! 1100: }; ! 1101: ! 1102: // Enumerate allocated objects or runtime classes ! 1103: void PASCAL AfxDoForAllObjects(void (*pfn)(CObject* pObject, void* pContext), void* pContext); ! 1104: void PASCAL AfxDoForAllClasses(void (*pfn)(const CRuntimeClass* pClass, void* pContext), void* pContext); ! 1105: ! 1106: #else ! 1107: ! 1108: // NonDebug version that assume everything is OK ! 1109: #define DEBUG_NEW new ! 1110: #define AfxCheckMemory() TRUE ! 1111: #define AfxIsMemoryBlock(pBuf, nBytes) TRUE ! 1112: ! 1113: #endif // _DEBUG ! 1114: ! 1115: ///////////////////////////////////////////////////////////////////////////// ! 1116: // Archives for serializing CObject data ! 1117: ! 1118: // needed for implementation ! 1119: class CPtrArray; ! 1120: class CMapPtrToWord; ! 1121: ! 1122: class CArchive ! 1123: { ! 1124: public: ! 1125: // Flag values ! 1126: enum Mode { store = 0, load = 1 }; ! 1127: ! 1128: CArchive(CFile* pFile, UINT nMode, int nBufSize = 512, void FAR* lpBuf = NULL); ! 1129: ~CArchive(); ! 1130: ! 1131: // Attributes ! 1132: BOOL IsLoading() const; ! 1133: BOOL IsStoring() const; ! 1134: CFile* GetFile() const; ! 1135: ! 1136: // Operations ! 1137: UINT Read(void FAR* lpBuf, UINT nMax); ! 1138: void Write(const void FAR* lpBuf, UINT nMax); ! 1139: void Flush(); ! 1140: void Close(); ! 1141: ! 1142: protected: ! 1143: void FillBuffer(UINT nBytesNeeded); ! 1144: CObject* ReadObject(const CRuntimeClass* pClass); ! 1145: void WriteObject(const CObject* pOb); ! 1146: ! 1147: public: ! 1148: // Object I/O is pointer based to avoid added construction overhead. ! 1149: // Use the Serialize member function directly for embedded objects. ! 1150: friend CArchive& operator<<(CArchive& ar, const CObject* pOb); ! 1151: ! 1152: friend CArchive& operator>>(CArchive& ar, CObject*& pOb); ! 1153: friend CArchive& operator>>(CArchive& ar, const CObject*& pOb); ! 1154: ! 1155: // insertion operations ! 1156: // NOTE: operators available only for fixed size types for portability ! 1157: CArchive& operator<<(BYTE by); ! 1158: CArchive& operator<<(WORD w); ! 1159: CArchive& operator<<(LONG l); ! 1160: CArchive& operator<<(DWORD dw); ! 1161: ! 1162: // extraction operations ! 1163: // NOTE: operators available only for fixed size types for portability ! 1164: CArchive& operator>>(BYTE& by); ! 1165: CArchive& operator>>(WORD& w); ! 1166: CArchive& operator>>(DWORD& dw); ! 1167: CArchive& operator>>(LONG& l); ! 1168: ! 1169: // Implementation ! 1170: protected: ! 1171: // archive objects cannot be copied or assigned ! 1172: CArchive(const CArchive& arSrc); ! 1173: void operator=(const CArchive& arSrc); ! 1174: ! 1175: BOOL m_nMode; ! 1176: BOOL m_bUserBuf; ! 1177: int m_nBufSize; ! 1178: CFile* m_pFile; ! 1179: BYTE FAR* m_lpBufCur; ! 1180: BYTE FAR* m_lpBufMax; ! 1181: BYTE FAR* m_lpBufStart; ! 1182: ! 1183: UINT m_nMapCount; // count and map used when storing ! 1184: union ! 1185: { ! 1186: CPtrArray* m_pLoadArray; ! 1187: CMapPtrToWord* m_pStoreMap; ! 1188: }; ! 1189: }; ! 1190: ! 1191: ! 1192: ///////////////////////////////////////////////////////////////////////////// ! 1193: // Diagnostic dumping ! 1194: ! 1195: class CDumpContext ! 1196: { ! 1197: public: ! 1198: CDumpContext(CFile* pFile); ! 1199: ! 1200: // Attributes ! 1201: int GetDepth() const; // 0 => this object, 1 => children objects ! 1202: void SetDepth(int nNewDepth); ! 1203: ! 1204: // Operations ! 1205: CDumpContext& operator<<(const char FAR* lpsz); ! 1206: CDumpContext& operator<<(const void FAR* lp); ! 1207: #ifdef _NEARDATA ! 1208: CDumpContext& operator<<(const void NEAR* np); ! 1209: #endif ! 1210: CDumpContext& operator<<(const CObject* pOb); ! 1211: CDumpContext& operator<<(const CObject& ob); ! 1212: CDumpContext& operator<<(BYTE by); ! 1213: CDumpContext& operator<<(WORD w); ! 1214: CDumpContext& operator<<(UINT u); ! 1215: CDumpContext& operator<<(LONG l); ! 1216: CDumpContext& operator<<(DWORD dw); ! 1217: CDumpContext& operator<<(int n); ! 1218: void HexDump(const char* pszLine, BYTE* pby, int nBytes, int nWidth); ! 1219: void Flush(); ! 1220: ! 1221: // Implementation ! 1222: protected: ! 1223: // dump context objects cannot be copied or assigned ! 1224: CDumpContext(const CDumpContext& dcSrc); ! 1225: void operator=(const CDumpContext& dcSrc); ! 1226: void OutputString(const char FAR* lpsz); ! 1227: ! 1228: int m_nDepth; ! 1229: ! 1230: public: ! 1231: CFile* m_pFile; ! 1232: }; ! 1233: ! 1234: #ifdef _DEBUG ! 1235: extern CDumpContext& afxDump; ! 1236: extern "C" BOOL afxTraceEnabled; ! 1237: #endif ! 1238: ! 1239: ///////////////////////////////////////////////////////////////////////////// ! 1240: // Other implementation helpers ! 1241: ! 1242: #define BEFORE_START_POSITION ((void*)(void NEAR*)-1) ! 1243: #define _AFX_FP_OFF(thing) (*((UINT*)&(thing))) ! 1244: #define _AFX_FP_SEG(lp) (*((UINT*)&(lp)+1)) ! 1245: ! 1246: ! 1247: ///////////////////////////////////////////////////////////////////////////// ! 1248: // Swap tuning for AFX library ! 1249: ! 1250: // Use BASED_CODE so that it may be easily redefined for tuning purposes ! 1251: ! 1252: // Data defined using this modifier is placed in the current ! 1253: // code segment, which is modified with #pragma code_seg ! 1254: #ifndef BASED_CODE ! 1255: #define BASED_CODE __based(__segname("_CODE")) ! 1256: #endif ! 1257: ! 1258: #if defined(_M_I86MM) || defined(_M_I86LM) // far code ! 1259: #define AFX_CORE_SEG "AFX_CORE_TEXT" /* core functionality */ ! 1260: #define AFX_AUX_SEG "AFX_AUX_TEXT" /* auxilliary functionality */ ! 1261: #define AFX_COLL_SEG "AFX_COLL_TEXT" /* collections */ ! 1262: #define AFX_OLE_SEG "AFX_OLE_TEXT" /* OLE support */ ! 1263: #endif ! 1264: ///////////////////////////////////////////////////////////////////////////// ! 1265: // Inline function declarations ! 1266: ! 1267: #include "afx.inl" ! 1268: ! 1269: #endif // __AFX_H__
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.