Annotation of win32/sql/oracle/include/oci/sx3.h, revision 1.1
1.1 ! parser 1: /*
! 2: * $Header: /var/lib/cvsroot/parser3/parser3/src/sql/oracle/oracle32/include/oci/sx3.h,v 1.1 2001/08/22 14:02:20 parser Exp $
! 3: */
! 4:
! 5: /* Copyright (c) Oracle Corporation 1997, 1998, 1999. All Rights Reserved. */
! 6:
! 7: /*
! 8: NAME
! 9: sx3.h - System dependent eXternal definitions for disk data structures.
! 10: (Solaris version).
! 11:
! 12: DESCRIPTION
! 13: System dependent definitions and declarations used in all Oracle disk
! 14: data structures.
! 15:
! 16: RELATED DOCUMENTS
! 17:
! 18: INSPECTION STATUS
! 19: Inspection date:
! 20: Inspection status:
! 21: Estimated increasing cost defects per page:
! 22: Rule sets:
! 23:
! 24: ACCEPTANCE REVIEW STATUS
! 25: Review date:
! 26: Review status:
! 27: Reviewers:
! 28:
! 29: PUBLIC FUNCTIONS
! 30: None
! 31:
! 32: PRIVATE FUNCTIONS
! 33: None
! 34:
! 35: EXAMPLES
! 36: N/A
! 37:
! 38: NOTES
! 39:
! 40: This file contains system dependent definitions and declarations of
! 41: data types used in on-disk structures. On-disk structures should be
! 42: defined in separate header files and can only use data types defined
! 43: in this file. On-disk structures should not use any native types or
! 44: any other type not defined in this file (but defined in sx.h).
! 45:
! 46: Separating the definitions of on-disk data types allows us to keep
! 47: them compatible across different versions. The key purpose of this
! 48: file is to restrict the data types which can go on disk and to make sure
! 49: that their sizes remain the same across different versions.
! 50:
! 51: The -MAXVAL and -MINVAL constants represent the numerical range of
! 52: the relevant data type on the current port, i.e. the value of such
! 53: symbol may change from one port to another. The MIN-MAXVAL and
! 54: MAX-MINVAL constants represent the numerical range of the relevant
! 55: data type across all ports, i.e. the value of these should never be
! 56: changed by porters. Note that MAXSB1MINVAL is -127, instead of
! 57: -128, to support one's ** complement arithmetic architectures.
! 58:
! 59:
! 60: DEVELOPERS: This file has been created to separate all the valid
! 61: data types that can go on on-disk structures. All the types in
! 62: this file are guaranteed to be of the same size across different
! 63: versions, specifically while migrating from 32 bit to 64 bit.
! 64: This is very important to maintain the consistency of data on
! 65: the disk. All on-disk structures should be defined in separate
! 66: header files (*3.h) and *3.h can only include other *3.h header
! 67: files. New data types d*word, dptr_t, dboolean and dsize_t have been
! 68: defined to be used in place of *word, ptr_t, boolean and size_t. All
! 69: the existing references to *word, size_t, boolean and ptr_t in on-disk
! 70: structures have to be replaced with d*word, dsize_t, dboolean and
! 71: dptr_t as word, size_t, boolean and ptr_t could be of different sizes
! 72: in different versions. d*word, dsize_t, dboolean and dptr_t are currently
! 73: defined to have the same size as the existing type and are guaranteed to
! 74: remain the same size in all future versions, like in 64 bit versions.
! 75:
! 76: The d*word, dsize_t, dboolean and dptr_t data types should never be used in
! 77: any new data structures. Also dptr_t is defined as a non pointer type
! 78: to preserve the size. So it should never be used to store a pointer.
! 79: It is provided as a place holder to preserve the size of the structure.
! 80:
! 81: RELATED NOTE: Normal alignment macros like slalsu should never be used
! 82: for on-disk data types. You should use a new set of alignment macros
! 83: defined in sl.h. Instead of slalsu, slalsd, slalpu and slalpd you should
! 84: use sldalsu, sldalsd, sldalpu and sldalpd respectively.
! 85:
! 86:
! 87: PRODUCT LINE DEVELOPERS: This file is solaris specific and
! 88: product lines have to modify this file to reflect their platform. In
! 89: this file the datatypes eb1, ub1, sb1, eb2, ub2, sb2, eb4, ub4, sb4
! 90: must be defined so that they are always of same size for a
! 91: particular platform across different versions. For eg: In solaris
! 92: ub1, ub2, ub4 occupy 1, 2 and 4 bytes respectively. While porting to
! 93: different versions for solaris (say to 64 bit), porters have to make
! 94: sure that they always occupy 1,2 and 4 bytes. If the native data
! 95: type associated with these types are changed to preserve the sizes,
! 96: then literals MIN & MAXVALS have to be changed accordingly. While
! 97: porting to 64 bit, only the definitions of *b1,*b2 and *b4 can be
! 98: changed to preserve their sizes. All other datatypes must not be
! 99: changed.
! 100:
! 101: dword, dsize_t, dboolean and dptr_t are defined to provide backward
! 102: compatibility with word, size_t, boolean and ptr_t. Their definitions
! 103: must be set such that their size is the same as existing word, size_t,
! 104: boolean and ptr_t and should never be changed in the future. For example
! 105: in solaris ptr_t (defined as void *) has the same size as unsigned long
! 106: which is 4 bytes. So dptr_t is defined as ub4 and as ub4's size will
! 107: be constant in the future so will be dsize_t's size. The definition
! 108: of d* should never be changed once they have been defined for a
! 109: particular product line.
! 110:
! 111: MODIFIED (MM/DD/YY)
! 112: tsaulys 02/10/99 - move obsolete types and macros
! 113: dcolello 08/25/98 - WIN32COMMON: port
! 114: kkarun 08/14/98 - Rollback 667803
! 115: tsaulys 07/31/98 - do not use text for C++ (when LUSEMFC defined)
! 116: skabraha 05/08/98 - no more 1's complement support
! 117: skabraha 04/17/98 - changing xb4 to int
! 118: skabraha 01/27/98 - adding M_IDEN and SLMXFNMLEN
! 119: skabraha 10/28/97 - Defining some datatypes to garbage
! 120: skabraha 10/16/97 - Creation
! 121:
! 122:
! 123: */
! 124:
! 125:
! 126: #ifndef SX3_ORACLE
! 127: #define SX3_ORACLE
! 128:
! 129: #ifndef ORALIMITS
! 130: # include <limits.h>
! 131: # define ORALIMITS
! 132: #endif /* !ORALIMITS */
! 133:
! 134: /*
! 135: ** Note: this is the WIN32COMMON version of sx3.h. Always make sure that
! 136: ** WIN32COMMON is defined. It is not defined yet if this file is included
! 137: ** first for whatever reason.
! 138: */
! 139: #ifndef WIN32COMMON
! 140: #define WIN32COMMON
! 141: #endif
! 142:
! 143: #ifdef WIN32COMMON
! 144: /* make sure stdlib.h is included to avoid warning with max()/min() macros */
! 145: #ifndef ORASTDLIB
! 146: # include <stdlib.h>
! 147: # define ORASTDLIB
! 148: #endif
! 149: #endif /* WIN32COMMON */
! 150:
! 151:
! 152: /* All references to size_t has to be replaced with dsize_t. size_t should not
! 153: * be used in any disk structures. To enforce this size_t is defined to
! 154: * an invalid type here. It is redefined to a valid type in sx.h from the
! 155: * included file stddef.h.
! 156: */
! 157:
! 158: #ifdef size_t
! 159: # undef size_t
! 160: #endif /* size_t */
! 161:
! 162:
! 163: #define size_t size_t_may_not_be_used_here
! 164:
! 165: /* As olint accepts most of the datatypes on its own here we are #defining
! 166: * the unwanted data types to garbage to catch its usage. These will be
! 167: * #undefed in the beginning of sx.h.
! 168: */
! 169:
! 170: #ifndef SX3_GARBAGE_DEFS
! 171: # define SX3_GARBAGE_DEFS
! 172:
! 173: # define uword uword_may_not_be_used_here
! 174: # define sword sword_may_not_be_used_here
! 175: # define ubig_ora ubig_ora_may_not_be_used_here
! 176: # define sbig_ora sbig_ora_may_not_be_used_here
! 177: # define ub8 ub8_may_not_be_used_here
! 178: # define sb8 sb8_may_not_be_used_here
! 179: # ifndef WIN32COMMON
! 180: # define boolean boolean_may_not_be_used_here
! 181: # else /* WIN32COMMON */
! 182: # undef boolean
! 183: # endif /* WIN32COMMON */
! 184: # define ptr_t ptr_t_may_not_be_used_here
! 185:
! 186: #endif /* SX3_GARBAGE_DEFS */
! 187:
! 188: /**-------------------------------------------------------------------------**/
! 189: /** DATA TYPE DEFINITIONS **/
! 190: /**-------------------------------------------------------------------------**/
! 191:
! 192: /* We #define while linting as lint complains while casting between
! 193: * two datatypes which have been typedefed to compatible types.
! 194: */
! 195:
! 196: /* xb1 definitions. xb1 will be exactly one byte - at least 8 bits,
! 197: * possibly more. sizeof(ub1) is guaranteed to be 1
! 198: */
! 199:
! 200: #ifndef lint
! 201: typedef unsigned char ub1; /* use where unsigned important */
! 202: typedef signed char sb1; /* use where signed important */
! 203: #else
! 204: #define ub1 unsigned char
! 205: #define sb1 signed char
! 206: #endif /* LINT */
! 207:
! 208: #define UB1MAXVAL ((ub1)UCHAR_MAX)
! 209: #define UB1MINVAL ((ub1) 0)
! 210: #define SB1MAXVAL ((sb1)SCHAR_MAX)
! 211: #define SB1MINVAL ((sb1)SCHAR_MIN)
! 212: #define MINUB1MAXVAL ((ub1) 255)
! 213: #define MAXUB1MINVAL ((ub1) 0)
! 214: #define MINSB1MAXVAL ((sb1) 127)
! 215: #define MAXSB1MINVAL ((sb1) -127)
! 216:
! 217:
! 218: /* xb2 definitions. xb2 will be atleast 2 bytes, possible more */
! 219:
! 220: #ifndef lint
! 221: typedef unsigned short ub2; /* use where unsigned important */
! 222: typedef signed short sb2; /* use where signed important */
! 223: #else
! 224: #define ub2 unsigned short
! 225: #define sb2 signed short
! 226: #endif /* LINT */
! 227:
! 228: #define UB2MAXVAL ((ub2)USHRT_MAX)
! 229: #define UB2MINVAL ((ub2) 0)
! 230: #define SB2MAXVAL ((sb2) SHRT_MAX)
! 231: #define SB2MINVAL ((sb2) SHRT_MIN)
! 232: #define MINUB2MAXVAL ((ub2) 65535)
! 233: #define MAXUB2MINVAL ((ub2) 0)
! 234: #define MINSB2MAXVAL ((sb2) 32767)
! 235: #define MAXSB2MINVAL ((sb2)-32767)
! 236:
! 237:
! 238: /* xb4 definitions. xb4 will be atleast 4 bytes, possibly more */
! 239:
! 240: #ifndef lint
! 241: typedef unsigned int ub4; /* use where unsigned important */
! 242: typedef signed int sb4; /* use where signed important */
! 243: #else
! 244: #define ub4 unsigned int
! 245: #define sb4 signed int
! 246: #endif /* LINT */
! 247:
! 248: #define UB4MAXVAL ((ub4)UINT_MAX)
! 249: #define UB4MINVAL ((ub4) 0)
! 250: #define SB4MAXVAL ((sb4) INT_MAX)
! 251: #define SB4MINVAL ((sb4) INT_MIN)
! 252: #define MINUB4MAXVAL ((ub4) 4294967295)
! 253: #define MAXUB4MINVAL ((ub4) 0)
! 254: #define MINSB4MAXVAL ((sb4) 2147483647)
! 255: #define MAXSB4MINVAL ((sb4)-2147483647)
! 256:
! 257:
! 258: /* number of bits in a byte */
! 259: #define UB1BITS CHAR_BIT
! 260: #define UB1MASK ((1 << ((uword)CHAR_BIT)) - 1)
! 261:
! 262: /* This definition has been moved from s.h as it is used by on-disk
! 263: * data structures. The macros for bitvec are in s.h.
! 264: */
! 265: typedef ub1 bitvec;
! 266:
! 267: /* BITVEC - to size bitvec arrays */
! 268: #define BITVEC(n) (((n)+(UB1BITS-1))>>3)
! 269:
! 270: /* human readable (printable) characters. oratext should always be one byte */
! 271: /*
! 272: * Update for C++ design: change text to oratext
! 273: * typedef unsigned char text;
! 274: */
! 275:
! 276: #ifdef lint
! 277: # define oratext unsigned char
! 278: #else
! 279: typedef unsigned char oratext;
! 280: #endif
! 281:
! 282: /* macros defining min & max */
! 283:
! 284: #ifdef WIN32COMMON
! 285: #ifndef max
! 286: #define max(x, y) (((x) < (y)) ? (y) : (x))
! 287: #endif
! 288: #else
! 289: #define max(x, y) (((x) < (y)) ? (y) : (x))
! 290: #endif
! 291: #define min(x, y) (((x) < (y)) ? (x) : (y))
! 292:
! 293: /**-------------------------------------------------------------------------**/
! 294: /** ALTERNATE DATA TYPES FOR THOSE OBSOLETED FOR ON_DISK DATA STRUCTURES **/
! 295: /**-------------------------------------------------------------------------**/
! 296:
! 297: /* Developers should replace all existing references to *word, ptr_t, boolean
! 298: * and size_t in disk data structures with d*word, dptr_t, dboolean and
! 299: * dsize_t respectively. These types are guaranteed to be of the same size
! 300: * across different versions on a platform.
! 301: *
! 302: * d*word, dsize_t, dboolean and dptr_t should never be used in new data structures.
! 303: * They should only be used to preserve the sizes of existing data
! 304: * structures.
! 305: *
! 306: * WARNING: dptr_t has been defined to be a non-pointer datatype so that we
! 307: * can guarantee that the size remains same!!!
! 308: */
! 309:
! 310:
! 311: /* PRODUCT LINE DEVELOPERS: Change this typedef to a type which has the
! 312: * same size as the current size of *word in your platform. Once the size
! 313: * of d*word has been defined, it should always be of the same size in
! 314: * all future versions (irrespective of the size of *word in later versions)
! 315: *
! 316: * For example in Solaris uword is defined as having 4 bytes. Hence d*word is
! 317: * defined as *b4. This definition will NOT be changed in the future, thus
! 318: * preserving the size.
! 319: */
! 320:
! 321: /* deword is defined as eb4. As ebx is defined later in the obselete section
! 322: * the definition of deword was moved there.
! 323: */
! 324:
! 325: #ifndef lint
! 326: typedef ub4 duword;
! 327: typedef sb4 dsword;
! 328: /* word is an obselete datatype. But it still needs to be changed to dword */
! 329: typedef dsword dword;
! 330:
! 331: #else
! 332: #define duword ub4
! 333: #define dsword sb4
! 334: #define dword dsword
! 335: #endif /*LINT */
! 336:
! 337: #define DUWORDMAXVAL UB4MAXVAL
! 338: #define DUWORDMINVAL UB4MINVAL
! 339: #define DSWORDMAXVAL SB4MAXVAL
! 340: #define DSWORDMINVAL SB4MINVAL
! 341: #define MINDUWORDMAXVAL MINUB4MAXVAL
! 342: #define MAXDUWORDMINVAL MAXUB4MINVAL
! 343: #define MINDSWORDMAXVAL MINSB4MAXVAL
! 344: #define MAXDSWORDMINVAL MAXSB4MINVAL
! 345: #define DWORDMAXVAL DSWORDMAXVAL
! 346: #define DWORDMINVAL DSWORDMINVAL
! 347:
! 348:
! 349:
! 350: /* PRODUCT LINE DEVELOPERS: Change this typedef to a type which has the
! 351: * same size as the current size of size_t in your platform. Once the size
! 352: * of dsize_t has been defined, it should always be of the same size in all
! 353: * future versions (irrespective of the size of size_t in later versions)
! 354: *
! 355: * For example in Solaris size_t is defined as unsigned int which is
! 356: * the same as ub4. Hence it is defined as ub4.
! 357: */
! 358:
! 359: #ifndef lint
! 360: typedef ub4 dsize_t;
! 361: # else
! 362: # define dsize_t ub4
! 363: #endif /*LINT */
! 364:
! 365: # define DSIZE_TMAXVAL UB4MAXVAL
! 366: # define MINDSIZE_TMAXVAL (dsize_t)65535
! 367:
! 368:
! 369: /* PRODUCT LINE DEVELOPERS: Change this typedef to a type which has the
! 370: * same size as the current size of boolean in your platform. Once the size
! 371: * of dboolean has been defined, it should always be of the same size in all
! 372: * future versions (irrespective of the size of boolean in later versions)
! 373: *
! 374: * For example in Solaris boolean is defined as int which is 4 bytes. Hence
! 375: * dboolean is defined as sb4.
! 376: */
! 377:
! 378: #ifndef lint
! 379: typedef sb4 dboolean;
! 380: # else
! 381: # define dboolean sb4
! 382: #endif /*LINT */
! 383:
! 384:
! 385: /*
! 386: * PRODUCT LINE DEVELOPERS: Change this typedef to a type which has the
! 387: * same size as the size of ptr_t in the existing version. Once the size of
! 388: * dptr_t has been defined it should always be of the same size in all future
! 389: * versions, irrrespective of the size of ptr_t in later versions.
! 390: *
! 391: * For example in Solaris the pointer is a 4 byte quantity and hence dptr_t
! 392: * is defined as ub4.
! 393: *
! 394: * WARNING! dptr_t has been defined to be a non-pointer datatype so that
! 395: * we can guarantee that the size remains same! So it should never be used
! 396: * to store a pointer. It should only be used as a place holder to preserve
! 397: * the size of the structure.
! 398: */
! 399:
! 400:
! 401: #ifndef lint
! 402: typedef ub4 dptr_t;
! 403: #else
! 404: #define dptr_t ub4
! 405: #endif /* lint */
! 406:
! 407:
! 408: /* SLMXFNMLEN: Maximum file name length */
! 409: #ifdef AIXRIOS
! 410: # define SLMXFNMLEN 256
! 411: #else
! 412: # define SLMXFNMLEN 512
! 413: #endif /* AIXRIOS */
! 414:
! 415:
! 416: /**-------------------------------------------------------------------------**/
! 417: /** OBSOLETE DATA TYPES **/
! 418: /**-------------------------------------------------------------------------**/
! 419:
! 420: /* OBSOLETE: The following data types have been obsoleted. They should
! 421: * not be used in any new code. Types word, b1, b2, & b4 were
! 422: * considered to be synonyms of eword, eb1, eb2 & eb4, but which
! 423: * actually had to be implemented as sword, sb1, sb2, & sb4 for
! 424: * backward compatibility of old code.
! 425: */
! 426:
! 427: /* ebx definitions */
! 428:
! 429: #ifndef lint
! 430: typedef char eb1;
! 431: typedef short eb2;
! 432: typedef int eb4;
! 433: typedef eb4 deword;
! 434: #else
! 435: # define eb1 char
! 436: # define eb2 short
! 437: # define eb4 int
! 438: # define deword eb4
! 439: #endif
! 440:
! 441: #define EB1MAXVAL ((eb1)SCHAR_MAX)
! 442: #define EB1MINVAL ((eb1) 0)
! 443: #define MINEB1MAXVAL ((eb1) 127)
! 444: #define MAXEB1MINVAL ((eb1) 0)
! 445: #define EB2MAXVAL ((eb2) SHRT_MAX)
! 446: #define EB2MINVAL ((eb2) 0)
! 447: #define MINEB2MAXVAL ((eb2) 32767)
! 448: #define MAXEB2MINVAL ((eb2) 0)
! 449: #define EB4MAXVAL ((eb4) INT_MAX)
! 450: #define EB4MINVAL ((eb4) 0)
! 451: #define MINEB4MAXVAL ((eb4) 2147483647)
! 452: #define MAXEB4MINVAL ((eb4) 0)
! 453: #define DEWORDMAXVAL EB4MAXVAL
! 454: #define DEWORDMINVAL EB4MINVAL
! 455: #define MINDEWORDMAXVAL MINEB4MAXVAL
! 456: #define MAXDEWORDMINVAL MAXEB4MINVAL
! 457:
! 458:
! 459: /* bx definitions */
! 460:
! 461: #ifndef lint
! 462: typedef sb1 b1;
! 463: #else
! 464: #define b1 sb1
! 465: #endif /* lint */
! 466: #define B1MAXVAL SB1MAXVAL
! 467: #define B1MINVAL SB1MINVAL
! 468:
! 469: #ifndef lint
! 470: typedef sb2 b2;
! 471: #else
! 472: #define b2 sb2
! 473: #endif /* lint */
! 474: #define B2MAXVAL SB2MAXVAL
! 475: #define B2MINVAL SB2MINVAL
! 476:
! 477: #ifndef lint
! 478: typedef sb4 b4;
! 479: #else
! 480: #define b4 sb4
! 481: #endif /* lint */
! 482: # define B4MAXVAL SB4MAXVAL
! 483: # define B4MINVAL SB4MINVAL
! 484:
! 485:
! 486: #ifndef uiXT
! 487: /* Since the use of BITS16 and BITS32 conflict with X Windows definitions, */
! 488: /* they need to disappear when Xt-based toolkits are being compiled. */
! 489:
! 490: /* OBSOLETE: BITS8/16/32 are synonyms of ub1/2/4, which are preferred */
! 491: typedef ub1 BITS8; /* Can hold 8 bits */
! 492: typedef ub2 BITS16; /* Can hold 16 bits */
! 493: typedef ub4 BITS32; /* Can hold 32 bits */
! 494: #endif /* uiXT */
! 495:
! 496: /* OBSOLETE: For C++ users who are using Microsoft Foundation Classes, the
! 497: * obsolete Oracle type text conflicts with a reserved keyword. If LUSEMFC is
! 498: * defined, the Oracle definition of text is not used.
! 499: */
! 500: #if !defined(LUSEMFC)
! 501: # ifdef lint
! 502: # define text unsigned char
! 503: # define OraText unsigned char
! 504: # else
! 505: typedef oratext text;
! 506: typedef oratext OraText;
! 507: # endif /* lint */
! 508: #endif /* !LUSEMFC */
! 509:
! 510: /* OBSOLETE:
! 511: ** M_IDEN - maximum identifier size
! 512: **
! 513: ** This constant is generic, and should NEVER be changed.
! 514: */
! 515: #define M_IDEN 30
! 516:
! 517:
! 518: #endif /* SX3_ORACLE */
! 519:
! 520:
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sx3.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / sql / oracle / include / oci