#include "unix/ptlib/contain.h"
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
#include <strstrea.h>
#include <iomanip.h>
#include <typeinfo>
Go to the source code of this file.
Classes | |
class | PTrace |
class | PTrace::Block |
class | PObject |
Defines | |
#define | _BADOFF -1 |
#define | P_USE_INLINES 0 |
#define | PINLINE |
#define | P_USE_ASSERTS 1 |
#define | __CLASS__ NULL |
#define | PAssert(b, m) PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,(m)) |
#define | PAssert2(b, c, m) PAssertFuncInline((b), __FILE__,__LINE__,(c),(m)) |
#define | PAssertOS(b) PAssertFuncInline((b), __FILE__,__LINE__,__CLASS__,POperatingSystemError) |
#define | PAssertNULL(p) |
#define | PAssertAlways(m) PAssertFunc(__FILE__,__LINE__,__CLASS__,(m)) |
#define | PAssertAlways2(c, m) PAssertFunc(__FILE__,__LINE__,(c),(m)) |
#define | PError (PGetErrorStream()) |
#define | PTRACING 0 |
#define | PTRACE_PARAM(param) |
#define | PTRACE_BLOCK(n) |
#define | PTRACE_LINE() |
#define | PTRACE(level, arg) |
#define | PTRACE_IF(level, cond, args) |
#define | PNEW new |
#define | PNEW_AND_DELETE_FUNCTIONS |
#define | runtime_malloc(s) malloc(s) |
#define | runtime_free(p) free(p) |
#define | PIsDescendant(ptr, cls) (dynamic_cast<const cls *>(ptr) != NULL) |
#define | PIsDescendantStr(ptr, str) ((ptr)->InternalIsDescendant(str)) |
#define | PRemoveConst(cls, ptr) (const_cast<cls*>(ptr)) |
#define | PDownCast(cls, ptr) PAssertCast<cls>(dynamic_cast<cls*>(ptr),__FILE__,__LINE__) |
#define | PBASECLASSINFO(cls, par) |
#define | PCLASSINFO(cls, par) |
#define | PDECLARE_CLASS(cls, par) class cls : public par { PCLASSINFO(cls, par) |
#define | PANSI_CHAR 1 |
#define | PLITTLE_ENDIAN 2 |
#define | PBIG_ENDIAN 3 |
#define | PI_SAME(name, type) |
#define | PI_LOOP(src, dst) |
#define | PI_DIFF(name, type) |
#define | PCHAR8 PANSI_CHAR |
#define | PARRAYSIZE(array) ((PINDEX)(sizeof(array)/sizeof(array[0]))) |
#define | PMIN(v1, v2) ((v1) < (v2) ? (v1) : (v2)) |
#define | PMAX(v1, v2) ((v1) > (v2) ? (v1) : (v2)) |
#define | PABS(v) ((v) < 0 ? -(v) : (v)) |
Typedefs | |
typedef long | _Ios_Fmtflags |
Enumerations | |
enum | PStandardAssertMessage { PLogicError, POutOfMemory, PNullPointerReference, PInvalidCast, PInvalidArrayIndex, PInvalidArrayElement, PStackEmpty, PUnimplementedFunction, PInvalidParameter, POperatingSystemError, PChannelNotOpen, PUnsupportedFeature, PInvalidWindow, PMaxStandardAssertMessage } |
Standard assert messages for the PAssert macro. More... | |
Functions | |
void | PAssertFunc (const char *file, int line, const char *className, PStandardAssertMessage msg) |
void | PAssertFunc (const char *file, int line, const char *className, const char *msg) |
void | PAssertFunc (const char *full_msg) |
bool | PAssertFuncInline (bool b, const char *file, int line, const char *className, PStandardAssertMessage msg) |
bool | PAssertFuncInline (bool b, const char *file, int line, const char *className, const char *msg) |
ostream & | PGetErrorStream () |
void | PSetErrorStream (ostream *strm) |
void * | operator new (size_t nSize) |
void * | operator new[] (size_t nSize) |
void | operator delete (void *ptr) |
void | operator delete[] (void *ptr) |
template<class BaseClass> | |
BaseClass * | PAssertCast (BaseClass *obj, const char *file, int line) |
PI_SAME (PChar8, char) | |
PI_SAME (PInt8, signed char) | |
PI_SAME (PUInt8, unsigned char) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
This macro is used to assert that a condition must be TRUE. If the condition is FALSE then an assert function is called with the source file and line number the macro was instantiated on, plus the message described by the msg# parameter. This parameter may be either a standard value from the PStandardAssertMessage# enum or a literal string. |
|
This macro is used to assert that a condition must be TRUE. If the condition is FALSE then an assert function is called with the source file and line number the macro was instantiated on, plus the message described by the msg# parameter. This parameter may be either a standard value from the PStandardAssertMessage# enum or a literal string. The c# parameter specifies the class name that the error occurred in |
|
This macro is used to assert immediately. The assert function is called with the source file and line number the macro was instantiated on, plus the message described by the msg# parameter. This parameter may be either a standard value from the PStandardAssertMessage# enum or a literal string. |
|
This macro is used to assert immediately. The assert function is called with the source file and line number the macro was instantiated on, plus the message described by the msg# parameter. This parameter may be either a standard value from the PStandardAssertMessage# enum or a literal string. |
|
Value: ((&(p)&&(p)!=NULL)?(p): \ (PAssertFunc(__FILE__,__LINE__, __CLASS__, PNullPointerReference),(p))) Note that this evaluates the expression defined by ptr# twice. To prevent incorrect behaviour with this, the macro will assume that the ptr# parameter is an L-Value. |
|
This macro is used to assert that an operating system call succeeds. If the condition is FALSE then an assert function is called with the source file and line number the macro was instantiated on, plus the message described by the POperatingSystemError# value in the PStandardAssertMessage# enum. |
|
Value: public: \ static inline const char * Class() \ { return PCLASSNAME(cls); } \ virtual BOOL InternalIsDescendant(const char * clsName) const \ { return strcmp(clsName, PCLASSNAME(cls)) == 0 || par::InternalIsDescendant(clsName); } \ |
|
|
|
|
|
Value: PBASECLASSINFO(cls, par) \ virtual const char * GetClass(unsigned ancestor = 0) const \ { return ancestor > 0 ? par::GetClass(ancestor-1) : cls::Class(); } \ virtual Comparison CompareObjectMemoryDirect(const PObject & obj) const \ { return (Comparison)memcmp(this, &obj, sizeof(cls)); } \ |
|
Declare a class with PWLib class information. This macro is used to declare a new class with a single public ancestor. It starts the class declaration and then uses the PCLASSINFO# macro to get all the run-time type functions. The use of this macro is no longer recommended for reasons of compatibility with documentation systems. |
|
|
|
This macro is used to access the platform specific error output stream. This is to be used in preference to assuming cerr# is always available. On Unix platforms this {} cerr# but for MS-Windows this is another stream that uses the OutputDebugString() Windows API function. Note that a MS-DOS or Windows NT console application would still use cerr#. The PError# stream would normally only be used for debugging information as a suitable display is not always available in windowed environments. The macro is a wrapper for a global variable PErrorStream# which is a pointer to an ostream#. The variable is initialised to cerr# for all but MS-Windows and NT GUI applications. An application could change this pointer to a ofstream# variable of PError# output is wished to be redirected to a file. |
|
Value: struct name { \ name() { } \ name(type value) { operator=(value); } \ name(const name & value) { data = value.data; } \ name & operator =(type value) { PI_LOOP(value, data); return *this; } \ name & operator =(const name & value) { data = value.data; return *this; } \ operator type() const { type value; PI_LOOP(data, value); return value; } \ friend ostream & operator<<(ostream & s, const name & value) { return s << (type)value; } \ friend istream & operator>>(istream & s, name & v) { type val; s >> val; v = val; return s; } \ private: type data; \ } |
|
Value: BYTE *s = ((BYTE *)&src)+sizeof(src); BYTE *d = (BYTE *)&dst; \ while (s != (BYTE *)&src) *d++ = *--s; |
|
Value: struct name { \ name() { } \ name(type value) { data = value; } \ name(const name & value) { data = value.data; } \ name & operator =(type value) { data = value; return *this; } \ name & operator =(const name & value) { data = value.data; return *this; } \ operator type() const { return data; } \ friend ostream & operator<<(ostream & s, const name & v) { return s << v.data; } \ friend istream & operator>>(istream & s, name & v) { return s >> v.data; } \ private: type data; \ } |
|
|
|
Declare all the standard PWlib class information. This macro is used to provide the basic run-time typing capability needed by the library. All descendent classes from the PObject# class require these functions for correct operation. Either use this macro or the PDECLARE_CLASS# macro. The use of the PDECLARE_CLASS# macro is no longer recommended for reasons of compatibility with documentation systems. |
|
|
|
|
|
|
|
|
|
|
|
Value: void * operator new(size_t nSize) \ { return malloc(nSize); } \ void operator delete(void * ptr) \ { free(ptr); } \ void * operator new[](size_t nSize) \ { return malloc(nSize); } \ void operator delete[](void * ptr) \ { free(ptr); } |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Standard assert messages for the PAssert macro.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Get the stream being used for error output. This stream is used for all trace output using the various trace functions and macros. |
|
|
|
|
|
|
|
Set the stream to be used for error output. This stream is used for all error output using the PError# macro.
|