00001 00002 /*---------------------------------------------------------------------------- 00003 | One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined. 00004 *----------------------------------------------------------------------------*/ 00005 #define LITTLEENDIAN 00006 00007 /*---------------------------------------------------------------------------- 00008 | The macro `BITS64' can be defined to indicate that 64-bit integer types are 00009 | supported by the compiler. 00010 *----------------------------------------------------------------------------*/ 00011 #define BITS64 00012 00013 /*---------------------------------------------------------------------------- 00014 | Each of the following `typedef's defines the most convenient type that holds 00015 | integers of at least as many bits as specified. For example, `uint8' should 00016 | be the most convenient type that can hold unsigned integers of as many as 00017 | 8 bits. The `flag' type must be able to hold either a 0 or 1. For most 00018 | implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed 00019 | to the same as `int'. 00020 *----------------------------------------------------------------------------*/ 00021 typedef char flag; 00022 typedef unsigned char uint8; 00023 typedef signed char int8; 00024 typedef int uint16; 00025 typedef int int16; 00026 typedef unsigned int uint32; 00027 typedef signed int int32; 00028 #ifdef BITS64 00029 typedef unsigned long long int uint64; 00030 typedef signed long long int int64; 00031 #endif 00032 00033 /*---------------------------------------------------------------------------- 00034 | Each of the following `typedef's defines a type that holds integers 00035 | of _exactly_ the number of bits specified. For instance, for most 00036 | implementation of C, `bits16' and `sbits16' should be `typedef'ed to 00037 | `unsigned short int' and `signed short int' (or `short int'), respectively. 00038 *----------------------------------------------------------------------------*/ 00039 typedef unsigned char bits8; 00040 typedef signed char sbits8; 00041 typedef unsigned short int bits16; 00042 typedef signed short int sbits16; 00043 typedef unsigned int bits32; 00044 typedef signed int sbits32; 00045 #ifdef BITS64 00046 typedef unsigned long long int bits64; 00047 typedef signed long long int sbits64; 00048 #endif 00049 00050 #ifdef BITS64 00051 /*---------------------------------------------------------------------------- 00052 | The `LIT64' macro takes as its argument a textual integer literal and 00053 | if necessary ``marks'' the literal as having a 64-bit integer type. 00054 | For example, the GNU C Compiler (`gcc') requires that 64-bit literals be 00055 | appended with the letters `LL' standing for `long long', which is `gcc's 00056 | name for the 64-bit integer type. Some compilers may allow `LIT64' to be 00057 | defined as the identity macro: `#define LIT64( a ) a'. 00058 *----------------------------------------------------------------------------*/ 00059 #define LIT64( a ) a##LL 00060 #endif 00061 00062 /*---------------------------------------------------------------------------- 00063 | The macro `INLINE' can be used before functions that should be inlined. If 00064 | a compiler does not support explicit inlining, this macro should be defined 00065 | to be `static'. 00066 *----------------------------------------------------------------------------*/ 00067 #define INLINE extern inline 00068