开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
object.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：31k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

object.cxx：源码内容
  1. /*
  2.  * object.cxx
  3.  *
  4.  * Global object support.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: object.cxx,v $
  30.  * Revision 1.44  2000/06/26 11:17:20  robertj
  31.  * Nucleus++ port (incomplete).
  32.  *
  33.  * Revision 1.43  2000/01/05 00:29:12  robertj
  34.  * Fixed alignment problems in memory checking debug functions.
  35.  *
  36.  * Revision 1.42  1999/11/01 00:17:20  robertj
  37.  * Added override of new functions for MSVC memory check code.
  38.  *
  39.  * Revision 1.41  1999/08/22 13:38:39  robertj
  40.  * Fixed termination hang up problem with memory check code under unix pthreads.
  41.  *
  42.  * Revision 1.40  1999/08/10 10:45:09  robertj
  43.  * Added mutex in memory check detection code.
  44.  *
  45.  * Revision 1.39  1999/07/18 15:08:48  robertj
  46.  * Fixed 64 bit compatibility
  47.  *
  48.  * Revision 1.38  1999/05/01 11:29:20  robertj
  49.  * Alpha linux port changes.
  50.  *
  51.  * Revision 1.37  1999/03/09 10:30:17  robertj
  52.  * Fixed ability to have PMEMORY_CHECK on/off on both debug/release versions.
  53.  *
  54.  * Revision 1.36  1999/02/22 10:48:14  robertj
  55.  * Fixed delete operator prototypes for MSVC6 and GNU compatibility.
  56.  *
  57.  * Revision 1.35  1998/12/22 10:24:17  robertj
  58.  * Fixed MSVC warnings caused by changes made in linux PPC support.
  59.  *
  60.  * Revision 1.34  1998/12/15 09:01:10  robertj
  61.  * Fixed 8 byte alignment problem in memory leak check code for sparc.
  62.  *
  63.  * Revision 1.33  1998/11/30 05:33:00  robertj
  64.  * Fixed duplicate debug stream class, ther can be only one.
  65.  *
  66.  * Revision 1.32  1998/11/03 03:11:53  robertj
  67.  * Fixed memory leak question so correctly detects leaks and can be ^C'd.
  68.  *
  69.  * Revision 1.31  1998/11/03 00:55:31  robertj
  70.  * Added allocation breakpoint variable.
  71.  *
  72.  * Revision 1.30  1998/10/15 07:48:56  robertj
  73.  * Added hex dump to memory leak.
  74.  * Added ability to ignore G++lib memory leaks.
  75.  *
  76.  * Revision 1.29  1998/10/15 01:53:35  robertj
  77.  * GNU compatibility.
  78.  *
  79.  * Revision 1.28  1998/10/13 14:06:26  robertj
  80.  * Complete rewrite of memory leak detection code.
  81.  *
  82.  * Revision 1.27  1998/09/23 06:22:22  robertj
  83.  * Added open source copyright license.
  84.  *
  85.  * Revision 1.26  1998/05/30 13:27:02  robertj
  86.  * Changed memory check code so global statics are not included in leak check.
  87.  *
  88.  * Revision 1.25  1997/07/08 13:07:07  robertj
  89.  * DLL support.
  90.  *
  91.  * Revision 1.24  1997/02/09 03:45:28  robertj
  92.  * Fixed unix/dos compatibility with include file.
  93.  *
  94.  * Revision 1.23  1997/02/05 11:54:12  robertj
  95.  * Fixed problems with memory check and leak detection.
  96.  *
  97.  * Revision 1.22  1996/08/08 10:08:46  robertj
  98.  * Directory structure changes for common files.
  99.  *
  100.  * Revision 1.21  1996/07/15 10:35:11  robertj
  101.  * Changed memory leak dump to use static class rather than atexit for better portability.
  102.  *
  103.  * Revision 1.20  1996/06/17 11:35:47  robertj
  104.  * Fixed display of memory leak info, needed flush and use of cin as getchar() does not work with services.
  105.  *
  106.  * Revision 1.19  1996/05/09 12:19:29  robertj
  107.  * Fixed up 64 bit integer class for Mac platform.
  108.  * Fixed incorrect use of memcmp/strcmp return value.
  109.  *
  110.  * Revision 1.18  1996/03/26 00:55:20  robertj
  111.  * Added keypress before dumping memory leaks.
  112.  *
  113.  * Revision 1.17  1996/01/28 02:50:27  robertj
  114.  * Added missing bit shift operators to 64 bit integer class.
  115.  * Added assert into all Compare functions to assure comparison between compatible objects.
  116.  *
  117.  * Revision 1.16  1996/01/23 13:15:52  robertj
  118.  * Mac Metrowerks compiler support.
  119.  *
  120.  * Revision 1.15  1996/01/02 12:52:02  robertj
  121.  * Mac OS compatibility changes.
  122.  *
  123.  * Revision 1.14  1995/11/21 11:51:54  robertj
  124.  * Improved streams compatibility.
  125.  *
  126.  * Revision 1.12  1995/04/25 11:30:34  robertj
  127.  * Fixed Borland compiler warnings.
  128.  * Fixed function hiding ancestors virtual.
  129.  *
  130.  * Revision 1.11  1995/03/12 04:59:53  robertj
  131.  * Re-organisation of DOS/WIN16 and WIN32 platforms to maximise common code.
  132.  * Used built-in equate for WIN32 API (_WIN32).
  133.  *
  134.  * Revision 1.10  1995/02/19  04:19:21  robertj
  135.  * Added dynamically linked command processing.
  136.  *
  137.  * Revision 1.9  1995/01/15  04:52:02  robertj
  138.  * Mac compatibility.
  139.  * Added memory stats function.
  140.  *
  141. // Revision 1.8  1995/01/09  12:38:07  robertj
  142. // Changed variable names around during documentation run.
  143. // Fixed smart pointer comparison.
  144. // Fixed serialisation stuff.
  145. //
  146. // Revision 1.7  1995/01/07  04:39:45  robertj
  147. // Redesigned font enumeration code and changed font styles.
  148. //
  149. // Revision 1.6  1995/01/04  10:57:08  robertj
  150. // Changed for HPUX and GNU2.6.x
  151. //
  152. // Revision 1.5  1995/01/03  09:39:10  robertj
  153. // Put standard malloc style memory allocation etc into memory check system.
  154. //
  155. // Revision 1.4  1994/12/21  11:43:29  robertj
  156. // Added extra memory stats.
  157. //
  158. // Revision 1.3  1994/12/13  11:54:54  robertj
  159. // Added some memory usage statistics.
  160. //
  161. // Revision 1.2  1994/12/12  10:08:32  robertj
  162. // Renamed PWrapper to PSmartPointer..
  163. //
  164. // Revision 1.1  1994/10/30  12:02:15  robertj
  165. // Initial revision
  166. //
  167.  */
  169. #include <ptlib.h>
  170. #include <ctype.h>
  171. #ifdef _WIN32
  172. #include <strstrea.h>
  173. #include <ptlib/debstrm.h>
  174. #elif defined(__NUCLEUS_PLUS__)
  175. #include <ptlib/NucleusDebstrm.h>
  176. #else
  177. #include <strstream.h>
  178. #include <signal.h>
  179. #endif
  181. void PAssertFunc(const char * file, int line, PStandardAssertMessage msg)
  182. {
  183.   static const char * const textmsg[PMaxStandardAssertMessage] = {
  184.     NULL,
  185.     "Out of memory",
  186.     "Null pointer reference",
  187.     "Invalid cast to non-descendant class",
  188.     "Invalid array index",
  189.     "Invalid array element",
  190.     "Stack empty",
  191.     "Unimplemented function",
  192.     "Invalid parameter",
  193.     "Operating System error",
  194.     "File not open",
  195.     "Unsupported feature",
  196.     "Invalid or closed operating system window"
  197.   };
  199.   const char * theMsg;
  200.   char msgbuf[20];
  201.   if (msg < PMaxStandardAssertMessage)
  202.     theMsg = textmsg[msg];
  203.   else {
  204.     sprintf(msgbuf, "Error code: %i", msg);
  205.     theMsg = msgbuf;
  206.   }
  207.   PAssertFunc(file, line, theMsg);
  208. }
  212. #if PMEMORY_CHECK
  214. #undef malloc
  215. #undef realloc
  216. #undef free
  219. void * operator new(size_t nSize)
  220. {
  221.   return PMemoryHeap::Allocate(nSize, (const char *)NULL, 0, NULL);
  222. }
  225. void * operator new[](size_t nSize)
  226. {
  227.   return PMemoryHeap::Allocate(nSize, (const char *)NULL, 0, NULL);
  228. }
  231. void operator delete(void * ptr)
  232. {
  233.   PMemoryHeap::Deallocate(ptr, NULL);
  234. }
  237. void operator delete[](void * ptr)
  238. {
  239.   PMemoryHeap::Deallocate(ptr, NULL);
  240. }
  243. DWORD PMemoryHeap::allocationBreakpoint;
  244. char PMemoryHeap::Header::GuardBytes[NumGuardBytes];
  247. PMemoryHeap::Wrapper::Wrapper()
  248. {
  249.   // The following is done like this to get over brain dead compilers that cannot
  250.   // guarentee that a static global is contructed before it is used.
  251.   static PMemoryHeap real_instance;
  252.   instance = &real_instance;
  253.   if (instance->isDestroyed)
  254.     return;
  256. #if defined(_WIN32)
  257.   EnterCriticalSection(&instance->mutex);
  258. #elif defined(P_PTHREADS)
  259.   pthread_mutex_lock(&instance->mutex);
  260. #endif
  261. }
  264. PMemoryHeap::Wrapper::~Wrapper()
  265. {
  266.   if (instance->isDestroyed)
  267.     return;
  269. #if defined(_WIN32)
  270.   LeaveCriticalSection(&instance->mutex);
  271. #elif defined(P_PTHREADS)
  272.   pthread_mutex_unlock(&instance->mutex);
  273. #endif
  274. }
  277. PMemoryHeap::PMemoryHeap()
  278. {
  279.   isDestroyed = FALSE;
  281.   listHead = NULL;
  282.   listTail = NULL;
  284.   allocationRequest = 1;
  285.   firstRealObject = 0;
  286.   flags = 0;
  288.   allocFillChar = 'x5A';
  289.   freeFillChar = 'xA5';
  291.   currentMemoryUsage = 0;
  292.   peakMemoryUsage = 0;
  293.   currentObjects = 0;
  294.   peakObjects = 0;
  295.   totalObjects = 0;
  297.   for (PINDEX i = 0; i < Header::NumGuardBytes; i++)
  298.     Header::GuardBytes[i] = (i&1) == 0 ? 'x55' : 'xaa';
  300. #if defined(_WIN32)
  301.   InitializeCriticalSection(&mutex);
  302.   static PDebugStream debug;
  303.   leakDumpStream = &debug;
  304. #else
  305. #if defined(P_PTHREADS)
  306.   pthread_mutex_init(&mutex, NULL);
  307. #endif
  308.   leakDumpStream = &cerr;
  309. #endif
  310. }
  313. PMemoryHeap::~PMemoryHeap()
  314. {
  315.   isDestroyed = TRUE;
  317.   if (leakDumpStream != NULL) {
  318.     DumpStatistics(*leakDumpStream);
  319. #if !defined(_WIN32)
  320.     if (listTail != NULL && listTail->request >= firstRealObject) {
  321. #if defined(P_PTHREADS)
  322.       sigset_t blockedSignals;
  323.       sigemptyset(&blockedSignals);
  324.       sigaddset(&blockedSignals, SIGINT);
  325.       sigaddset(&blockedSignals, SIGQUIT);
  326.       sigaddset(&blockedSignals, SIGTERM);
  327.       pthread_sigmask(SIG_UNBLOCK, &blockedSignals, NULL);
  328. #endif
  329.       ::signal(SIGINT, SIG_DFL);
  330.       ::signal(SIGQUIT, SIG_DFL);
  331.       ::signal(SIGTERM, SIG_DFL);
  332.       *leakDumpStream << "nMemory leaks detected, press Enter to display . . ." << flush;
  333.       cin.get();
  334.     }
  335. #endif
  336.     DumpObjectsSince(firstRealObject, *leakDumpStream);
  337.   }
  339. #if defined(_WIN32)
  340.   DeleteCriticalSection(&mutex);
  341.   extern void PWaitOnExitConsoleWindow();
  342.   PWaitOnExitConsoleWindow();
  343. #elif defined(P_PTHREADS)
  344.   pthread_mutex_destroy(&mutex);
  345. #endif
  346. }
  349. void * PMemoryHeap::Allocate(size_t nSize, const char * file, int line, const char * className)
  350. {
  351.   Wrapper mem;
  352.   return mem->InternalAllocate(nSize, file, line, className);
  353. }
  356. void * PMemoryHeap::Allocate(size_t count, size_t size, const char * file, int line)
  357. {
  358.   Wrapper mem;
  360.   char oldFill = mem->allocFillChar;
  361.   mem->allocFillChar = '';
  363.   void * data = mem->InternalAllocate(count*size, file, line, NULL);
  365.   mem->allocFillChar = oldFill;
  367.   return data;
  368. }
  371. void * PMemoryHeap::InternalAllocate(size_t nSize, const char * file, int line, const char * className)
  372. {
  373.   if (isDestroyed)
  374.     return malloc(nSize);
  376.   Header * obj = (Header *)malloc(sizeof(Header) + nSize + sizeof(Header::GuardBytes));
  377.   if (obj == NULL) {
  378.     PAssertAlways(POutOfMemory);
  379.     return NULL;
  380.   }
  382.   if (firstRealObject == 0 && file != NULL && line > 0)
  383.     firstRealObject = allocationRequest;
  385.   PAssert(allocationRequest != allocationBreakpoint, "Break on memory allocation.");
  387.   currentMemoryUsage += nSize;
  388.   if (currentMemoryUsage > peakMemoryUsage)
  389.     peakMemoryUsage = currentMemoryUsage;
  391.   currentObjects++;
  392.   if (currentObjects > peakObjects)
  393.     peakObjects = currentObjects;
  394.   totalObjects++;
  396.   char * data = (char *)&obj[1];
  398.   obj->prev      = listTail;
  399.   obj->next      = NULL;
  400.   obj->size      = nSize;
  401.   obj->fileName  = file;
  402.   obj->line      = (WORD)line;
  403.   obj->className = className;
  404.   obj->request   = allocationRequest++;
  405.   obj->flags     = flags;
  406.   memcpy(obj->guard, obj->GuardBytes, sizeof(obj->guard));
  407.   memset(data, allocFillChar, nSize);
  408.   memcpy(&data[nSize], obj->GuardBytes, sizeof(obj->guard));
  410.   if (listTail != NULL)
  411.     listTail->next = obj;
  413.   listTail = obj;
  415.   if (listHead == NULL)
  416.     listHead = obj;
  418.   return data;
  419. }
  422. void * PMemoryHeap::Reallocate(void * ptr, size_t nSize, const char * file, int line)
  423. {
  424.   if (ptr == NULL)
  425.     return Allocate(nSize, file, line, NULL);
  427.   if (nSize == 0) {
  428.     Deallocate(ptr, NULL);
  429.     return NULL;
  430.   }
  432.   Wrapper mem;
  434.   if (mem->isDestroyed)
  435.     return realloc(ptr, nSize);
  437.   if (mem->InternalValidate(ptr, NULL, mem->leakDumpStream) != Ok)
  438.     return NULL;
  440.   Header * obj = (Header *)realloc(((Header *)ptr)-1, sizeof(Header) + nSize + sizeof(obj->guard));
  441.   if (obj == NULL) {
  442.     PAssertAlways(POutOfMemory);
  443.     return NULL;
  444.   }
  446.   PAssert(mem->allocationRequest != allocationBreakpoint, "Break on memory allocation.");
  448.   mem->currentMemoryUsage -= obj->size;
  449.   mem->currentMemoryUsage += nSize;
  450.   if (mem->currentMemoryUsage > mem->peakMemoryUsage)
  451.     mem->peakMemoryUsage = mem->currentMemoryUsage;
  453.   char * data = (char *)&obj[1];
  454.   memcpy(&data[nSize], obj->GuardBytes, sizeof(obj->guard));
  456.   obj->size      = nSize;
  457.   obj->fileName  = file;
  458.   obj->line      = (WORD)line;
  459.   obj->request   = mem->allocationRequest++;
  460.   if (obj->prev != NULL)
  461.     obj->prev->next = obj;
  462.   else
  463.     mem->listHead = obj;
  464.   if (obj->next != NULL)
  465.     obj->next->prev = obj;
  466.   else
  467.     mem->listTail = obj;
  469.   return data;
  470. }
  473. void PMemoryHeap::Deallocate(void * ptr, const char * className)
  474. {
  475.   if (ptr == NULL)
  476.     return;
  478.   Wrapper mem;
  480.   if (mem->isDestroyed) {
  481.     free(ptr);
  482.     return;
  483.   }
  485.   if (mem->InternalValidate(ptr, className, mem->leakDumpStream) != Ok) {
  486.     free(ptr);
  487.     return;
  488.   }
  490.   Header * obj = ((Header *)ptr)-1;
  491.   if (obj->prev != NULL)
  492.     obj->prev->next = obj->next;
  493.   else
  494.     mem->listHead = obj->next;
  495.   if (obj->next != NULL)
  496.     obj->next->prev = obj->prev;
  497.   else
  498.     mem->listTail = obj->prev;
  500.   mem->currentMemoryUsage -= obj->size;
  501.   mem->currentObjects--;
  503.   memset(ptr, mem->freeFillChar, obj->size);  // Make use of freed data noticable
  504.   free(obj);
  505. }
  508. PMemoryHeap::Validation PMemoryHeap::Validate(void * ptr,
  509.                                               const char * className,
  510.                                               ostream * error)
  511. {
  512.   Wrapper mem;
  513.   return mem->InternalValidate(ptr, className, error);
  514. }
  517. PMemoryHeap::Validation PMemoryHeap::InternalValidate(void * ptr,
  518.                                                       const char * className,
  519.                                                       ostream * error)
  520. {
  521.   if (isDestroyed)
  522.     return Bad;
  524.   if (ptr == NULL)
  525.     return Trashed;
  527.   Header * obj = ((Header *)ptr)-1;
  529.   if (memcmp(obj->guard, obj->GuardBytes, sizeof(obj->guard)) != 0) {
  530.     if (error != NULL)
  531.       *error << "Underrun at " << ptr << '[' << obj->size << "] #" << obj->request << endl;
  532.     return Bad;
  533.   }
  534.   
  535.   if (memcmp((char *)ptr+obj->size, obj->GuardBytes, sizeof(obj->guard)) != 0) {
  536.     if (error != NULL)
  537.       *error << "Overrun at " << ptr << '[' << obj->size << "] #" << obj->request << endl;
  538.     return Bad;
  539.   }
  540.   
  541.   if (obj->className != NULL && strcmp(obj->className, className) != 0) {
  542.     if (error != NULL)
  543.       *error << "PObject " << ptr << '[' << obj->size << "] #" << obj->request
  544.              << " allocated as "" << obj->className
  545.              << "" and should be "" << className << ""." << endl;
  546.     return Bad;
  547.   }
  549.   Header * forward = obj;
  550.   Header * backward = obj;
  551.   while (forward->next != NULL && backward->prev != NULL) {
  552.     forward = forward->next;
  553.     backward = backward->prev;
  554.   }
  556.   if (forward != listTail && backward != listHead) {
  557.     if (error != NULL)
  558.       *error << "Block " << ptr << '[' << obj->size << "] #" << obj->request
  559.              << " not in heap!" << endl;
  560.     return Trashed;
  561.   }
  563.   return Ok;
  564. }
  567. void PMemoryHeap::SetIgnoreAllocations(BOOL ignore)
  568. {
  569.   Wrapper mem;
  571.   if (ignore)
  572.     mem->flags |= NoLeakPrint;
  573.   else
  574.     mem->flags &= ~NoLeakPrint;
  575. }
  578. void PMemoryHeap::DumpStatistics()
  579. {
  580.   Wrapper mem;
  581.   if (mem->leakDumpStream != NULL)
  582.     mem->InternalDumpStatistics(*mem->leakDumpStream);
  583. }
  586. void PMemoryHeap::DumpStatistics(ostream & strm)
  587. {
  588.   Wrapper mem;
  589.   mem->InternalDumpStatistics(strm);
  590. }
  593. void PMemoryHeap::InternalDumpStatistics(ostream & strm)
  594. {
  595.   strm << "nCurrent memory usage: " << currentMemoryUsage << " bytes";
  596.   if (currentMemoryUsage > 2048)
  597.     strm << ", " << (currentMemoryUsage+1023)/1024 << "kb";
  598.   if (currentMemoryUsage > 2097152)
  599.     strm << ", " << (currentMemoryUsage+1048575)/1048576 << "Mb";
  601.   strm << ".nCurrent objects count: " << currentObjects
  602.        << "nPeak memory usage: " << peakMemoryUsage << " bytes";
  603.   if (peakMemoryUsage > 2048)
  604.     strm << ", " << (peakMemoryUsage+1023)/1024 << "kb";
  605.   if (peakMemoryUsage > 2097152)
  606.     strm << ", " << (peakMemoryUsage+1048575)/1048576 << "Mb";
  608.   strm << ".nPeak objects created: " << peakObjects
  609.        << "nTotal objects created: " << totalObjects
  610.        << 'n' << endl;
  611. }
  614. DWORD PMemoryHeap::GetAllocationRequest()
  615. {
  616.   Wrapper mem;
  617.   return mem->allocationRequest;
  618. }
  621. void PMemoryHeap::SetAllocationBreakpoint(DWORD point)
  622. {
  623.   allocationBreakpoint = point;
  624. }
  627. void PMemoryHeap::DumpObjectsSince(DWORD objectNumber)
  628. {
  629.   Wrapper mem;
  630.   if (mem->leakDumpStream != NULL)
  631.     mem->InternalDumpObjectsSince(objectNumber, *mem->leakDumpStream);
  632. }
  635. void PMemoryHeap::DumpObjectsSince(DWORD objectNumber, ostream & strm)
  636. {
  637.   Wrapper mem;
  638.   mem->InternalDumpObjectsSince(objectNumber, strm);
  639. }
  642. void PMemoryHeap::InternalDumpObjectsSince(DWORD objectNumber, ostream & strm)
  643. {
  644.   for (Header * obj = listHead; obj != NULL; obj = obj->next) {
  645.     if (obj->request < objectNumber || (obj->flags&NoLeakPrint) != 0)
  646.       continue;
  648.     BYTE * data = (BYTE *)&obj[1];
  650.     if (obj->fileName != NULL)
  651.       strm << obj->fileName << '(' << obj->line << ") : ";
  653.     strm << '#' << obj->request << ' ' << (void *)data << " [" << obj->size << "] ";
  655.     if (obj->className != NULL)
  656.       strm << '"' << obj->className << "" ";
  658.     strm << 'n' << hex << setfill('0') << PBYTEArray(data, PMIN(16, obj->size), FALSE)
  659.                  << dec << setfill(' ') << endl;
  660.   }
  661. }
  664. #endif
  667. const char * PObject::GetClass(unsigned) const
  668. {
  669.   return Class();
  670. }
  673. BOOL PObject::IsClass(const char * clsName) const
  674. {
  675.   return strcmp(clsName, Class()) == 0;
  676. }
  679. BOOL PObject::IsDescendant(const char * clsName) const
  680. {
  681.   return strcmp(clsName, Class()) == 0;
  682. }
  685. PObject::Comparison PObject::CompareObjectMemoryDirect(const PObject&obj) const
  686. {
  687.   int retval = memcmp(this, &obj, sizeof(PObject));
  688.   if (retval < 0)
  689.     return LessThan;
  690.   if (retval > 0)
  691.     return GreaterThan;
  692.   return EqualTo;
  693. }
  696. PObject * PObject::Clone() const
  697. {
  698.   PAssertAlways(PUnimplementedFunction);
  699.   return NULL;
  700. }
  703. PObject::Comparison PObject::Compare(const PObject & obj) const
  704. {
  705.   return (Comparison)CompareObjectMemoryDirect(obj);
  706. }
  709. void PObject::PrintOn(ostream & strm) const
  710. {
  711.   strm << GetClass();
  712. }
  715. void PObject::ReadFrom(istream &)
  716. {
  717. }
  720. PINDEX PObject::PreSerialise(PSerialiser &)
  721. {
  722.   return 0;
  723. }
  726. void PObject::Serialise(PSerialiser &)
  727. {
  728. }
  731. void PObject::UnSerialise(PUnSerialiser &)
  732. {
  733. }
  736. PINDEX PObject::HashFunction() const
  737. {
  738.   return 0;
  739. }
  742. ///////////////////////////////////////////////////////////////////////////////
  743. // Serialisation support
  745. PSerialRegistration * PSerialRegistration::creatorHashTable[
  746.                                            PSerialRegistration::HashTableSize];
  748. PINDEX PSerialRegistration::HashFunction(const char * className)
  749. {
  750.   PINDEX hash = (BYTE)className[0];
  751.   if (className[0] != '') {
  752.     hash += (BYTE)className[1];
  753.     if (className[1] != '')
  754.       hash += (BYTE)className[2];
  755.   }
  756.   return hash%HashTableSize;
  757. }
  760. PSerialRegistration::PSerialRegistration(const char * clsNam,
  761.                                                           CreatorFunction func)
  762.   : className(clsNam), creator(func)
  763. {
  764.   clash = NULL;
  766.   PINDEX hash = HashFunction(className);
  767.   if (creatorHashTable[hash] != NULL)
  768.     creatorHashTable[hash]->clash = this;
  769.   creatorHashTable[hash] = this;
  770. }
  773. PSerialRegistration::CreatorFunction
  774.                            PSerialRegistration::GetCreator(const char * clsNam)
  775. {
  776.   PINDEX hash = HashFunction(clsNam);
  777.   PSerialRegistration * reg = creatorHashTable[hash];
  778.   while (reg != NULL) {
  779.     if (strcmp(reg->className, clsNam) == 0)
  780.       return reg->creator;
  781.   }
  782.   return NULL;
  783. }
  786. PSerialiser::PSerialiser(ostream & strm)
  787.   : stream(strm)
  788. {
  789. }
  792. PSerialiser & PSerialiser::operator<<(PObject & obj)
  793. {
  794.   obj.Serialise(*this);
  795.   return *this;
  796. }
  799. PTextSerialiser::PTextSerialiser(ostream & strm, PObject & data)
  800.   : PSerialiser(strm)
  801. {
  802.   data.Serialise(*this);
  803. }
  806. PSerialiser & PTextSerialiser::operator<<(char)
  807.   { return *this; }
  809. PSerialiser & PTextSerialiser::operator<<(unsigned char)
  810.   { return *this; }
  812. PSerialiser & PTextSerialiser::operator<<(signed char)
  813.   { return *this; }
  815. PSerialiser & PTextSerialiser::operator<<(short)
  816.   { return *this; }
  818. PSerialiser & PTextSerialiser::operator<<(unsigned short)
  819.   { return *this; }
  821. PSerialiser & PTextSerialiser::operator<<(int)
  822.   { return *this; }
  824. PSerialiser & PTextSerialiser::operator<<(unsigned int)
  825.   { return *this; }
  827. PSerialiser & PTextSerialiser::operator<<(long)
  828.   { return *this; }
  830. PSerialiser & PTextSerialiser::operator<<(unsigned long)
  831.   { return *this; }
  833. PSerialiser & PTextSerialiser::operator<<(float)
  834.   { return *this; }
  836. PSerialiser & PTextSerialiser::operator<<(double)
  837.   { return *this; }
  839. PSerialiser & PTextSerialiser::operator<<(long double)
  840.   { return *this; }
  842. PSerialiser & PTextSerialiser::operator<<(const char *)
  843.   { return *this; }
  845. PSerialiser & PTextSerialiser::operator<<(const unsigned char *)
  846.   { return *this; }
  848. PSerialiser & PTextSerialiser::operator<<(const signed char *)
  849.   { return *this; }
  851. PSerialiser & PTextSerialiser::operator<<(PObject & obj)
  852.   { return PSerialiser::operator<<(obj); }
  855. PBinarySerialiser::PBinarySerialiser(ostream & strm, PObject & data)
  856.   : PSerialiser(strm)
  857. {
  858.   classesUsed = new PSortedStringList;
  859.   data.PreSerialise(*this);
  860.   stream << *classesUsed;
  861.   data.Serialise(*this);
  862. }
  865. PBinarySerialiser::~PBinarySerialiser()
  866. {
  867.   delete classesUsed;
  868. }
  871. PSerialiser & PBinarySerialiser::operator<<(char)
  872.   { return *this; }
  874. PSerialiser & PBinarySerialiser::operator<<(unsigned char)
  875.   { return *this; }
  877. PSerialiser & PBinarySerialiser::operator<<(signed char)
  878.   { return *this; }
  880. PSerialiser & PBinarySerialiser::operator<<(short)
  881.   { return *this; }
  883. PSerialiser & PBinarySerialiser::operator<<(unsigned short)
  884.   { return *this; }
  886. PSerialiser & PBinarySerialiser::operator<<(int)
  887.   { return *this; }
  889. PSerialiser & PBinarySerialiser::operator<<(unsigned int)
  890.   { return *this; }
  892. PSerialiser & PBinarySerialiser::operator<<(long)
  893.   { return *this; }
  895. PSerialiser & PBinarySerialiser::operator<<(unsigned long)
  896.   { return *this; }
  898. PSerialiser & PBinarySerialiser::operator<<(float)
  899.   { return *this; }
  901. PSerialiser & PBinarySerialiser::operator<<(double)
  902.   { return *this; }
  904. PSerialiser & PBinarySerialiser::operator<<(long double)
  905.   { return *this; }
  907. PSerialiser & PBinarySerialiser::operator<<(const char *)
  908.   { return *this; }
  910. PSerialiser & PBinarySerialiser::operator<<(const unsigned char *)
  911.   { return *this; }
  913. PSerialiser & PBinarySerialiser::operator<<(const signed char *)
  914.   { return *this; }
  916. PSerialiser & PBinarySerialiser::operator<<(PObject & obj)
  917.   { return PSerialiser::operator<<(obj); }
  920. PUnSerialiser::PUnSerialiser(istream & strm)
  921.   : stream(strm)
  922. {
  923. }
  926. PTextUnSerialiser::PTextUnSerialiser(istream & strm)
  927.   : PUnSerialiser(strm)
  928. {
  929. }
  932. PUnSerialiser & PTextUnSerialiser::operator>>(char &)
  933.   { return *this; }
  935. PUnSerialiser & PTextUnSerialiser::operator>>(unsigned char &)
  936.   { return *this; }
  938. PUnSerialiser & PTextUnSerialiser::operator>>(signed char &)
  939.   { return *this; }
  941. PUnSerialiser & PTextUnSerialiser::operator>>(short &)
  942.   { return *this; }
  944. PUnSerialiser & PTextUnSerialiser::operator>>(unsigned short &)
  945.   { return *this; }
  947. PUnSerialiser & PTextUnSerialiser::operator>>(int &)
  948.   { return *this; }
  950. PUnSerialiser & PTextUnSerialiser::operator>>(unsigned int &)
  951.   { return *this; }
  953. PUnSerialiser & PTextUnSerialiser::operator>>(long &)
  954.   { return *this; }
  956. PUnSerialiser & PTextUnSerialiser::operator>>(unsigned long &)
  957.   { return *this; }
  959. PUnSerialiser & PTextUnSerialiser::operator>>(float &)
  960.   { return *this; }
  962. PUnSerialiser & PTextUnSerialiser::operator>>(double &)
  963.   { return *this; }
  965. PUnSerialiser & PTextUnSerialiser::operator>>(long double &)
  966.   { return *this; }
  968. PUnSerialiser & PTextUnSerialiser::operator>>(char *)
  969.   { return *this; }
  971. PUnSerialiser & PTextUnSerialiser::operator>>(unsigned char *)
  972.   { return *this; }
  974. PUnSerialiser & PTextUnSerialiser::operator>>(signed char *)
  975.   { return *this; }
  977. PUnSerialiser & PTextUnSerialiser::operator>>(PObject &)
  978.   { return *this; }
  981. PBinaryUnSerialiser::PBinaryUnSerialiser(istream & strm)
  982.   : PUnSerialiser(strm)
  983. {
  984.   classesUsed = new PStringArray;
  985. }
  988. PBinaryUnSerialiser::~PBinaryUnSerialiser()
  989. {
  990.   delete classesUsed;
  991. }
  994. PUnSerialiser & PBinaryUnSerialiser::operator>>(char &)
  995.   { return *this; }
  997. PUnSerialiser & PBinaryUnSerialiser::operator>>(unsigned char &)
  998.   { return *this; }
  1000. PUnSerialiser & PBinaryUnSerialiser::operator>>(signed char &)
  1001.   { return *this; }
  1003. PUnSerialiser & PBinaryUnSerialiser::operator>>(short &)
  1004.   { return *this; }
  1006. PUnSerialiser & PBinaryUnSerialiser::operator>>(unsigned short &)
  1007.   { return *this; }
  1009. PUnSerialiser & PBinaryUnSerialiser::operator>>(int &)
  1010.   { return *this; }
  1012. PUnSerialiser & PBinaryUnSerialiser::operator>>(unsigned int &)
  1013.   { return *this; }
  1015. PUnSerialiser & PBinaryUnSerialiser::operator>>(long &)
  1016.   { return *this; }
  1018. PUnSerialiser & PBinaryUnSerialiser::operator>>(unsigned long &)
  1019.   { return *this; }
  1021. PUnSerialiser & PBinaryUnSerialiser::operator>>(float &)
  1022.   { return *this; }
  1024. PUnSerialiser & PBinaryUnSerialiser::operator>>(double &)
  1025.   { return *this; }
  1027. PUnSerialiser & PBinaryUnSerialiser::operator>>(long double &)
  1028.   { return *this; }
  1030. PUnSerialiser & PBinaryUnSerialiser::operator>>(char *)
  1031.   { return *this; }
  1033. PUnSerialiser & PBinaryUnSerialiser::operator>>(unsigned char *)
  1034.   { return *this; }
  1036. PUnSerialiser & PBinaryUnSerialiser::operator>>(signed char *)
  1037.   { return *this; }
  1039. PUnSerialiser & PBinaryUnSerialiser::operator>>(PObject &)
  1040.   { return *this; }
  1043. ///////////////////////////////////////////////////////////////////////////////
  1044. // General reference counting support
  1046. PSmartPointer::PSmartPointer(const PSmartPointer & ptr)
  1047. {
  1048.   object = ptr.object;
  1049.   if (object != NULL)
  1050.     ++object->referenceCount;
  1051. }
  1054. PSmartPointer & PSmartPointer::operator=(const PSmartPointer & ptr)
  1055. {
  1056.   if (object == ptr.object)
  1057.     return *this;
  1059.   if (object != NULL && --object->referenceCount == 0)
  1060.     delete object;
  1062.   object = ptr.object;
  1063.   if (object != NULL)
  1064.     ++object->referenceCount;
  1066.   return *this;
  1067. }
  1070. PSmartPointer::~PSmartPointer()
  1071. {
  1072.   if (object != NULL && --object->referenceCount == 0)
  1073.     delete object;
  1074. }
  1077. PObject::Comparison PSmartPointer::Compare(const PObject & obj) const
  1078. {
  1079.   PAssert(obj.IsDescendant(PSmartPointer::Class()), PInvalidCast);
  1080.   PSmartObject * other = ((const PSmartPointer &)obj).object;
  1081.   if (object == other)
  1082.     return EqualTo;
  1083.   return object < other ? LessThan : GreaterThan;
  1084. }
  1087. ///////////////////////////////////////////////////////////////////////////////
  1088. // Large integer support
  1090. #ifdef P_NEEDS_INT64
  1092. void PInt64__::Add(const PInt64__ & v)
  1093. {
  1094.   unsigned long old = low;
  1095.   high += v.high;
  1096.   low += v.low;
  1097.   if (low < old)
  1098.     high++;
  1099. }
  1102. void PInt64__::Sub(const PInt64__ & v)
  1103. {
  1104.   unsigned long old = low;
  1105.   high -= v.high;
  1106.   low -= v.low;
  1107.   if (low > old)
  1108.     high--;
  1109. }
  1112. void PInt64__::Mul(const PInt64__ & v)
  1113. {
  1114.   DWORD p1 = (low&0xffff)*(v.low&0xffff);
  1115.   DWORD p2 = (low >> 16)*(v.low >> 16);
  1116.   DWORD p3 = (high&0xffff)*(v.high&0xffff);
  1117.   DWORD p4 = (high >> 16)*(v.high >> 16);
  1118.   low = p1 + (p2 << 16);
  1119.   high = (p2 >> 16) + p3 + (p4 << 16);
  1120. }
  1123. void PInt64__::Div(const PInt64__ & v)
  1124. {
  1125.   long double dividend = high;
  1126.   dividend *=  4294967296.0;
  1127.   dividend += low;
  1128.   long double divisor = high;
  1129.   divisor *=  4294967296.0;
  1130.   divisor += low;
  1131.   long double quotient = dividend/divisor;
  1132.   low = quotient;
  1133.   high = quotient/4294967296.0;
  1134. }
  1137. void PInt64__::Mod(const PInt64__ & v)
  1138. {
  1139.   PInt64__ t = *this;
  1140.   t.Div(v);
  1141.   t.Mul(t);
  1142.   Sub(t);
  1143. }
  1146. void PInt64__::ShiftLeft(int bits)
  1147. {
  1148.   if (bits >= 32) {
  1149.     high = low << (bits - 32);
  1150.     low = 0;
  1151.   }
  1152.   else {
  1153.     high <<= bits;
  1154.     high |= low >> (32 - bits);
  1155.     low <<= bits;
  1156.   }
  1157. }
  1160. void PInt64__::ShiftRight(int bits)
  1161. {
  1162.   if (bits >= 32) {
  1163.     low = high >> (bits - 32);
  1164.     high = 0;
  1165.   }
  1166.   else {
  1167.     low >>= bits;
  1168.     low |= high << (32 - bits);
  1169.     high >>= bits;
  1170.   }
  1171. }
  1174. BOOL PInt64::Lt(const PInt64 & v) const
  1175. {
  1176.   if ((long)high < (long)v.high)
  1177.     return TRUE;
  1178.   if ((long)high > (long)v.high)
  1179.     return FALSE;
  1180.   if ((long)high < 0)
  1181.     return (long)low > (long)v.low;
  1182.   return (long)low < (long)v.low;
  1183. }
  1186. BOOL PInt64::Gt(const PInt64 & v) const
  1187. {
  1188.   if ((long)high > (long)v.high)
  1189.     return TRUE;
  1190.   if ((long)high < (long)v.high)
  1191.     return FALSE;
  1192.   if ((long)high < 0)
  1193.     return (long)low < (long)v.low;
  1194.   return (long)low > (long)v.low;
  1195. }
  1198. BOOL PUInt64::Lt(const PUInt64 & v) const
  1199. {
  1200.   if (high < v.high)
  1201.     return TRUE;
  1202.   if (high > v.high)
  1203.     return FALSE;
  1204.   return low < high;
  1205. }
  1208. BOOL PUInt64::Gt(const PUInt64 & v) const
  1209. {
  1210.   if (high > v.high)
  1211.     return TRUE;
  1212.   if (high < v.high)
  1213.     return FALSE;
  1214.   return low > high;
  1215. }
  1218. static void Out64(ostream & stream, PUInt64 num)
  1219. {
  1220.   char buf[25];
  1221.   char * p = &buf[sizeof(buf)];
  1222.   *--p = '';
  1224.   switch (stream.flags()&ios::basefield) {
  1225.     case ios::oct :
  1226.       while (num != 0) {
  1227.         *--p = (num&7) + '0';
  1228.         num >>= 3;
  1229.       }
  1230.       break;
  1232.     case ios::hex :
  1233.       while (num != 0) {
  1234.         *--p = (num&15) + '0';
  1235.         if (*p > '9')
  1236.           *p += 7;
  1237.         num >>= 4;
  1238.       }
  1239.       break;
  1241.     default :
  1242.       while (num != 0) {
  1243.         *--p = num%10 + '0';
  1244.         num /= 10;
  1245.       }
  1246.   }
  1248.   if (*p == '')
  1249.     *--p = '0';
  1251.   stream << p;
  1252. }
  1255. ostream & operator<<(ostream & stream, const PInt64 & v)
  1256. {
  1257.   if (v >= 0)
  1258.     Out64(stream, v);
  1259.   else {
  1260.     int w = stream.width();
  1261.     stream.put('-');
  1262.     if (w > 0)
  1263.       stream.width(w-1);
  1264.     Out64(stream, -v);
  1265.   }
  1267.   return stream;
  1268. }
  1271. ostream & operator<<(ostream & stream, const PUInt64 & v)
  1272. {
  1273.   Out64(stream, v);
  1274.   return stream;
  1275. }
  1278. static PUInt64 Inp64(istream & stream)
  1279. {
  1280.   int base;
  1281.   switch (stream.flags()&ios::basefield) {
  1282.     case ios::oct :
  1283.       base = 8;
  1284.       break;
  1285.     case ios::hex :
  1286.       base = 16;
  1287.       break;
  1288.     default :
  1289.       base = 10;
  1290.   }
  1292.   if (isspace(stream.peek()))
  1293.     stream.get();
  1295.   PInt64 num = 0;
  1296.   while (isxdigit(stream.peek())) {
  1297.     int c = stream.get() - '0';
  1298.     if (c > 9)
  1299.       c -= 7;
  1300.     if (c > 9)
  1301.       c -= 32;
  1302.     num = num*base + c;
  1303.   }
  1305.   return num;
  1306. }
  1309. istream & operator>>(istream & stream, PInt64 & v)
  1310. {
  1311.   if (isspace(stream.peek()))
  1312.     stream.get();
  1314.   switch (stream.peek()) {
  1315.     case '-' :
  1316.       stream.ignore();
  1317.       v = -(PInt64)Inp64(stream);
  1318.       break;
  1319.     case '+' :
  1320.       stream.ignore();
  1321.     default :
  1322.       v = (PInt64)Inp64(stream);
  1323.   }
  1325.   return stream;
  1326. }
  1329. istream & operator>>(istream & stream, PUInt64 & v)
  1330. {
  1331.   v = Inp64(stream);
  1332.   return stream;
  1333. }
  1336. #endif
  1339. // End Of File ///////////////////////////////////////////////////////////////