Changeset 3525 for trunk/kLdr/kLdrBase.h


Ignore:
Timestamp:
Aug 20, 2007, 12:14:55 AM (18 years ago)
Author:
bird
Message:

made the format headers usable externally.

File:
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/kLdr/kLdrBase.h

    r3388 r3525  
    22/** @file
    33 *
    4  * kLdr - The Dynamic Loader, Helper Functions.
     4 * kLdr - The Dynamic Loader, Base Definitions and Typedefs.
    55 *
    6  * Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
     6 * Copyright (c) 2006-2007 knut st. osmundsen <bird@anduin.net>
    77 *
    88 *
    … …  
    2525 */
    2626
     27#ifndef ___kLdrBase_h___
     28#define ___kLdrBase_h___
    2729
    28 #ifndef __kLdrHlp_h__
    29 #define __kLdrHlp_h__
    3030
    31 /** @defgroup grp_kLdrHlp  kLdrHlp - Helper Functions
    32  * @internal
     31/** @defgroup grp_kLdrBase  kLdrBase - Base Definitions And Typedefs
    3332 * @{ */
     33
     34/*
     35 * kLdr depend on size_t, [u]intNN_t, [u]intptr_t and some related constants.
     36 * If KLDR_ALREADY_INCLUDED_STD_TYPES is defined, these has already been defined.
     37 */
     38#ifndef KLDR_ALREADY_INCLUDED_STD_TYPES
     39# include <sys/types.h>
     40# include <stddef.h>
     41# ifdef _MSC_VER
     42   typedef signed char          int8_t;
     43   typedef unsigned char        uint8_t;
     44   typedef signed short         int16_t;
     45   typedef unsigned short       uint16_t;
     46   typedef signed int           int32_t;
     47   typedef unsigned int         uint32_t;
     48   typedef signed __int64       int64_t;
     49   typedef unsigned __int64     uint64_t;
     50   typedef int64_t              intmax_t;
     51   typedef uint64_t             uintmax_t;
     52#  define UINT8_C(c)            (c)
     53#  define UINT16_C(c)           (c)
     54#  define UINT32_C(c)           (c ## U)
     55#  define UINT64_C(c)           (c ## ULL)
     56#  define INT8_C(c)             (c)
     57#  define INT16_C(c)            (c)
     58#  define INT32_C(c)            (c)
     59#  define INT64_C(c)            (c ## LL)
     60#  define INT8_MIN              (INT8_C(-0x7f) - 1)
     61#  define INT16_MIN             (INT16_C(-0x7fff) - 1)
     62#  define INT32_MIN             (INT32_C(-0x7fffffff) - 1)
     63#  define INT64_MIN             (INT64_C(-0x7fffffffffffffff) - 1)
     64#  define INT8_MAX              INT8_C(0x7f)
     65#  define INT16_MAX             INT16_C(0x7fff)
     66#  define INT32_MAX             INT32_C(0x7fffffff)
     67#  define INT64_MAX             INT64_C(0x7fffffffffffffff)
     68#  define UINT8_MAX             UINT8_C(0xff)
     69#  define UINT16_MAX            UINT16_C(0xffff)
     70#  define UINT32_MAX            UINT32_C(0xffffffff)
     71#  define UINT64_MAX            UINT64_C(0xffffffffffffffff)
     72# else
     73#  include <stdint.h>
     74# endif
     75#endif /* !KLDR_ALREADY_INCLUDED_STD_TYPES */
     76
    3477
    3578/** Get the minimum of two values. */
    … …  
    4992
    5093
     94/** @def KLDR_LITTLE_ENDIAN
     95 * The kLdr build is for a little endian target. */
     96/** @def KLDR_BIG_ENDIAN
     97 * The kLdr build is for a big endian target. */
     98#if !defined(KLDR_LITTLE_ENDIAN) && !defined(KLDR_BIG_ENDIAN)
     99# define KLDR_LITTLE_ENDIAN
     100#endif
     101#ifdef __DOXYGEN__
     102# define KLDR_BIG_ENDIAN
     103#endif
     104
     105
    51106/** @name Endian Conversion
    52107 * @{ */
    53108
    54 /** @def KLDRHLP_E2E_U16
     109/** @def KLDR_E2E_U16
    55110 * Convert the endian of an unsigned 16-bit value. */
    56 # define KLDRHLP_E2E_U16(u16)   ( (uint16_t) (((u16) >> 8) | ((u16) << 8)) )
    57 /** @def KLDRHLP_E2E_U32
     111# define KLDR_E2E_U16(u16)      ( (uint16_t) (((u16) >> 8) | ((u16) << 8)) )
     112/** @def KLDR_E2E_U32
    58113 * Convert the endian of an unsigned 32-bit value. */
    59 # define KLDRHLP_E2E_U32(u32)   (   ( ((u32) & UINT32_C(0xff000000)) >> 24 ) \
     114# define KLDR_E2E_U32(u32)      (   ( ((u32) & UINT32_C(0xff000000)) >> 24 ) \
    60115                                  | ( ((u32) & UINT32_C(0x00ff0000)) >>  8 ) \
    61116                                  | ( ((u32) & UINT32_C(0x0000ff00)) <<  8 ) \
    62117                                  | ( ((u32) & UINT32_C(0x000000ff)) << 24 ) \
    63118                                )
    64 /** @def KLDRHLP_E2E_U64
     119/** @def KLDR_E2E_U64
    65120 * Convert the endian of an unsigned 64-bit value. */
    66 # define KLDRHLP_E2E_U64(u64)   (   ( ((u64) & UINT64_C(0xff00000000000000)) >> 56 ) \
     121# define KLDR_E2E_U64(u64)      (   ( ((u64) & UINT64_C(0xff00000000000000)) >> 56 ) \
    67122                                  | ( ((u64) & UINT64_C(0x00ff000000000000)) >> 40 ) \
    68123                                  | ( ((u64) & UINT64_C(0x0000ff0000000000)) >> 24 ) \
    … …  
    74129                                )
    75130
    76 /** @def KLDRHLP_LE2H_U16
     131/** @def KLDR_LE2H_U16
    77132 * Unsigned 16-bit little-endian to host endian. */
    78 /** @def KLDRHLP_LE2H_U32
     133/** @def KLDR_LE2H_U32
    79134 * Unsigned 32-bit little-endian to host endian. */
    80 /** @def KLDRHLP_LE2H_U64
     135/** @def KLDR_LE2H_U64
    81136 * Unsigned 64-bit little-endian to host endian. */
    82 /** @def KLDRHLP_BE2H_U16
     137/** @def KLDR_BE2H_U16
    83138 * Unsigned 16-bit big-endian to host endian. */
    84 /** @def KLDRHLP_BE2H_U32
     139/** @def KLDR_BE2H_U32
    85140 * Unsigned 32-bit big-endian to host endian. */
    86 /** @def KLDRHLP_BE2H_U64
     141/** @def KLDR_BE2H_U64
    87142 * Unsigned 64-bit big-endian to host endian. */
    88143#ifdef KLDR_LITTLE_ENDIAN
    89 # define KLDRHLP_LE2H_U16(u16)  ((uint16_t)(u16))
    90 # define KLDRHLP_LE2H_U32(u32)  ((uint32_t)(u32))
    91 # define KLDRHLP_LE2H_U64(u64)  ((uint32_t)(u32))
    92 # define KLDRHLP_BE2H_U16(u16)  KLDRHLP_E2E_U16(u16)
    93 # define KLDRHLP_BE2H_U32(u32)  KLDRHLP_E2E_U32(u32)
    94 # define KLDRHLP_BE2H_U64(u64)  KLDRHLP_E2E_U64(u64)
     144# define KLDR_LE2H_U16(u16)  ((uint16_t)(u16))
     145# define KLDR_LE2H_U32(u32)  ((uint32_t)(u32))
     146# define KLDR_LE2H_U64(u64)  ((uint32_t)(u32))
     147# define KLDR_BE2H_U16(u16)  KLDR_E2E_U16(u16)
     148# define KLDR_BE2H_U32(u32)  KLDR_E2E_U32(u32)
     149# define KLDR_BE2H_U64(u64)  KLDR_E2E_U64(u64)
    95150#elif defined(KLDR_BIG_ENDIAN)
    96 # define KLDRHLP_LE2H_U16(u16)  KLDRHLP_E2E_U16(u16)
    97 # define KLDRHLP_LE2H_U32(u32)  KLDRHLP_E2E_U32(u32)
    98 # define KLDRHLP_LE2H_U32(u64)  KLDRHLP_E2E_U64(u64)
    99 # define KLDRHLP_BE2H_U16(u16)  ((uint16_t)(u16))
    100 # define KLDRHLP_BE2H_U32(u32)  ((uint32_t)(u32))
    101 # define KLDRHLP_BE2H_U64(u64)  ((uint32_t)(u32))
     151# define KLDR_LE2H_U16(u16)  KLDR_E2E_U16(u16)
     152# define KLDR_LE2H_U32(u32)  KLDR_E2E_U32(u32)
     153# define KLDR_LE2H_U32(u64)  KLDR_E2E_U64(u64)
     154# define KLDR_BE2H_U16(u16)  ((uint16_t)(u16))
     155# define KLDR_BE2H_U32(u32)  ((uint32_t)(u32))
     156# define KLDR_BE2H_U64(u64)  ((uint32_t)(u32))
    102157#else
    103158# error "KLDR_BIG_ENDIAN or KLDR_LITTLE_ENDIAN is supposed to be defined."
    … …  
    106161/** @} */
    107162
    108 
    109 /*
    110  * Compiler specific helpers / CRT.
    111  * (I.e. operations that tend to have compiler intrinsic implementations).
    112  */
    113 #ifndef KLDR_USE_CRT
    114 
    115 # ifdef __GNUC__
    116 /** memchr */
    117 #  define kLdrHlpMemChr(a,b,c)  __builtin_memchr(a,b,c)
    118 /** memcmp */
    119 #  define kLdrHlpMemComp(a,b,c) __builtin_memcmp(a,b,c)
    120 /** memcpy */
    121 #  define kLdrHlpMemCopy(a,b,c) __builtin_memcpy(a,b,c)
    122 /** memmove */
    123 /*# define kLdrHlpMemMove(a,b,c) __builtin_memmove(a,b,c)*/
    124 #  define kLdrHlpMemMove_needed
    125 /** memset */
    126 #  define kLdrHlpMemSet(a,b,c)  __builtin_memset(a,b,c)
    127 /** strchr */
    128 #  define kLdrHlpStrChr(a, b)   __builtin_strchr(a, b)
    129 /** strcmp */
    130 #  define kLdrHlpStrComp(a, b)  __builtin_strcmp(a, b)
    131 /** strncmp */
    132 #  define kLdrHlpStrNComp(a,b,c) __builtin_strncmp(a, b, c)
    133 /** strlen */
    134 #  define kLdrHlpStrLen(a)      __builtin_strlen(a)
    135 /** alloca */
    136 #  define kLdrHlpAllocA(a)      __builtin_alloca(a)
    137 /** int3 */
    138 #  define kldrHlpBreakpoint() do { __asm__ __volatile__ ("int3\n\tnop"); } while (0)
    139 /** NULL */
    140 #  ifndef NULL
    141 #   define NULL 0
    142 #  endif
    143 # endif
    144 
    145 # ifdef _MSC_VER
    146 #  include <string.h>
    147 #  include <malloc.h>
    148 #  pragma intrinsic(memcmp, memcpy, memset, strcmp, strlen, __debugbreak)
    149 /** memchr */
    150 #  define kLdrHlpMemChr_needed
    151 /** memcmp */
    152 #  define kLdrHlpMemComp(a,b,c) memcmp(a,b,c)
    153 /** memcpy */
    154 #  define kLdrHlpMemCopy(a,b,c) memcpy(a,b,c)
    155 /** memmove */
    156 #  define kLdrHlpMemMove_needed
    157 /** memset */
    158 #  define kLdrHlpMemSet(a,b,c)  memset(a,b,c)
    159 /** strcmp */
    160 #  define kLdrHlpStrComp(a, b)  strcmp(a, b)
    161 /** strncmp */
    162 #  define kLdrHlpStrNComp_needed
    163 /** strlen */
    164 #  define kLdrHlpStrLen(a)      strlen(a)
    165 /** strchr */
    166 #  define kLdrHlpStrChr_needed
    167 /** alloca */
    168 #  define kLdrHlpAllocA(a)      alloca(a)
    169 /** int3 */
    170 #  define kldrHlpBreakpoint() __debugbreak()
    171 /** NULL */
    172 #  ifndef NULL
    173 #   define NULL 0
    174 #  endif
    175 # endif
    176 
    177 # ifdef kLdrHlpStrChr_needed
    178 char   *kLdrHlpStrChr(const char *psz, int ch);
    179 # endif
    180 # ifdef kLdrHlpStrChr_needed
    181 int     kLdrHlpStrNComp(const char *psz1, const char *psz2, size_t cch);
    182 # endif
    183 # ifdef kLdrHlpMemChr_needed
    184 void   *kLdrHlpMemChr(const void *pv, int ch, size_t cb);
    185 # endif
    186 # ifdef kLdrHlpMemMove_needed
    187 void   *kLdrHlpMemMove(void *pv1, const void *pv2, size_t cb);
    188 # endif
    189 
    190 
    191 #else /* KLDR_USE_CRT */
    192 
    193 #  include <string.h>
    194 #  include <stdlib.h>
    195 #  ifdef _MSC_VER
    196 #   include <malloc.h>
    197 #  endif
    198 
    199 #  define kLdrHlpMemChr(a,b,c)  memchr(a,b,c)
    200 /** memcmp */
    201 #  define kLdrHlpMemComp(a,b,c) memcmp(a,b,c)
    202 /** memcpy */
    203 #  define kLdrHlpMemCopy(a,b,c) memcpy(a,b,c)
    204 /** memmove */
    205 #  define kLdrHlpMemMove(a,b,c) memmove(a,b,c)
    206 /** memset */
    207 #  define kLdrHlpMemSet(a,b,c)  memset(a,b,c)
    208 /** strchr */
    209 #  define kLdrHlpStrChr(a, b)   strchr(a, b)
    210 /** strcmp */
    211 #  define kLdrHlpStrComp(a, b)  strcmp(a, b)
    212 /** strncmp */
    213 #  define kLdrHlpStrNComp(a,b,c) strncmp(a, b, c)
    214 /** strlen */
    215 #  define kLdrHlpStrLen(a)      strlen(a)
    216 /** alloca */
    217 #  define kLdrHlpAllocA(a)      alloca(a)
    218 /** int3 */
    219 #  ifdef __GNUC__
    220 #   define kldrHlpBreakpoint() do { __asm__ __volatile__ ("int3\n\tnop"); } while (0)
    221 #  endif
    222 #  ifdef _MSC_VER
    223 #   define kldrHlpBreakpoint() __debugbreak()
    224 #  endif
     163/** @} */
    225164
    226165#endif
    227166
    228 #if (!defined(kLdrHlpMemChr) && !defined(kLdrHlpStrChr_needed))\
    229  || !defined(kLdrHlpMemComp) \
    230  || !defined(kLdrHlpMemCopy) \
    231  || !defined(kLdrHlpMemSet) \
    232  || (!defined(kLdrHlpStrChr) && !defined(kLdrHlpStrChr_needed)) \
    233  || !defined(kLdrHlpStrComp) \
    234  || (!defined(kLdrHlpStrNComp) && !defined(kLdrHlpStrNComp_needed)) \
    235  || !defined(kLdrHlpStrLen) \
    236  || !defined(kLdrHlpAllocA) \
    237  || !defined(kldrHlpBreakpoint)
    238 # error "Needs porting to your compiler."
    239 #endif
    240 
    241 #ifdef __cplusplus
    242 extern "C" {
    243 #endif
    244 
    245 size_t  kLdrHlpStrNLen(const char *psz, size_t cchMax);
    246 int     kLdrHlpMemIComp(const void *pv1, const void *pv2, size_t cb);
    247 int     kLdrHlpStrIComp(const char *pv1, const char *pv2);
    248 
    249 int     kldrHlpSemInit(void);
    250 void    kldrHlpSemTerm(void);
    251 int     kldrHlpSemRequest(void);
    252 void    kldrHlpSemRelease(void);
    253 
    254 int     kldrHlpPageAlloc(void **ppv, size_t cb, KLDRPROT enmProt, unsigned fFixed);
    255 int     kldrHlpPageProtect(void *pv, size_t cb, KLDRPROT enmProt);
    256 int     kldrHlpPageFree(void *pv, size_t cb);
    257 
    258 int     kldrHlpHeapInit(void);
    259 void    kldrHlpHeapTerm(void);
    260 void    kldrHlpHeapDonate(void *pv, size_t cb);
    261 void *  kldrHlpAlloc(size_t cb);
    262 void *  kldrHlpAllocZ(size_t cb);
    263 void    kldrHlpFree(void *pv);
    264 
    265 int     kldrHlpGetEnv(const char *pszVar, char *pszVal, size_t cchVal);
    266 int     kldrHlpGetEnvUZ(const char *pszVar, size_t *pcb);
    267 char   *kldrHlpGetFilename(const char *pszFilename);
    268 char   *kldrHlpGetSuff(const char *pszFilename);
    269 char   *kldrHlpGetExt(const char *pszFilename);
    270 int     kldrHlpIsFilenameOnly(const char *pszFilename);
    271 void    kldrHlpExit(int rc);
    272 void    kldrHlpSleep(unsigned cMillies);
    273 char   *kldrHlpInt2Ascii(char *psz, size_t cch, long lVal, unsigned iBase);
    274 void    kldrHlpAssertMsg(const char *pszExpr, const char *pszFile, unsigned iLine, const char *pszFunction);
    275 
    276 #ifdef __cplusplus
    277 }
    278 #endif
    279 
    280 
    281 /** Assertion macro.
    282  * Users should wrap it since this is ALWAYS compiled in. */
    283 #define kldrHlpAssert(expr) \
    284     do { \
    285         if (!(expr)) \
    286         { \
    287             kldrHlpAssertMsg(#expr, __FILE__, __LINE__, __FUNCTION__); \
    288             kldrHlpBreakpoint(); \
    289         } \
    290     } while (0)
    291 
    292 
    293 /** @name Parameter validation macros
    294  * @{ */
    295 
    296 /** Crash validation of a string argument. */
    297 #define KLDRHLP_VALIDATE_STRING(str) \
    298     do { kLdrHlpStrLen(str); } while (0)
    299 
    300 /** Crash validation of an optional string argument. */
    301 #define KLDRHLP_VALIDATE_OPTIONAL_STRING(str) \
    302     do { if (str) { KLDRHLP_VALIDATE_STRING(str); } } while (0)
    303 
    304 /** Return/Crash validation of an output buffer. */
    305 #define KLDRHLP_VALIDATE_BUFFER(buf, cb) \
    306     do { \
    307         if ((cb)) \
    308         { \
    309             uint8_t             __b; \
    310             uint8_t volatile *  __pb = (uint8_t volatile *)(buf); \
    311             size_t              __cbPage1 = 0x1000 - ((uintptr_t)(__pb) & 0xfff); /* ASSUMES page size! */ \
    312             __b = *__pb; *__pb = 0xff; *__pb = __b; \
    313             if ((cb) > __cbPage1) \
    314             { \
    315                 size_t  __cb = (cb) - __cbPage1; \
    316                 __pb -= __cbPage1; \
    317                 for (;;) \
    318                 { \
    319                     __b = *__pb; *__pb = 0xff; *__pb = __b; \
    320                     if (__cb < 0x1000) \
    321                         break; \
    322                     __pb += 0x1000; \
    323                     __cb -= 0x1000; \
    324                 } \
    325             } \
    326         } \
    327         else \
    328             return KLDR_ERR_INVALID_PARAMETER; \
    329     } while (0)
    330 
    331 /** Crash validation of an optional output buffer. */
    332 #define KLDRHLP_VALIDATE_OPTIONAL_BUFFER(buf, cb) \
    333     do { \
    334         if ((buf) != NULL && (cb) != 0) \
    335         { \
    336             KLDRHLP_VALIDATE_BUFFER(buf, cb); \
    337         } \
    338     } while (0)
    339 
    340 /** Return validation of an enum argument. */
    341 #define KLDRHLP_VALIDATE_ENUM(arg, enumname) \
    342     do { \
    343         if ((arg) <= enumname##_INVALID || (arg) >= enumname##_END) \
    344         {  \
    345             return KLDR_ERR_INVALID_PARAMETER; \
    346         } \
    347     } while (0)
    348 
    349 /** Return validation of a flags argument. */
    350 #define KLDRHLP_VALIDATE_FLAGS(arg, AllowedMask) \
    351     do { \
    352         if ((arg) & ~(AllowedMask)) \
    353         {  \
    354             return KLDR_ERR_INVALID_PARAMETER; \
    355         } \
    356     } while (0)
    357 
    358 /** @} */
    359 
    360 
    361 /** @} */
    362 
    363 #endif /* __kLdrHlp_h__ */
    364 
Note: See TracChangeset for help on using the changeset viewer.