Developer's Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
p6types.h
Go to the documentation of this file.
1 
10 #ifndef P6TYPES_H__
11 #define P6TYPES_H__ 1
12 
13 #ifndef P6_UEFI
14 #include <stdint.h>
15 #include <stddef.h>
16 #include <wchar.h> // wchar_t
17 #endif
18 
19 //#include "p6platform.h"
20 
21 #ifdef __cplusplus
22 
23 #ifndef P6_UEFI
24 #include <cstddef> // for std::ptrdiff_t
25 #include <new> // std::nothrow
26 #endif
27 
28 #define P6COMPILE_TIME_ASSERT(name,x) typedef int P6_CTA_ ## name__[(x) ? 1:-1];
29 
30 namespace P6R {
31 extern "C" {
32 #endif
33 
38 #if 0
39 typedef unsigned char P6UINT8;
40 typedef char P6INT8;
41 typedef P6UINT8 P6BYTE;
42 #if P6SIZEOF_SHORT == 2
43 typedef unsigned short int P6UINT16;
44 typedef short int P6INT16;
45 #else
46 #error Unable to find an appropriate type for P6UINT16 and P6INT16
47 #endif
48 #if P6SIZEOF_INT == 4
49 typedef unsigned int P6UINT32;
50 typedef int P6INT32;
51 #elif P6SIZEOF_LONG == 4
52 typedef unsigned long P6UINT32;
53 typedef long P6INT32;
54 #else
55 #error Unable to find an appropriate type for P6UINT32 and P6INT32
56 #endif
57 #if P6SIZEOF_LONGLONG == 8
58 typedef P6ULONGLONG P6UINT64;
59 typedef P6LONGLONG P6INT64;
60 #else
61 #error Unable to find an appropriate type for P6UINT64 and P6INT64
62 #endif
63 #if P6SIZEOF_PTRDIFF == P6SIZEOF_SIZET
64 typedef size_t P6PTRDIFF;
65 #else
66 #error Unable to find an appropriate type for P6PTRDIFF
67 #endif
68 
69 #endif
70 
71 typedef unsigned char P6UINT8;
72 typedef char P6INT8;
73 typedef P6UINT8 P6BYTE;
74 typedef int16_t P6INT16;
75 typedef uint16_t P6UINT16;
76 typedef int32_t P6INT32;
77 typedef uint32_t P6UINT32;
78 typedef int64_t P6INT64;
79 typedef uint64_t P6UINT64;
80 
81 
82 typedef short P6SHORT;
83 typedef unsigned short P6USHORT;
84 typedef int P6INT;
85 typedef unsigned int P6UINT;
86 typedef long P6LONG;
87 typedef unsigned long P6ULONG;
88 typedef int64_t P6LONGLONG;
89 typedef uint64_t P6ULONGLONG;
90 typedef size_t P6SIZE;
91 typedef ptrdiff_t P6PTRDIFF;
92 #ifndef P6_UEFI
93 typedef double P6FLOAT;
94 #else
95 typedef P6SIZE P6FLOAT;
96 #endif
97 
98 
99 
105 typedef char P6CHAR;
106 typedef P6CHAR* P6STR;
107 typedef const P6CHAR* P6CSTR;
108 typedef unsigned char P6UCHAR;
109 typedef void P6VOID;
110 #ifndef P6_UEFI
111 typedef wchar_t P6WCHAR;
112 #else
113 typedef unsigned short P6WCHAR;
114 #endif
115 typedef P6WCHAR* P6WSTR;
116 typedef const P6WCHAR* P6CWSTR;
117 typedef P6WCHAR* P6COMSTR;
119 #if defined(__GNUC__) || defined(__SUNPRO_CC)
120 #define P6I64(v) v##LL
121 #define P6U64(v) v##ULL
122 #else
123 #define P6I64(v) v##i64
124 #define P6U64(v) v##ui64
125 #endif
126 
127 
133 typedef unsigned char P6BOOL;
134 #define P6TRUE 1
135 #define P6FALSE 0
136 
141 typedef P6UINT32 P6ERR;
142 typedef P6SIZE P6ATOM;
162 typedef struct {
163  P6UINT32 timeLow;
164  P6UINT16 timeMid;
165  P6UINT16 timeHighVer;
166  P6UINT8 clockNode[8];
169 } P6UUID;
170 #define P6UUID_STR_SIZE 39
171 
172 typedef P6UUID P6IID;
173 typedef P6UUID P6CID;
174 typedef P6UUID P6CATID;
185 typedef struct {
186  P6UCHAR *pString;
187  P6SIZE length;
188 } P6BSTR;
189 
199 typedef struct {
200  const P6UCHAR *pString;
201  P6SIZE length;
202 } P6BCSTR;
203 
215 typedef struct {
216  P6WCHAR *pString;
217  P6SIZE length;
218 } P6BWSTR;
219 
231 typedef struct {
232  const P6WCHAR *pString;
233  P6SIZE length;
234 } P6BWCSTR;
235 
246 typedef struct {
247  const P6CHAR *pString;
248  P6SIZE length;
249 } P6NCSTR;
250 
251 
259 typedef P6INT64 P6TIME;
260 
264 typedef struct {
265  P6INT32 useconds;
266  P6INT32 seconds;
267  P6INT32 minutes;
268  P6INT32 hour;
269  P6INT16 month;
270  P6INT16 dayOfMonth;
271  P6INT32 year;
273  P6INT16 dayOfWeek;
274  P6INT16 dayOfYear;
275  P6INT32 tzoff;
276  P6INT32 dstoff;
277 } P6TIMEINFO;
278 
280 
285 typedef P6UINT64 P6INTERVAL;
286 
287 typedef struct {
288  P6UINT32 hours;
289  P6UINT32 minutes;
290  P6UINT32 seconds;
291  P6UINT32 milliseconds;
292  P6UINT64 microseconds;
293  P6UINT64 fractional;
294 } P6EXPANDEDINTERVAL;
295 
296 
297 typedef P6VOID *P6DLLHANDLE;
298 typedef P6VOID *P6SYMPROC;
299 
308 typedef P6UINT8 P6P8BIT;
309 typedef struct {P6UINT8 c[2];} P6P16BIT;
310 typedef struct {P6UINT8 c[4];} P6P32BIT;
311 typedef struct {P6UINT8 c[8];} P6P64BIT;
314 #define P6_NSEC_PER_USEC 1000UL
315 
317 #define P6_NSEC_PER_MSEC 1000000UL
318 
320 #define P6_NSEC_PER_SEC 1000000000UL
321 
323 #define P6_USEC_PER_MSEC 1000UL
324 
326 #define P6_USEC_PER_SEC 1000000UL
327 
329 #define P6_MSEC_PER_SEC 1000UL
330 
331 #define P6_SEC_PER_HOUR 3600UL
332 
333 #define P6_SEC_PER_DAY 86400UL
334 
335 
336 typedef P6SIZE P6PROCESSID;
338 typedef P6SIZE P6THREADID;
339 #define P6INVALID_THREADID 0
340 
346 #define P6MAXTHREADNAME 24
347 
353 #define P6MAXTHREADSTATENAME 24
354 
359 typedef enum {
360  P6TP_LOWEST,
361  P6TP_NORMAL,
362  P6TP_ELAVATED,
363  P6TP_HIGHEST,
364  P6TP_MAX
365 } P6THREADPRIORITY;
366 
373 typedef struct {
374  P6THREADID hThread;
375  P6TIME tStart;
376  P6WCHAR szwName[P6MAXTHREADNAME];
377  P6WCHAR szwState[P6MAXTHREADSTATENAME];
378  P6TIME tLastState;
379  P6THREADPRIORITY priority;
380 } P6THREADINFO;
381 
382 
383 typedef enum {
384  P6AF_INET = 1,
385  P6AF_INET6= 2,
386  P6AF_MAX
387 } P6ADDRFAM;
388 
393 typedef struct {
394  union {
395  P6UINT8 u8[4];
396  P6UINT16 u16[2];
397  P6UINT32 u32;
398  } u;
399 } IPV4ADDR;
400 
405 typedef struct {
406  union {
407  P6UINT8 u8[16];
408  P6UINT16 u16[8];
409  P6UINT32 u32[4];
410  } u;
411 } IPV6ADDR;
412 
417 typedef union {
418  struct {
419  P6ADDRFAM family;
420  P6UINT16 port;
421  IPV4ADDR ip;
422  } inet;
423  struct {
424  P6ADDRFAM family;
425  P6UINT16 port;
426  P6UINT32 flowinfo;
427  IPV6ADDR ip;
428  P6UINT32 scope_id;
429  } inet6;
430 } P6NETADDR;
431 
432 
436 typedef struct {
437  P6INT32 major;
438  P6INT32 minor;
439  P6INT32 patch;
440  P6INT32 build;
441 } P6VERSION;
442 
443 typedef P6UINT32 BUILDFLAGS;
444 #ifndef P6_UEFI
445 static const BUILDFLAGS P6BF_NONE = 0x00000000;
446 static const BUILDFLAGS P6BF_DEBUG = 0x00000001;
447 static const BUILDFLAGS P6BF_RETAIL = 0x00000002;
448 static const BUILDFLAGS P6BF_ALPHA = 0x00000004;
449 static const BUILDFLAGS P6BF_BETA = 0x00000008;
450 static const BUILDFLAGS P6BF_RELEASE = 0x00000010;
451 static const BUILDFLAGS P6BF_INTERNAL = 0x00000020;
452 static const BUILDFLAGS P6BF_LOADER = 0x00000100;
454 static const BUILDFLAGS P6BF_BUILDMODE_MASK = 0x00000003;
455 static const BUILDFLAGS P6BF_RELEASETYPE_MASK= 0x0000003c;
456 #endif /* P6_UEFI */
457 
458 typedef P6UINT32 VERMAGIC;
459 #ifndef P6_UEFI
460 static const VERMAGIC P6VI_MAGIC1 = 0x18436572;
461 static const VERMAGIC P6VI_MAGIC2 = 0x011951dc;
462 #endif /* P6_UEFI */
463 
464 typedef struct {
465  VERMAGIC magic1;
466  VERMAGIC magic2;
467  P6VERSION productver;
468  P6VERSION filever;
469  BUILDFLAGS flags;
470  const P6CHAR *pcszLocale;
471  const P6WCHAR *pszwProductName;
472  const P6WCHAR *pszwCopyright;
473  const P6WCHAR *pszwModuleDesc;
474  const P6WCHAR *pszwBuildNotes;
475 } P6VERINFO;
476 
477 typedef enum {
478  VER_PRODUCT,
479  VER_FILE
480 } VERFIELDS;
481 
482 typedef enum {
483  VER_PRODNAME,
484  VER_COPYRIGHT,
485  VER_MODDESC,
486  VER_NOTES
487 } VERSTRFIELDS;
489 
493 #define P6MAX_LOCALE_LEN 64
494 
495 
500 #define P6SAFESTR_MAX_CCH 2147483647
501 
521 typedef enum {
522  P6AT_BOOL,
523  P6AT_CHAR,
524  P6AT_CHARPTR,
525  P6AT_UCHAR,
526  P6AT_UCHARPTR,
527  P6AT_WCHAR,
528  P6AT_WCHARPTR,
529  P6AT_PTR,
530  P6AT_INT8,
531  P6AT_UINT8,
532  P6AT_INT16,
533  P6AT_UINT16,
534  P6AT_INT32,
535  P6AT_UINT32,
536  P6AT_INT64,
537  P6AT_UINT64,
538  P6AT_SHORT,
539  P6AT_USHORT,
540  P6AT_INT,
541  P6AT_UINT,
542  P6AT_LONG,
543  P6AT_ULONG,
544  P6AT_SIZE,
545  P6AT_FLOAT,
546  P6AT_TIME,
547  P6AT_ERR,
548  P6AT_UUID,
549  P6AT_CATID,
550  P6AT_NETADDR,
551  P6AT_INTERVAL,
552  P6AT_THREADID,
553  P6AT_BSTR,
554  P6AT_BWSTR,
555  P6AT_BCSTR,
556  P6AT_BWCSTR
557 } P6ARGTYPE;
558 
559 typedef enum {
560  P6AF_HEX,
561  P6AF_DEC,
562  P6AF_OCT,
563  P6AF_CHAR,
564  P6AF_STR,
565  P6AF_HEXSTR,
566  P6AF_ISOT,
567  P6AF_RFCT,
568  P6AF_HEXDUMP,
569  P6AF_KBMBGB
570 } P6ARGFMT;
571 
572 typedef P6UINT32 P6ARGFLAGS;
573 static const P6ARGFLAGS P6AFL_NOFLAGS = 0x00000000;
574 static const P6ARGFLAGS P6AFL_LEFTALIGN = 0x00000001;
575 static const P6ARGFLAGS P6AFL_CENTER = 0x00000002;
576 static const P6ARGFLAGS P6AFL_SIGN = 0x00000004;
577 static const P6ARGFLAGS P6AFL_ADDPORT = 0x00000008;
578 static const P6ARGFLAGS P6AFL_ISO860 = 0x00000010;
579 static const P6ARGFLAGS P6AFL_RFC822 = 0x00000020;
580 static const P6ARGFLAGS P6AFL_LOCALTIME = 0x00000040;
581 static const P6ARGFLAGS P6AFL_TRUNCATE = 0x00000080;
582 static const P6ARGFLAGS P6AFL_UPPERCASE = 0x00000100;
583 static const P6ARGFLAGS P6AFL_LOWERCASE = 0x00000200;
585 static const P6ARGFLAGS P6AFL_ALIGNMASK = 0x00000003;
586 static const P6ARGFLAGS P6AFL_CASEMASK = 0x00000300;
591 typedef struct {
592  P6ARGTYPE m_nType;
593  P6UINT16 m_fieldWidth;
594  P6INT16 m_precision;
595  P6WCHAR m_precisionPad;
596  P6WCHAR m_fieldPad;
597  P6ARGFMT m_nFormat;
598  P6ARGFLAGS m_fFlags;
599  union {
600  P6CHAR m_char;
601  P6BOOL m_bool;
602  const P6CHAR *m_charptr;
603  P6UCHAR m_uchar;
604  const P6UCHAR *m_ucharptr;
605  P6WCHAR m_wchar;
606  const P6WCHAR *m_wcharptr;
607  const P6VOID *m_voidptr;
608  P6INT8 m_int8;
609  P6UINT8 m_uint8;
610  P6INT16 m_int16;
611  P6UINT16 m_uint16;
612  P6INT32 m_int32;
613  P6UINT32 m_uint32;
614  P6INT64 m_int64;
615  P6UINT64 m_uint64;
616  P6SHORT m_short;
617  P6USHORT m_ushort;
618  P6INT m_int;
619  P6UINT m_uint;
620  P6LONG m_long;
621  P6ULONG m_ulong;
622  P6SIZE m_sizet;
623  P6FLOAT m_float;
624  P6TIME m_time;
625  P6ERR m_err;
626  P6INTERVAL m_tInterval;
627  P6THREADID m_hThread;
628  const P6UUID *m_uuid;
629  const P6CATID *m_catid;
630  const P6NETADDR *m_netAddr;
631  const P6BSTR *m_bstr;
632  const P6BWSTR *m_bwstr;
633  const P6BCSTR *m_bcstr;
634  const P6BWCSTR *m_bwcstr;
635  } u;
636 } P6ARG;
637 
638 
639  #define P6ARGINPLACE_INIT(type,fieldWidth,precision,precisionPad,fieldPad,format,flags,data) \
640  {(type),(fieldWidth),(precision),(precisionPad),(fieldPad),(format),(flags),{(data)}}
641 
642 #define P6ARGINIT(arg,nType,fmt,fieldWidth,precision,flags,fieldPad,precisionPad) \
643 (arg)->m_nType = (nType); \
644 (arg)->m_fieldWidth = (fieldWidth); \
645 (arg)->m_precision = (precision); \
646 (arg)->m_precisionPad = (precisionPad); \
647 (arg)->m_fieldPad = (fieldPad); \
648 (arg)->m_fFlags = (flags); \
649 (arg)->m_nFormat = (fmt); \
650 (arg)->u.m_uint64 = P6I64(0)
651 
652 #define P6ARGINITBOOLEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_BOOL,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_bool = (data)
653 #define P6ARGINITCHAREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_CHAR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_char = (data)
654 #define P6ARGINITCHARPTREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_CHARPTR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_charptr = (data)
655 #define P6ARGINITUCHAREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_UCHAR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_uchar = (data)
656 #define P6ARGINITWCHAREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_WCHAR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_wchar = (data)
657 #define P6ARGINITWCHARPTREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_WCHARPTR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_wcharptr = (data)
658 #define P6ARGINITPTREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_PTR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_voidptr = (data)
659 #define P6ARGINITINT8EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_INT8,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_int8 = (data)
660 #define P6ARGINITUINT8EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_UINT8,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_uint8 = (data)
661 #define P6ARGINITINT16EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_INT16,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_int16 = (data)
662 #define P6ARGINITUINT16EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_UINT16,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_uint16 = (data)
663 #define P6ARGINITINT32EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_INT32,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_int32 = (data)
664 #define P6ARGINITUINT32EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_UINT32,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_uint32 = (data)
665 #define P6ARGINITINT64EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_INT64,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_int64 = (data)
666 #define P6ARGINITUINT64EX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_UINT64,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_uint64 = (data)
667 #define P6ARGINITSHORTEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_SHORT,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_short = (data)
668 #define P6ARGINITUSHORTEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_USHORT,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_ushort = (data)
669 #define P6ARGINITINTEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_INT,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_int = (data)
670 #define P6ARGINITUINTEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_UINT,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_uint = (data)
671 #define P6ARGINITLONGEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_LONG,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_long = (data)
672 #define P6ARGINITULONGEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_ULONG,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_ulong = (data)
673 #define P6ARGINITSIZEEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_SIZE,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_sizet = (data)
674 #define P6ARGINITTHREADIDEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_THREADID,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_hThread = (data)
675 #define P6ARGINITERREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_ERR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_err = (data)
676 #define P6ARGINITUUIDEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_UUID,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_uuid = (data)
677 #define P6ARGINITCATIDEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_CATID,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_catid = (data)
678 #define P6ARGINITNETADDREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_NETADDR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_netAddr = (data)
679 #define P6ARGINITTIMEEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_TIME,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_time = (data)
680 #define P6ARGINITINTERVALEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_INTERVAL,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_tInterval = (data)
681 #define P6ARGINITFLOATEX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_FLOAT,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_float = (data)
682 #define P6ARGINITBSTREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_BSTR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_bstr = (data)
683 #define P6ARGINITBWSTREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_BWSTR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_bwstr = (data)
684 #define P6ARGINITBCSTREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_BCSTR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_bcstr = (data)
685 #define P6ARGINITBWCSTREX(arg,data,fmt,precision,fieldWidth,flags,ppad,fpad) P6ARGINIT((arg),P6AT_BWCSTR,(fmt),(fieldWidth),(precision),(flags),(fpad),(ppad)); (arg)->u.m_bwcstr = (data)
686 
687 #define P6AI_BOOL(arg,data) P6ARGINITBOOLEX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
688 #define P6AI_BOOL_HEXL(arg,data) P6ARGINITBOOLEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
689 #define P6AI_BOOL_HEXU(arg,data) P6ARGINITBOOLEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
690 #define P6AI_BOOL_DEC(arg,data) P6ARGINITBOOLEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
691 
692 #define P6AI_CHAR(arg,data) P6ARGINITCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_NOFLAGS,0,0)
693 #define P6AI_CHAR_HEXL(arg,data) P6ARGINITCHAREX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
694 #define P6AI_CHAR_HEXU(arg,data) P6ARGINITCHAREX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
695 #define P6AI_CHAR_DEC(arg,data) P6ARGINITCHAREX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
696 #define P6AI_CHAR_OCT(arg,data) P6ARGINITCHAREX(arg,data,P6AF_OCT,0,0,P6AFL_NOFLAGS,0,0)
697 #define P6AI_CHAR_UPR(arg,data) P6ARGINITCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_UPPERCASE,0,0)
698 #define P6AI_CHAR_LWR(arg,data) P6ARGINITCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_LOWERCASE,0,0)
699 
700 #define P6AI_CHARPTR(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
701 #define P6AI_CHARPTR_HEXL(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
702 #define P6AI_CHARPTR_HEXU(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
703 #define P6AI_CHARPTR_DEC(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
704 #define P6AI_CHARPTR_UPR(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_STR,0,0,P6AFL_UPPERCASE,0,0)
705 #define P6AI_CHARPTR_LWR(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_STR,0,0,P6AFL_LOWERCASE,0,0)
706 #define P6AI_CHARPTR_HEXSTR(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_HEXSTR,0,0,P6AFL_LOWERCASE,0,0)
707 #define P6AI_CHARPTR_HEXDUMP(arg,data) P6ARGINITCHARPTREX(arg,data,P6AF_HEXDUMP,0,0,P6AFL_NOFLAGS,0,0)
708 
709 #define P6AI_UCHAR(arg,data) P6ARGINITUCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_NOFLAGS,0,0)
710 #define P6AI_UCHAR_HEXL(arg,data) P6ARGINITUCHAREX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
711 #define P6AI_UCHAR_HEXU(arg,data) P6ARGINITUCHAREX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
712 #define P6AI_UCHAR_DEC(arg,data) P6ARGINITUCHAREX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
713 #define P6AI_UCHAR_OCT(arg,data) P6ARGINITUCHAREX(arg,data,P6AF_OCT,0,0,P6AFL_NOFLAGS,0,0)
714 #define P6AI_UCHAR_UPR(arg,data) P6ARGINITUCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_UPPERCASE,0,0)
715 #define P6AI_UCHAR_LWR(arg,data) P6ARGINITUCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_LOWERCASE,0,0)
716 
717 #define P6AI_WCHAR(arg,data) P6ARGINITWCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_NOFLAGS,0,0)
718 #define P6AI_WCHAR_HEXL(arg,data) P6ARGINITWCHAREX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
719 #define P6AI_WCHAR_HEXU(arg,data) P6ARGINITWCHAREX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
720 #define P6AI_WCHAR_DEC(arg,data) P6ARGINITWCHAREX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
721 #define P6AI_WCHAR_UPR(arg,data) P6ARGINITWCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_UPPERCASE,0,0)
722 #define P6AI_WCHAR_LWR(arg,data) P6ARGINITWCHAREX(arg,data,P6AF_CHAR,0,0,P6AFL_LOWERCASE,0,0)
723 
724 #define P6AI_WCHARPTR(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
725 #define P6AI_WCHARPTR_HEXL(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
726 #define P6AI_WCHARPTR_HEXU(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
727 #define P6AI_WCHARPTR_DEC(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
728 #define P6AI_WCHARPTR_UPR(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_STR,0,0,P6AFL_UPPERCASE,0,0)
729 #define P6AI_WCHARPTR_LWR(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_STR,0,0,P6AFL_LOWERCASE,0,0)
730 #define P6AI_WCHARPTR_HEXSTR(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_HEXSTR,0,0,P6AFL_LOWERCASE,0,0)
731 #define P6AI_WCHARPTR_HEXDUMP(arg,data) P6ARGINITWCHARPTREX(arg,data,P6AF_HEXDUMP,0,0,P6AFL_NOFLAGS,0,0)
732 
733 #define P6AI_PTR(arg,data) P6ARGINITPTREX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
734 #define P6AI_PTR_DEC(arg,data) P6ARGINITPTREX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
735 
736 #define P6AI_INT8(arg,data) P6ARGINITINT8EX(atg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
737 #define P6AI_INT8_HEXL(arg,data) P6ARGINITINT8EX(atg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
738 #define P6AI_INT8_HEXU(arg,data) P6ARGINITINT8EX(atg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
739 
740 #define P6AI_UINT8(arg,data) P6ARGINITUINT8EX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
741 #define P6AI_UINT8_HEXL(arg,data) P6ARGINITUINT8EX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
742 #define P6AI_UINT8_HEXU(arg,data) P6ARGINITUINT8EX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
743 
744 #define P6AI_INT16(arg,data) P6ARGINITINT16EX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
745 #define P6AI_INT16_HEXL(arg,data) P6ARGINITINT16EX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
746 #define P6AI_INT16_HEXU(arg,data) P6ARGINITINT16EX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
747 
748 #define P6AI_UINT16(arg,data) P6ARGINITUINT16EX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
749 #define P6AI_UINT16_HEXL(arg,data) P6ARGINITUINT16EX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
750 #define P6AI_UINT16_HEXU(arg,data) P6ARGINITUINT16EX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
751 
752 #define P6AI_INT32(arg,data) P6ARGINITINT32EX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
753 #define P6AI_INT32_HEXL(arg,data) P6ARGINITINT32EX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
754 #define P6AI_INT32_HEXU(arg,data) P6ARGINITINT32EX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
755 
756 #define P6AI_UINT32(arg,data) P6ARGINITUINT32EX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
757 #define P6AI_UINT32_HEXL(arg,data) P6ARGINITUINT32EX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
758 #define P6AI_UINT32_HEXU(arg,data) P6ARGINITUINT32EX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
759 
760 #define P6AI_INT64(arg,data) P6ARGINITINT64EX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
761 #define P6AI_INT64_HEXL(arg,data) P6ARGINITINT64EX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
762 #define P6AI_INT64_HEXU(arg,data) P6ARGINITINT64EX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
763 
764 #define P6AI_UINT64(arg,data) P6ARGINITUINT64EX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
765 #define P6AI_UINT64_HEXL(arg,data) P6ARGINITUINT64EX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
766 #define P6AI_UINT64_HEXU(arg,data) P6ARGINITUINT64EX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
767 
768 #define P6AI_SHORT(arg,data) P6ARGINITSHORTEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
769 #define P6AI_SHORT_HEXL(arg,data) P6ARGINITSHORTEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
770 #define P6AI_SHORT_HEXU(arg,data) P6ARGINITSHORTEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
771 
772 #define P6AI_USHORT(arg,data) P6ARGINITUSHORTEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
773 #define P6AI_USHORT_HEXL(arg,data) P6ARGINITUSHORTEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
774 #define P6AI_USHORT_HEXU(arg,data) P6ARGINITUSHORTEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
775 
776 #define P6AI_INT(arg,data) P6ARGINITINTEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
777 #define P6AI_INT_HEXL(arg,data) P6ARGINITINTEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
778 #define P6AI_INT_HEXU(arg,data) P6ARGINITINTEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
779 
780 #define P6AI_UINT(arg,data) P6ARGINITUINTEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
781 #define P6AI_UINT_HEXL(arg,data) P6ARGINITUINTEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
782 #define P6AI_UINT_HEXU(arg,data) P6ARGINITUINTEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
783 
784 #define P6AI_LONG(arg,data) P6ARGINITLONGEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
785 #define P6AI_LONG_HEXL(arg,data) P6ARGINITLONGEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
786 #define P6AI_LONG_HEXU(arg,data) P6ARGINITLONGEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
787 
788 #define P6AI_ULONG(arg,data) P6ARGINITULONGEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
789 #define P6AI_ULONG_HEXL(arg,data) P6ARGINITULONGEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
790 #define P6AI_ULONG_HEXU(arg,data) P6ARGINITULONGEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
791 
792 #define P6AI_SIZE(arg,data) P6ARGINITSIZEEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
793 #define P6AI_SIZE_HEXL(arg,data) P6ARGINITSIZEEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
794 #define P6AI_SIZE_HEXU(arg,data) P6ARGINITSIZEEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
795 
796 #define P6AI_THREADID(arg,data) P6ARGINITSIZEEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
797 #define P6AI_THREADID_HEXL(arg,data) P6ARGINITSIZEEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
798 #define P6AI_THREADID_HEXU(arg,data) P6ARGINITSIZEEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
799 
800 #define P6AI_FLOAT(arg,data) P6ARGINITFLOATEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
801 
802 #define P6AI_UUID(arg,data) P6ARGINITUUIDEX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
803 #define P6AI_CATID(arg,data) P6ARGINITCATIDEX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
804 
805 #define P6AI_ERR(arg,data) P6ARGINITERREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
806 #define P6AI_ERR_HEXL(arg,data) P6ARGINITERREX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
807 #define P6AI_ERR_HEXU(arg,data) P6ARGINITERREX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
808 #define P6AI_ERR_DEC(arg,data) P6ARGINITERREX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
809 
810 #define P6AI_NETADDR(arg,data) P6ARGINITNETADDREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
811 #define P6AI_NETADDRPORT(arg,data) P6ARGINITNETADDREX(arg,data,P6AF_STR,0,0,P6AFL_ADDPORT,0,0)
812 
813 #define P6AI_INTERVAL(arg,data) P6ARGINITINTERVALEX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
814 #define P6AI_INTERVAL_ISO860(arg,data) P6ARGINITINTERVALEX(arg,data,P6AF_STR,0,0,P6AFL_ISO860,0,0)
815 #define P6AI_INTERVAL_DEC(arg,data) P6ARGINITINTERVALEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
816 #define P6AI_INTERVAL_HEXL(arg,data) P6ARGINITINTERVALEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
817 #define P6AI_INTERVAL_HEXU(arg,data) P6ARGINITINTERVALEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
818 
819 #define P6AI_TIME(arg,data) P6ARGINITTIMEEX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
820 #define P6AI_TIME_ISO860(arg,data) P6ARGINITTIMEEX(arg,data,P6AF_STR,0,0,P6AFL_ISO860,0,0)
821 #define P6AI_TIME_ISO860_LOCAL(arg,data) P6ARGINITTIMEEX(arg,data,P6AF_STR,0,0,P6AFL_ISO860|P6AFL_LOCALTIME,0,0)
822 #define P6AI_TIME_RFC822(arg,data) P6ARGINITTIMEEX(arg,data,P6AF_STR,0,0,P6AFL_RFC822,0,0)
823 #define P6AI_TIME_DEC(arg,data) P6ARGINITTIMEEX(arg,data,P6AF_DEC,0,0,P6AFL_NOFLAGS,0,0)
824 #define P6AI_TIME_HEXL(arg,data) P6ARGINITTIMEEX(arg,data,P6AF_HEX,0,0,P6AFL_LOWERCASE,0,0)
825 #define P6AI_TIME_HEXU(arg,data) P6ARGINITTIMEEX(arg,data,P6AF_HEX,0,0,P6AFL_UPPERCASE,0,0)
826 
827 #define P6AI_BSTR(arg,data) P6ARGINITBSTREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
828 #define P6AI_BSTR_UPR(arg,data) P6ARGINITBSTREX(arg,data,P6AF_STR,0,0,P6AFL_UPPERCASE,0,0)
829 #define P6AI_BSTR_LWR(arg,data) P6ARGINITBSTREX(arg,data,P6AF_STR,0,0,P6AFL_LOWERCASE,0,0)
830 #define P6AI_BSTR_HEXSTR(arg,data) P6ARGINITBSTREX(arg,data,P6AF_HEXSTR,0,0,P6AFL_LOWERCASE,0,0)
831 #define P6AI_BSTR_HEXDUMP(arg,data) P6ARGINITBSTREX(arg,data,P6AF_HEXDUMP,0,0,P6AFL_NOFLAGS,0,0)
832 
833 #define P6AI_BWSTR(arg,data) P6ARGINITBWSTREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
834 #define P6AI_BWSTR_UPR(arg,data) P6ARGINITBWSTREX(arg,data,P6AF_STR,0,0,P6AFL_UPPERCASE,0,0)
835 #define P6AI_BWSTR_LWR(arg,data) P6ARGINITBWSTREX(arg,data,P6AF_STR,0,0,P6AFL_LOWERCASE,0,0)
836 #define P6AI_BWSTR_HEXSTR(arg,data) P6ARGINITBWSTREX(arg,data,P6AF_HEXSTR,0,0,P6AFL_LOWERCASE,0,0)
837 #define P6AI_BWSTR_HEXDUMP(arg,data) P6ARGINITBWSTREX(arg,data,P6AF_HEXDUMP,0,0,P6AFL_NOFLAGS,0,0)
838 
839 #define P6AI_BCSTR(arg,data) P6ARGINITBCSTREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
840 #define P6AI_BCSTR_UPR(arg,data) P6ARGINITBCSTREX(arg,data,P6AF_STR,0,0,P6AFL_UPPERCASE,0,0)
841 #define P6AI_BCSTR_LWR(arg,data) P6ARGINITBCSTREX(arg,data,P6AF_STR,0,0,P6AFL_LOWERCASE,0,0)
842 #define P6AI_BCSTR_HEXSTR(arg,data) P6ARGINITBCSTREX(arg,data,P6AF_HEXSTR,0,0,P6AFL_LOWERCASE,0,0)
843 #define P6AI_BCSTR_HEXDUMP(arg,data) P6ARGINITBCSTREX(arg,data,P6AF_HEXDUMP,0,0,P6AFL_NOFLAGS,0,0)
844 
845 #define P6AI_BWCSTR(arg,data) P6ARGINITBWCSTREX(arg,data,P6AF_STR,0,0,P6AFL_NOFLAGS,0,0)
846 #define P6AI_BWCSTR_UPR(arg,data) P6ARGINITBWCSTREX(arg,data,P6AF_STR,0,0,P6AFL_UPPERCASE,0,0)
847 #define P6AI_BWCSTR_LWR(arg,data) P6ARGINITBWCSTREX(arg,data,P6AF_STR,0,0,P6AFL_LOWERCASE,0,0)
848 #define P6AI_BWCSTR_HEXSTR(arg,data) P6ARGINITBWCSTREX(arg,data,P6AF_HEXSTR,0,0,P6AFL_LOWERCASE,0,0)
849 #define P6AI_BWCSTR_HEXDUMP(arg,data) P6ARGINITBWCSTREX(arg,data,P6AF_HEXDUMP,0,0,P6AFL_NOFLAGS,0,0)
850 
861 #define P6HEXDUMP_OFFSETSZ 11
862 #define P6HEXDUMP_ASCIISEPSZ 2
863 #define P6HEXDUMP_CHARSPERBYTE 6
872 typedef P6UINT32 P6BTFLAGS;
873 #ifndef P6_UEFI
874 static const P6BTFLAGS BT_NOFLAGS = 0x00000000;
875 static const P6BTFLAGS BT_ADDPATHS = 0x00000001;
876 static const P6BTFLAGS BT_FMTXML = 0x00000002;
877 static const P6BTFLAGS BT_FMTCSV = 0x00000004;
878 static const P6BTFLAGS BT_NODEMANGLE = 0x00000008;
879 #endif /* P6_UEFI */
880 
897 typedef enum {
898  P6D_STARTUP,
899  P6D_INSTALL,
900  P6D_COMPONENT,
901  P6D_CONF,
902  P6D_LANG,
903  P6D_DATA,
904  P6D_LICENSE,
905  P6D_LOG,
906  P6D_MAX
907 } P6DIRS;
908 
909 #ifdef P6_UEFI
910 
918 typedef P6VOID* (*P6PLATFORMALLOC)(P6SIZE cSizeInBytes);
919 
926 typedef P6VOID (*P6PLATFORMFREE)(P6VOID *pMemory);
927 
928 #endif
929 
930 
933 #ifdef __cplusplus
934 } // extern "C"
935 
939 typedef struct P6AUTO_INT32 {
940  P6INT32 value;
941  P6AUTO_INT32() : value(0) {};
942 } P6AUTO_INT32;
943 
944 } // namespace
945 
946 
947 #ifdef P6_UEFI
948 
949 namespace std {
950  typedef int nothrow_t;
951  extern const nothrow_t nothrow; // constant for placement new tag
952 }
953 #endif
954 #endif
956 #include "p6defs.h"
957 #ifdef P6_UEFI
958 #include "p6uefidefs.h"
959 #endif
960 
961 #endif
962 
P6R::P6AT_BWCSTR
Wide const binary string, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags.
Definition: p6types.h:556
P6R::P6BWSTR
Wide binary string.
Definition: p6types.h:215
P6R::P6SIZE
size_t P6SIZE
Definition: p6types.h:90
P6R::P6CID
P6UUID P6CID
A component ID.
Definition: p6types.h:173
P6R::P6ARG::m_int64
P6INT64 m_int64
Definition: p6types.h:614
P6R::P6AF_HEXSTR
Format as hex encoded string, converts character values to hex.
Definition: p6types.h:565
P6R::P6AF_CHAR
Format as a character.
Definition: p6types.h:563
P6R::P6UINT64
uint64_t P6UINT64
Definition: p6types.h:79
P6R::P6ARG::m_time
P6TIME m_time
Definition: p6types.h:624
P6R::P6BCSTR
Const Binary string.
Definition: p6types.h:199
P6R::P6D_LICENSE
This defines where the runtime stores license files.
Definition: p6types.h:904
P6R::P6AF_STR
Format as a text string (prints a formatted UUID string for UUIDs)
Definition: p6types.h:564
P6R::P6UCHAR
unsigned char P6UCHAR
Definition: p6types.h:108
P6R::P6NCSTR
A convience structure to pass around a narrow string along with its length.
Definition: p6types.h:246
P6R::P6AF_HEX
Format as hexadecimal number.
Definition: p6types.h:560
P6R::P6AT_UINT
unsigned unsized integer
Definition: p6types.h:541
P6R::P6ARG::m_bwstr
const P6BWSTR * m_bwstr
Definition: p6types.h:632
P6R::P6BCSTR::length
P6SIZE length
Length of data in bytes.
Definition: p6types.h:201
P6R::P6AF_DEC
Format as a decimal number.
Definition: p6types.h:561
P6R::P6ARG::m_wcharptr
const P6WCHAR * m_wcharptr
Definition: p6types.h:606
P6R::P6ULONGLONG
uint64_t P6ULONGLONG
Definition: p6types.h:89
P6R::P6UINT32
uint32_t P6UINT32
Definition: p6types.h:77
P6R::P6D_STARTUP
The &quot;current&quot; working directory.
Definition: p6types.h:898
P6R::P6INT16
int16_t P6INT16
Definition: p6types.h:74
P6R::P6TIMEINFO::dayOfMonth
P6INT16 dayOfMonth
[1 - 31]
Definition: p6types.h:270
P6R::P6AT_UINT64
Unsigned 64-bit integer.
Definition: p6types.h:537
P6R::P6SHORT
short P6SHORT
Definition: p6types.h:82
P6R::P6PTRDIFF
ptrdiff_t P6PTRDIFF
Definition: p6types.h:91
P6R::P6TIMEINFO::dayOfYear
P6INT16 dayOfYear
[0 - 365] days since January 1
Definition: p6types.h:274
P6R::P6ARG::m_ulong
P6ULONG m_ulong
Definition: p6types.h:621
P6R::P6INT
int P6INT
Definition: p6types.h:84
P6R::P6UUID::timeLow
P6UINT32 timeLow
(4*octet) time_low
Definition: p6types.h:163
P6R::P6AT_NETADDR
Pointer to a P6NETADDR will print dotted quad by default.
Definition: p6types.h:550
P6R::P6AT_UINT32
Unsigned 32-bit integer.
Definition: p6types.h:535
P6R::P6BOOL
unsigned char P6BOOL
Boolean type.
Definition: p6types.h:133
P6R::P6IID
P6UUID P6IID
An interface ID.
Definition: p6types.h:172
P6R::P6COMSTR
P6WCHAR * P6COMSTR
Standard COM length encoded string.
Definition: p6types.h:117
P6R::P6ARG::m_nFormat
P6ARGFMT m_nFormat
Specified how the argument should be renedered (see P6R::P6ARGFMT)
Definition: p6types.h:597
P6R::P6ARG::m_hThread
P6THREADID m_hThread
Definition: p6types.h:627
P6R::P6AT_THREADID
Format a P6THREADID.
Definition: p6types.h:552
P6R::P6AT_WCHARPTR
Pointer to a wide character string, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags...
Definition: p6types.h:528
P6R::P6BWCSTR
Wide Const binary string.
Definition: p6types.h:231
P6R::P6ARG::m_int
P6INT m_int
Definition: p6types.h:618
P6R::P6ARG::m_voidptr
const P6VOID * m_voidptr
Definition: p6types.h:607
P6R::P6AF_RFCT
Format a P6TIME as an RFC 822 date, only valid for an P6ARGTYPE of P6AT_TIME.
Definition: p6types.h:567
P6R::P6INT8
char P6INT8
Definition: p6types.h:72
P6R::P6AT_INT16
Signed 16-bit integer.
Definition: p6types.h:532
P6R::P6AT_CATID
Pointer to a P6CATID.
Definition: p6types.h:549
P6R::P6ARG::m_fFlags
P6ARGFLAGS m_fFlags
See P6R::P6ARGFLAGS.
Definition: p6types.h:598
P6R::P6ARG::m_precisionPad
P6WCHAR m_precisionPad
The character to use to pad out to the width for wide output.
Definition: p6types.h:595
P6R::P6ARGFLAGS
P6UINT32 P6ARGFLAGS
Definition: p6types.h:572
P6R::P6ULONG
unsigned long P6ULONG
Definition: p6types.h:87
P6R::P6ATOM
P6SIZE P6ATOM
Atom type see P6R::p6IAtom in p6com.h.
Definition: p6types.h:142
P6R::P6ARG::m_charptr
const P6CHAR * m_charptr
Definition: p6types.h:602
P6R::P6AT_ULONG
unsigned long integer
Definition: p6types.h:543
P6R::P6TIMEINFO::minutes
P6INT32 minutes
[0 - 59]
Definition: p6types.h:267
P6R::P6D_LANG
I18n files directory (string tables, langtag mappings etc)
Definition: p6types.h:902
P6R::P6AT_SHORT
signed short integer
Definition: p6types.h:538
P6R::P6CSTR
const P6CHAR * P6CSTR
Definition: p6types.h:107
P6R::P6ARG::m_uint8
P6UINT8 m_uint8
Definition: p6types.h:609
P6R::P6ARG::m_bwcstr
const P6BWCSTR * m_bwcstr
Definition: p6types.h:634
P6R::P6ARG::m_char
P6CHAR m_char
Definition: p6types.h:600
P6R::P6AT_TIME
Format a P6TIME as mm/dd/yyyy hh:mm:ss.000000000 or an ISO860 or RFC822 date if the P6AFL_ISO860 or P...
Definition: p6types.h:546
P6R::P6AT_UINT8
Unsigned 8-bit integer.
Definition: p6types.h:531
P6R::P6UINT8
unsigned char P6UINT8
Definition: p6types.h:71
P6R::P6ARG::m_int16
P6INT16 m_int16
Definition: p6types.h:610
P6R::P6AF_ISOT
Format a P6TIME as an ISO 860 date, only valid for an P6ARGTYPE of P6AT_TIME.
Definition: p6types.h:566
P6R::P6BSTR::length
P6SIZE length
Length of data in bytes.
Definition: p6types.h:187
P6R::P6AF_KBMBGB
Format unsigned integer types as string in Bytes/KiloBytes/MegaBytes/GigaBytes etc automatically appe...
Definition: p6types.h:569
P6R::P6AUTO_INT32::value
P6INT32 value
Definition: p6types.h:940
P6R::P6UUID::timeMid
P6UINT16 timeMid
(2*octet) time_mid
Definition: p6types.h:164
P6R::P6USHORT
unsigned short P6USHORT
Definition: p6types.h:83
P6R::P6NCSTR::length
P6SIZE length
Length of data in characters.
Definition: p6types.h:248
P6R::P6BCSTR::pString
const P6UCHAR * pString
Pointer to const data.
Definition: p6types.h:200
P6R::P6AF_OCT
Format as a octal number.
Definition: p6types.h:562
P6R::P6AT_UCHAR
Single byte unsigned character, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags...
Definition: p6types.h:525
P6R::P6ARG::m_int32
P6INT32 m_int32
Definition: p6types.h:612
P6R::P6AT_WCHAR
Single wide character, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags.
Definition: p6types.h:527
P6R::P6AUTO_INT32
struct P6R::P6AUTO_INT32 P6AUTO_INT32
Auto initializing INT32.
P6R::P6AT_LONG
signed long integer
Definition: p6types.h:542
P6R::P6WCHAR
wchar_t P6WCHAR
Wide character type see p6i18n.h.
Definition: p6types.h:111
P6R::P6ARG::m_nType
P6ARGTYPE m_nType
Type of argument (see P6R::P6ARGTYPE)
Definition: p6types.h:592
P6R::P6AT_BCSTR
Narrow const binary string, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags.
Definition: p6types.h:555
P6R::P6AT_USHORT
unsigned short integer
Definition: p6types.h:539
P6R::P6AT_BOOL
P6BOOL renders as &#39;true&#39; or &#39;false&#39;.
Definition: p6types.h:522
P6R::P6BTFLAGS
P6UINT32 P6BTFLAGS
Runtime API Types.
Definition: p6types.h:872
P6R::P6ARG::m_bstr
const P6BSTR * m_bstr
Definition: p6types.h:631
P6R::P6CATID
P6UUID P6CATID
A category ID.
Definition: p6types.h:174
P6R::P6TIMEINFO
A structure that is used to describe a specified time.
Definition: p6types.h:264
P6R::P6AT_INT32
Signed 32-bit integer.
Definition: p6types.h:534
P6R::P6UUID::timeHighVer
P6UINT16 timeHighVer
(2*octet) time_high_and_version
Definition: p6types.h:165
P6R::P6ARG::m_int8
P6INT8 m_int8
Definition: p6types.h:608
P6R::P6ARG::m_short
P6SHORT m_short
Definition: p6types.h:616
P6R::P6AT_SIZE
P6SIZET integer.
Definition: p6types.h:544
P6R::P6TIMEINFO::dstoff
P6INT32 dstoff
Daylight saving time offset in seconds.
Definition: p6types.h:276
P6R::P6AT_INT64
Signed 64-bit integer.
Definition: p6types.h:536
P6R::P6INT64
int64_t P6INT64
Definition: p6types.h:78
P6R::P6D_MAX
Definition: p6types.h:906
P6R::P6D_DATA
This defines which directory data should be written into.
Definition: p6types.h:903
P6R::P6DIRS
P6DIRS
This enumeration defines the directories which can be retrieved using the p6GetDirectory() API...
Definition: p6types.h:897
P6R::P6AT_INT8
Signed 8-bit integer.
Definition: p6types.h:530
P6R::P6ARG::m_wchar
P6WCHAR m_wchar
Definition: p6types.h:605
P6R::P6CWSTR
const P6WCHAR * P6CWSTR
Definition: p6types.h:116
P6R::P6BWCSTR::pString
const P6WCHAR * pString
Pointer to wide const string data.
Definition: p6types.h:232
P6R::P6AT_BSTR
Narrow binary string, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags.
Definition: p6types.h:553
P6R::P6UINT
unsigned int P6UINT
Definition: p6types.h:85
P6R::P6ARG::m_uint32
P6UINT32 m_uint32
Definition: p6types.h:613
P6R::P6BWSTR::pString
P6WCHAR * pString
Pointer to wide string data.
Definition: p6types.h:216
P6R::P6AT_INTERVAL
Format a P6INTERVAL as 00:00:00.000000000 or an ISO860 duration if the P6AFL_ISO860 flag is specified...
Definition: p6types.h:551
P6R::P6AT_CHAR
Single byte signed character, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags.
Definition: p6types.h:523
P6R::P6BSTR
Binary string.
Definition: p6types.h:185
P6R::P6BWCSTR::length
P6SIZE length
Length of data in wide characters.
Definition: p6types.h:233
P6R::P6NCSTR::pString
const P6CHAR * pString
Pointer to narrow const string data.
Definition: p6types.h:247
P6R::P6ARG::m_float
P6FLOAT m_float
Definition: p6types.h:623
P6R::P6ARG::m_catid
const P6CATID * m_catid
Definition: p6types.h:629
P6R::P6D_COMPONENT
The component directory.
Definition: p6types.h:900
P6R::P6LONG
long P6LONG
Definition: p6types.h:86
P6R::P6AT_FLOAT
P6FLOAT.
Definition: p6types.h:545
P6R::P6AT_UCHARPTR
Pointer to an unsigned char string, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags...
Definition: p6types.h:526
P6R::P6D_INSTALL
The directory in which the executable that started the process is located.
Definition: p6types.h:899
P6R::P6ARG::m_bool
P6BOOL m_bool
Definition: p6types.h:601
P6R::P6AF_HEXDUMP
Format data as a multi-line hex dump, 16 bytes/line with leading offset, hexdata, followed by ascii...
Definition: p6types.h:568
P6R::P6BYTE
P6UINT8 P6BYTE
Definition: p6types.h:73
P6R::P6UUID
A universally unique indentifier (UUID).
Definition: p6types.h:162
P6R::P6ARG::m_sizet
P6SIZE m_sizet
Definition: p6types.h:622
P6R::P6ARG::m_ucharptr
const P6UCHAR * m_ucharptr
Definition: p6types.h:604
P6R::P6AUTO_INT32
Auto initializing INT32.
Definition: p6types.h:939
P6R::P6D_CONF
The config directory.
Definition: p6types.h:901
P6R::P6AT_ERR
Converts the specified P6ERR to it&#39;s string representation.
Definition: p6types.h:547
P6R::P6ARG::m_ushort
P6USHORT m_ushort
Definition: p6types.h:617
P6R::P6LONGLONG
int64_t P6LONGLONG
Definition: p6types.h:88
P6R::P6ARG::m_uint64
P6UINT64 m_uint64
Definition: p6types.h:615
P6R::P6TIMEINFO::tzoff
P6INT32 tzoff
Offset from GMT in seconds.
Definition: p6types.h:275
P6R::P6WSTR
P6WCHAR * P6WSTR
Definition: p6types.h:115
P6R::P6TIMEINFO::seconds
P6INT32 seconds
[0 - 61] where the values 60 and 61 are for accommodating up to two leap seconds. ...
Definition: p6types.h:266
P6R::P6ERR
P6UINT32 P6ERR
COM err return type see P6ERR.h.
Definition: p6types.h:141
P6R::P6AT_INT
signed unsized integer
Definition: p6types.h:540
P6R::P6ARG::m_err
P6ERR m_err
Definition: p6types.h:625
P6R::P6AT_PTR
Generic VOID Pointer.
Definition: p6types.h:529
P6R::P6ARG::m_long
P6LONG m_long
Definition: p6types.h:620
P6R::P6STR
P6CHAR * P6STR
Definition: p6types.h:106
P6R::P6TIMEINFO::year
P6INT32 year
Absolute year.
Definition: p6types.h:271
P6R::P6ARG::m_bcstr
const P6BCSTR * m_bcstr
Definition: p6types.h:633
P6R::P6UINT16
uint16_t P6UINT16
Definition: p6types.h:75
P6R::P6AT_CHARPTR
Pointer to a signed char string, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags...
Definition: p6types.h:524
P6R::P6ARG::m_uint16
P6UINT16 m_uint16
Definition: p6types.h:611
P6R::P6ARG::m_uint
P6UINT m_uint
Definition: p6types.h:619
P6R::P6ARG::m_fieldPad
P6WCHAR m_fieldPad
The character to use to pad out to the width for wide output.
Definition: p6types.h:596
P6R::P6TIME
P6INT64 P6TIME
The wallclock time represented as the number of microseconds since midnight January 1 1970 UTC...
Definition: p6types.h:259
P6R::P6ARG::m_tInterval
P6INTERVAL m_tInterval
Definition: p6types.h:626
P6R::P6AT_UINT16
Unsigned 16-bit integer.
Definition: p6types.h:533
P6R::P6AT_BWSTR
Wide binary string, transform based on P6AFL_UPPERCASE/P6AFL_LOWERCASE flags.
Definition: p6types.h:554
P6R::P6FLOAT
double P6FLOAT
Definition: p6types.h:93
P6R::P6TIMEINFO::dayOfWeek
P6INT16 dayOfWeek
[0 - 6] where 0 == Sunday
Definition: p6types.h:273
P6R::P6BSTR::pString
P6UCHAR * pString
Pointer to data.
Definition: p6types.h:186
P6R::P6ARGFMT
P6ARGFMT
Definition: p6types.h:559
P6R::P6BWSTR::length
P6SIZE length
Length of data in wide characters.
Definition: p6types.h:217
P6R::P6AT_UUID
Pointer to a UUID.
Definition: p6types.h:548
P6R::P6ARG::m_fieldWidth
P6UINT16 m_fieldWidth
Controls the minimum width of the regedered argument.
Definition: p6types.h:593
P6R::P6ARG::m_uchar
P6UCHAR m_uchar
Definition: p6types.h:603
P6R::P6VOID
void P6VOID
Definition: p6types.h:109
P6R::P6ARGTYPE
P6ARGTYPE
P6ARG Argument types.
Definition: p6types.h:521
P6R::P6ARG::m_uuid
const P6UUID * m_uuid
Definition: p6types.h:628
P6R::P6INT32
int32_t P6INT32
Definition: p6types.h:76
P6R::P6TIMEINFO::month
P6INT16 month
[0 - 11] where 0 == January
Definition: p6types.h:269
P6R::P6ARG::m_netAddr
const P6NETADDR * m_netAddr
Definition: p6types.h:630
P6R::P6TIMEINFO::useconds
P6INT32 useconds
[0 - 999999] Microseconds past seconds
Definition: p6types.h:265
P6R::P6D_LOG
The directory containing log files.
Definition: p6types.h:905
P6R::P6AUTO_INT32::P6AUTO_INT32
P6AUTO_INT32()
Definition: p6types.h:941
P6R::P6ARG::m_precision
P6INT16 m_precision
Contols precision of numeric output types.
Definition: p6types.h:594
P6R::P6CHAR
char P6CHAR
Narrow character type.
Definition: p6types.h:105
P6R::P6TIMEINFO::hour
P6INT32 hour
[0 - 23] 24 hour clock
Definition: p6types.h:268