Base.h

Go to the documentation of this file.

 
#ifndef __BASE_H__
#define __BASE_H__
 
//
// Include processor specific binding
//
#include <ProcessorBind.h>
 
#if defined(_MSC_EXTENSIONS)
//
// Disable warning when last field of data structure is a zero sized array.
//
#pragma warning ( disable : 4200 )
#endif
 
#define VERIFY_SIZE_OF(TYPE, Size) extern UINT8 _VerifySizeof##TYPE[(sizeof(TYPE) == (Size)) / (sizeof(TYPE) == (Size))]
 
//
// Verify that ProcessorBind.h produced UEFI Data Types that are compliant with
// Section 2.3.1 of the UEFI 2.3 Specification.
//
VERIFY_SIZE_OF (BOOLEAN, 1);
VERIFY_SIZE_OF (INT8, 1);
VERIFY_SIZE_OF (UINT8, 1);
VERIFY_SIZE_OF (INT16, 2);
VERIFY_SIZE_OF (UINT16, 2);
VERIFY_SIZE_OF (INT32, 4);
VERIFY_SIZE_OF (UINT32, 4);
VERIFY_SIZE_OF (INT64, 8);
VERIFY_SIZE_OF (UINT64, 8);
VERIFY_SIZE_OF (CHAR8, 1);
VERIFY_SIZE_OF (CHAR16, 2);
 
//
// The following three enum types are used to verify that the compiler
// configuration for enum types is compliant with Section 2.3.1 of the
// UEFI 2.3 Specification. These enum types and enum values are not
// intended to be used. A prefix of '__' is used avoid conflicts with
// other types.
//
typedef enum {
  __VerifyUint8EnumValue = 0xff
} __VERIFY_UINT8_ENUM_SIZE;
 
typedef enum {
  __VerifyUint16EnumValue = 0xffff
} __VERIFY_UINT16_ENUM_SIZE;
 
typedef enum {
  __VerifyUint32EnumValue = 0xffffffff
} __VERIFY_UINT32_ENUM_SIZE;
 
VERIFY_SIZE_OF (__VERIFY_UINT8_ENUM_SIZE, 4);
VERIFY_SIZE_OF (__VERIFY_UINT16_ENUM_SIZE, 4);
VERIFY_SIZE_OF (__VERIFY_UINT32_ENUM_SIZE, 4);
 
//
// The Microsoft* C compiler can removed references to unreferenced data items
//  if the /OPT:REF linker option is used. We defined a macro as this is a
//  a non standard extension
//
#if defined(_MSC_EXTENSIONS) && _MSC_VER < 1800 && !defined (MDE_CPU_EBC)
  #define GLOBAL_REMOVE_IF_UNREFERENCED __declspec(selectany)
#else
  #define GLOBAL_REMOVE_IF_UNREFERENCED
#endif
 
//
// Should be used in combination with NORETURN to avoid 'noreturn' returns
// warnings.
//
#ifndef UNREACHABLE
  #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4)
    #define UNREACHABLE()  __builtin_unreachable ()
  #elif defined (__has_feature)
    #if __has_builtin (__builtin_unreachable)
      #define UNREACHABLE()  __builtin_unreachable ()
    #endif
  #endif
 
  #ifndef UNREACHABLE
    #define UNREACHABLE()
  #endif
#endif
 
//
// Signaling compilers and analyzers that a certain function cannot return may
// remove all following code and thus lead to better optimization and less
// false positives.
//
#ifndef NORETURN
  #if defined (__GNUC__) || defined (__clang__)
    #define NORETURN  __attribute__((noreturn))
  #elif defined(_MSC_EXTENSIONS) && !defined(MDE_CPU_EBC)
    #define NORETURN  __declspec(noreturn)
  #else
    #define NORETURN
  #endif
#endif
 
//
// Should be used in combination with ANALYZER_NORETURN to avoid 'noreturn'
// returns warnings.
//
#ifndef ANALYZER_UNREACHABLE
  #ifdef __clang_analyzer__
    #if __has_builtin (__builtin_unreachable)
      #define ANALYZER_UNREACHABLE()  __builtin_unreachable ()
    #endif
  #endif
 
  #ifndef ANALYZER_UNREACHABLE
    #define ANALYZER_UNREACHABLE()
  #endif
#endif
 
//
// Static Analyzers may issue errors about potential NULL-dereferences when
// dereferencing a pointer, that has been checked before, outside of a
// NULL-check.  This may lead to false positives, such as when using ASSERT()
// for verification.
//
#ifndef ANALYZER_NORETURN
  #ifdef __has_feature
    #if __has_feature (attribute_analyzer_noreturn)
      #define ANALYZER_NORETURN  __attribute__((analyzer_noreturn))
    #endif
  #endif
 
  #ifndef ANALYZER_NORETURN
    #define ANALYZER_NORETURN
  #endif
#endif
 
#ifndef RETURNS_TWICE
  #if defined (__GNUC__) || defined (__clang__)
    #define RETURNS_TWICE  __attribute__((returns_twice))
  #else
    #define RETURNS_TWICE
  #endif
#endif
 
//
// For symbol name in assembly code, an extra "_" is sometimes necessary
//
 
#define _CONCATENATE(a, b)  __CONCATENATE(a, b)
#define __CONCATENATE(a, b) a ## b
 
#define ASM_PFX(name) _CONCATENATE (__USER_LABEL_PREFIX__, name)
 
#if __APPLE__
  //
  // Apple extension that is used by the linker to optimize code size
  // with assembly functions. Put at the end of your .S files
  //
  #define ASM_FUNCTION_REMOVE_IF_UNREFERENCED  .subsections_via_symbols
#else
  #define ASM_FUNCTION_REMOVE_IF_UNREFERENCED
#endif
 
#ifdef __CC_ARM
  //
  // Older RVCT ARM compilers don't fully support #pragma pack and require __packed
  // as a prefix for the structure.
  //
  #define PACKED  __packed
#else
  #define PACKED
#endif
 
typedef struct {
  UINT32  Data1;
  UINT16  Data2;
  UINT16  Data3;
  UINT8   Data4[8];
} GUID;
 
typedef struct {
  UINT8 Addr[4];
} IPv4_ADDRESS;
 
typedef struct {
  UINT8 Addr[16];
} IPv6_ADDRESS;
 
//
// 8-bytes unsigned value that represents a physical system address.
//
typedef UINT64 PHYSICAL_ADDRESS;
 
typedef struct _LIST_ENTRY LIST_ENTRY;
 
struct _LIST_ENTRY {
  LIST_ENTRY  *ForwardLink;
  LIST_ENTRY  *BackLink;
};
 
//
// Modifiers to abstract standard types to aid in debug of problems
//
 
#define CONST     const
 
#define STATIC    static
 
#define VOID      void
 
//
// Modifiers for Data Types used to self document code.
// This concept is borrowed for UEFI specification.
//
 
#define IN
 
#define OUT
 
#define OPTIONAL
 
//
//  UEFI specification claims 1 and 0. We are concerned about the
//  compiler portability so we did it this way.
//
 
#define TRUE  ((BOOLEAN)(1==1))
 
#define FALSE ((BOOLEAN)(0==1))
 
#define NULL  ((VOID *) 0)
 
//
// Null character
//
#define CHAR_NULL             0x0000
 
#define MAX_INT8    ((INT8)0x7F)
#define MAX_UINT8   ((UINT8)0xFF)
#define MAX_INT16   ((INT16)0x7FFF)
#define MAX_UINT16  ((UINT16)0xFFFF)
#define MAX_INT32   ((INT32)0x7FFFFFFF)
#define MAX_UINT32  ((UINT32)0xFFFFFFFF)
#define MAX_INT64   ((INT64)0x7FFFFFFFFFFFFFFFULL)
#define MAX_UINT64  ((UINT64)0xFFFFFFFFFFFFFFFFULL)
 
#define MIN_INT8   (((INT8)  -127) - 1)
#define MIN_INT16  (((INT16) -32767) - 1)
#define MIN_INT32  (((INT32) -2147483647) - 1)
#define MIN_INT64  (((INT64) -9223372036854775807LL) - 1)
 
#define  BIT0     0x00000001
#define  BIT1     0x00000002
#define  BIT2     0x00000004
#define  BIT3     0x00000008
#define  BIT4     0x00000010
#define  BIT5     0x00000020
#define  BIT6     0x00000040
#define  BIT7     0x00000080
#define  BIT8     0x00000100
#define  BIT9     0x00000200
#define  BIT10    0x00000400
#define  BIT11    0x00000800
#define  BIT12    0x00001000
#define  BIT13    0x00002000
#define  BIT14    0x00004000
#define  BIT15    0x00008000
#define  BIT16    0x00010000
#define  BIT17    0x00020000
#define  BIT18    0x00040000
#define  BIT19    0x00080000
#define  BIT20    0x00100000
#define  BIT21    0x00200000
#define  BIT22    0x00400000
#define  BIT23    0x00800000
#define  BIT24    0x01000000
#define  BIT25    0x02000000
#define  BIT26    0x04000000
#define  BIT27    0x08000000
#define  BIT28    0x10000000
#define  BIT29    0x20000000
#define  BIT30    0x40000000
#define  BIT31    0x80000000
#define  BIT32    0x0000000100000000ULL
#define  BIT33    0x0000000200000000ULL
#define  BIT34    0x0000000400000000ULL
#define  BIT35    0x0000000800000000ULL
#define  BIT36    0x0000001000000000ULL
#define  BIT37    0x0000002000000000ULL
#define  BIT38    0x0000004000000000ULL
#define  BIT39    0x0000008000000000ULL
#define  BIT40    0x0000010000000000ULL
#define  BIT41    0x0000020000000000ULL
#define  BIT42    0x0000040000000000ULL
#define  BIT43    0x0000080000000000ULL
#define  BIT44    0x0000100000000000ULL
#define  BIT45    0x0000200000000000ULL
#define  BIT46    0x0000400000000000ULL
#define  BIT47    0x0000800000000000ULL
#define  BIT48    0x0001000000000000ULL
#define  BIT49    0x0002000000000000ULL
#define  BIT50    0x0004000000000000ULL
#define  BIT51    0x0008000000000000ULL
#define  BIT52    0x0010000000000000ULL
#define  BIT53    0x0020000000000000ULL
#define  BIT54    0x0040000000000000ULL
#define  BIT55    0x0080000000000000ULL
#define  BIT56    0x0100000000000000ULL
#define  BIT57    0x0200000000000000ULL
#define  BIT58    0x0400000000000000ULL
#define  BIT59    0x0800000000000000ULL
#define  BIT60    0x1000000000000000ULL
#define  BIT61    0x2000000000000000ULL
#define  BIT62    0x4000000000000000ULL
#define  BIT63    0x8000000000000000ULL
 
#define  SIZE_1KB    0x00000400
#define  SIZE_2KB    0x00000800
#define  SIZE_4KB    0x00001000
#define  SIZE_8KB    0x00002000
#define  SIZE_16KB   0x00004000
#define  SIZE_32KB   0x00008000
#define  SIZE_64KB   0x00010000
#define  SIZE_128KB  0x00020000
#define  SIZE_256KB  0x00040000
#define  SIZE_512KB  0x00080000
#define  SIZE_1MB    0x00100000
#define  SIZE_2MB    0x00200000
#define  SIZE_4MB    0x00400000
#define  SIZE_8MB    0x00800000
#define  SIZE_16MB   0x01000000
#define  SIZE_32MB   0x02000000
#define  SIZE_64MB   0x04000000
#define  SIZE_128MB  0x08000000
#define  SIZE_256MB  0x10000000
#define  SIZE_512MB  0x20000000
#define  SIZE_1GB    0x40000000
#define  SIZE_2GB    0x80000000
#define  SIZE_4GB    0x0000000100000000ULL
#define  SIZE_8GB    0x0000000200000000ULL
#define  SIZE_16GB   0x0000000400000000ULL
#define  SIZE_32GB   0x0000000800000000ULL
#define  SIZE_64GB   0x0000001000000000ULL
#define  SIZE_128GB  0x0000002000000000ULL
#define  SIZE_256GB  0x0000004000000000ULL
#define  SIZE_512GB  0x0000008000000000ULL
#define  SIZE_1TB    0x0000010000000000ULL
#define  SIZE_2TB    0x0000020000000000ULL
#define  SIZE_4TB    0x0000040000000000ULL
#define  SIZE_8TB    0x0000080000000000ULL
#define  SIZE_16TB   0x0000100000000000ULL
#define  SIZE_32TB   0x0000200000000000ULL
#define  SIZE_64TB   0x0000400000000000ULL
#define  SIZE_128TB  0x0000800000000000ULL
#define  SIZE_256TB  0x0001000000000000ULL
#define  SIZE_512TB  0x0002000000000000ULL
#define  SIZE_1PB    0x0004000000000000ULL
#define  SIZE_2PB    0x0008000000000000ULL
#define  SIZE_4PB    0x0010000000000000ULL
#define  SIZE_8PB    0x0020000000000000ULL
#define  SIZE_16PB   0x0040000000000000ULL
#define  SIZE_32PB   0x0080000000000000ULL
#define  SIZE_64PB   0x0100000000000000ULL
#define  SIZE_128PB  0x0200000000000000ULL
#define  SIZE_256PB  0x0400000000000000ULL
#define  SIZE_512PB  0x0800000000000000ULL
#define  SIZE_1EB    0x1000000000000000ULL
#define  SIZE_2EB    0x2000000000000000ULL
#define  SIZE_4EB    0x4000000000000000ULL
#define  SIZE_8EB    0x8000000000000000ULL
 
#define  BASE_1KB    0x00000400
#define  BASE_2KB    0x00000800
#define  BASE_4KB    0x00001000
#define  BASE_8KB    0x00002000
#define  BASE_16KB   0x00004000
#define  BASE_32KB   0x00008000
#define  BASE_64KB   0x00010000
#define  BASE_128KB  0x00020000
#define  BASE_256KB  0x00040000
#define  BASE_512KB  0x00080000
#define  BASE_1MB    0x00100000
#define  BASE_2MB    0x00200000
#define  BASE_4MB    0x00400000
#define  BASE_8MB    0x00800000
#define  BASE_16MB   0x01000000
#define  BASE_32MB   0x02000000
#define  BASE_64MB   0x04000000
#define  BASE_128MB  0x08000000
#define  BASE_256MB  0x10000000
#define  BASE_512MB  0x20000000
#define  BASE_1GB    0x40000000
#define  BASE_2GB    0x80000000
#define  BASE_4GB    0x0000000100000000ULL
#define  BASE_8GB    0x0000000200000000ULL
#define  BASE_16GB   0x0000000400000000ULL
#define  BASE_32GB   0x0000000800000000ULL
#define  BASE_64GB   0x0000001000000000ULL
#define  BASE_128GB  0x0000002000000000ULL
#define  BASE_256GB  0x0000004000000000ULL
#define  BASE_512GB  0x0000008000000000ULL
#define  BASE_1TB    0x0000010000000000ULL
#define  BASE_2TB    0x0000020000000000ULL
#define  BASE_4TB    0x0000040000000000ULL
#define  BASE_8TB    0x0000080000000000ULL
#define  BASE_16TB   0x0000100000000000ULL
#define  BASE_32TB   0x0000200000000000ULL
#define  BASE_64TB   0x0000400000000000ULL
#define  BASE_128TB  0x0000800000000000ULL
#define  BASE_256TB  0x0001000000000000ULL
#define  BASE_512TB  0x0002000000000000ULL
#define  BASE_1PB    0x0004000000000000ULL
#define  BASE_2PB    0x0008000000000000ULL
#define  BASE_4PB    0x0010000000000000ULL
#define  BASE_8PB    0x0020000000000000ULL
#define  BASE_16PB   0x0040000000000000ULL
#define  BASE_32PB   0x0080000000000000ULL
#define  BASE_64PB   0x0100000000000000ULL
#define  BASE_128PB  0x0200000000000000ULL
#define  BASE_256PB  0x0400000000000000ULL
#define  BASE_512PB  0x0800000000000000ULL
#define  BASE_1EB    0x1000000000000000ULL
#define  BASE_2EB    0x2000000000000000ULL
#define  BASE_4EB    0x4000000000000000ULL
#define  BASE_8EB    0x8000000000000000ULL
 
//
//  Support for variable argument lists in freestanding edk2 modules.
//
//  For modules that use the ISO C library interfaces for variable
//  argument lists, refer to "StdLib/Include/stdarg.h".
//
//  VA_LIST  - typedef for argument list.
//  VA_START (VA_LIST Marker, argument before the ...) - Init Marker for use.
//  VA_END (VA_LIST Marker) - Clear Marker
//  VA_ARG (VA_LIST Marker, var arg type) - Use Marker to get an argument from
//    the ... list. You must know the type and pass it in this macro.  Type
//    must be compatible with the type of the actual next argument (as promoted
//    according to the default argument promotions.)
//  VA_COPY (VA_LIST Dest, VA_LIST Start) - Initialize Dest as a copy of Start.
//
//  Example:
//
//  UINTN
//  EFIAPI
//  ExampleVarArg (
//    IN UINTN  NumberOfArgs,
//    ...
//    )
//  {
//    VA_LIST Marker;
//    UINTN   Index;
//    UINTN   Result;
//
//    //
//    // Initialize the Marker
//    //
//    VA_START (Marker, NumberOfArgs);
//    for (Index = 0, Result = 0; Index < NumberOfArgs; Index++) {
//      //
//      // The ... list is a series of UINTN values, so sum them up.
//      //
//      Result += VA_ARG (Marker, UINTN);
//    }
//
//    VA_END (Marker);
//    return Result;
//  }
//
//  Notes:
//  - Functions that call VA_START() / VA_END() must have a variable
//    argument list and must be declared EFIAPI.
//  - Functions that call VA_COPY() / VA_END() must be declared EFIAPI.
//  - Functions that only use VA_LIST and VA_ARG() need not be EFIAPI.
//
 
#define _INT_SIZE_OF(n) ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
 
#if defined(__CC_ARM)
//
// RVCT ARM variable argument list support.
//
 
#ifdef __APCS_ADSABI
  typedef int         *va_list[1];
  #define VA_LIST     va_list
#else
  typedef struct __va_list { void *__ap; } va_list;
  #define VA_LIST                          va_list
#endif
 
#define VA_START(Marker, Parameter)   __va_start(Marker, Parameter)
 
#define VA_ARG(Marker, TYPE)          __va_arg(Marker, TYPE)
 
#define VA_END(Marker)                ((void)0)
 
// For some ARM RVCT compilers, __va_copy is not defined
#ifndef __va_copy
  #define __va_copy(dest, src) ((void)((dest) = (src)))
#endif
 
#define VA_COPY(Dest, Start)          __va_copy (Dest, Start)
 
#elif defined(_M_ARM) || defined(_M_ARM64)
//
// MSFT ARM variable argument list support.
//
 
typedef char* VA_LIST;
 
#define VA_START(Marker, Parameter)     __va_start (&Marker, &Parameter, _INT_SIZE_OF (Parameter), __alignof(Parameter), &Parameter)
#define VA_ARG(Marker, TYPE)            (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE) + ((-(INTN)Marker) & (sizeof(TYPE) - 1))) - _INT_SIZE_OF (TYPE)))
#define VA_END(Marker)                  (Marker = (VA_LIST) 0)
#define VA_COPY(Dest, Start)            ((void)((Dest) = (Start)))
 
#elif defined(__GNUC__)
 
#if defined(MDE_CPU_X64) && !defined(NO_MSABI_VA_FUNCS)
//
// X64 only. Use MS ABI version of GCC built-in macros for variable argument lists.
//
 
typedef __builtin_ms_va_list VA_LIST;
 
#define VA_START(Marker, Parameter)  __builtin_ms_va_start (Marker, Parameter)
 
#define VA_ARG(Marker, TYPE)         ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
 
#define VA_END(Marker)               __builtin_ms_va_end (Marker)
 
#define VA_COPY(Dest, Start)         __builtin_ms_va_copy (Dest, Start)
 
#else
//
// Use GCC built-in macros for variable argument lists.
//
 
typedef __builtin_va_list VA_LIST;
 
#define VA_START(Marker, Parameter)  __builtin_va_start (Marker, Parameter)
 
#define VA_ARG(Marker, TYPE)         ((sizeof (TYPE) < sizeof (UINTN)) ? (TYPE)(__builtin_va_arg (Marker, UINTN)) : (TYPE)(__builtin_va_arg (Marker, TYPE)))
 
#define VA_END(Marker)               __builtin_va_end (Marker)
 
#define VA_COPY(Dest, Start)         __builtin_va_copy (Dest, Start)
 
#endif
 
#else
typedef CHAR8 *VA_LIST;
 
#define VA_START(Marker, Parameter) (Marker = (VA_LIST) ((UINTN) & (Parameter) + _INT_SIZE_OF (Parameter)))
 
#define VA_ARG(Marker, TYPE)   (*(TYPE *) ((Marker += _INT_SIZE_OF (TYPE)) - _INT_SIZE_OF (TYPE)))
 
#define VA_END(Marker)      (Marker = (VA_LIST) 0)
 
#define VA_COPY(Dest, Start)  ((void)((Dest) = (Start)))
 
#endif
 
typedef UINTN  *BASE_LIST;
 
#define _BASE_INT_SIZE_OF(TYPE) ((sizeof (TYPE) + sizeof (UINTN) - 1) / sizeof (UINTN))
 
#define BASE_ARG(Marker, TYPE)   (*(TYPE *) ((Marker += _BASE_INT_SIZE_OF (TYPE)) - _BASE_INT_SIZE_OF (TYPE)))
 
#ifdef __GNUC__
#if __GNUC__ >= 4
#define OFFSET_OF(TYPE, Field) ((UINTN) __builtin_offsetof(TYPE, Field))
#endif
#endif
 
#ifndef OFFSET_OF
#define OFFSET_OF(TYPE, Field) ((UINTN) &(((TYPE *)0)->Field))
#endif
 
#define BASE_CR(Record, TYPE, Field)  ((TYPE *) ((CHAR8 *) (Record) - OFFSET_OF (TYPE, Field)))
 
#define ALIGN_VALUE(Value, Alignment) ((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))
 
#define ALIGN_POINTER(Pointer, Alignment) ((VOID *) (ALIGN_VALUE ((UINTN)(Pointer), (Alignment))))
 
#define ALIGN_VARIABLE(Value)  ALIGN_VALUE ((Value), sizeof (UINTN))
 
 
#define MAX(a, b)                       \
  (((a) > (b)) ? (a) : (b))
 
#define MIN(a, b)                       \
  (((a) < (b)) ? (a) : (b))
 
#define ABS(a)                          \
  (((a) < 0) ? (-(a)) : (a))
 
//
// Status codes common to all execution phases
//
typedef UINTN RETURN_STATUS;
 
#define ENCODE_ERROR(StatusCode)     ((RETURN_STATUS)(MAX_BIT | (StatusCode)))
 
#define ENCODE_WARNING(StatusCode)   ((RETURN_STATUS)(StatusCode))
 
#define RETURN_ERROR(StatusCode)     (((INTN)(RETURN_STATUS)(StatusCode)) < 0)
 
#define RETURN_SUCCESS               0
 
#define RETURN_LOAD_ERROR            ENCODE_ERROR (1)
 
#define RETURN_INVALID_PARAMETER     ENCODE_ERROR (2)
 
#define RETURN_UNSUPPORTED           ENCODE_ERROR (3)
 
#define RETURN_BAD_BUFFER_SIZE       ENCODE_ERROR (4)
 
#define RETURN_BUFFER_TOO_SMALL      ENCODE_ERROR (5)
 
#define RETURN_NOT_READY             ENCODE_ERROR (6)
 
#define RETURN_DEVICE_ERROR          ENCODE_ERROR (7)
 
#define RETURN_WRITE_PROTECTED       ENCODE_ERROR (8)
 
#define RETURN_OUT_OF_RESOURCES      ENCODE_ERROR (9)
 
#define RETURN_VOLUME_CORRUPTED      ENCODE_ERROR (10)
 
#define RETURN_VOLUME_FULL           ENCODE_ERROR (11)
 
#define RETURN_NO_MEDIA              ENCODE_ERROR (12)
 
#define RETURN_MEDIA_CHANGED         ENCODE_ERROR (13)
 
#define RETURN_NOT_FOUND             ENCODE_ERROR (14)
 
#define RETURN_ACCESS_DENIED         ENCODE_ERROR (15)
 
#define RETURN_NO_RESPONSE           ENCODE_ERROR (16)
 
#define RETURN_NO_MAPPING            ENCODE_ERROR (17)
 
#define RETURN_TIMEOUT               ENCODE_ERROR (18)
 
#define RETURN_NOT_STARTED           ENCODE_ERROR (19)
 
#define RETURN_ALREADY_STARTED       ENCODE_ERROR (20)
 
#define RETURN_ABORTED               ENCODE_ERROR (21)
 
#define RETURN_ICMP_ERROR            ENCODE_ERROR (22)
 
#define RETURN_TFTP_ERROR            ENCODE_ERROR (23)
 
#define RETURN_PROTOCOL_ERROR        ENCODE_ERROR (24)
 
#define RETURN_INCOMPATIBLE_VERSION  ENCODE_ERROR (25)
 
#define RETURN_SECURITY_VIOLATION    ENCODE_ERROR (26)
 
#define RETURN_CRC_ERROR             ENCODE_ERROR (27)
 
#define RETURN_END_OF_MEDIA          ENCODE_ERROR (28)
 
#define RETURN_END_OF_FILE           ENCODE_ERROR (31)
 
#define RETURN_INVALID_LANGUAGE      ENCODE_ERROR (32)
 
#define RETURN_COMPROMISED_DATA      ENCODE_ERROR (33)
 
#define RETURN_HTTP_ERROR            ENCODE_ERROR (35)
 
#define RETURN_WARN_UNKNOWN_GLYPH    ENCODE_WARNING (1)
 
#define RETURN_WARN_DELETE_FAILURE   ENCODE_WARNING (2)
 
#define RETURN_WARN_WRITE_FAILURE    ENCODE_WARNING (3)
 
#define RETURN_WARN_BUFFER_TOO_SMALL ENCODE_WARNING (4)
 
#define RETURN_WARN_STALE_DATA       ENCODE_WARNING (5)
 
#define RETURN_WARN_FILE_SYSTEM      ENCODE_WARNING (6)
 
 
#define SIGNATURE_16(A, B)        ((A) | (B << 8))
 
#define SIGNATURE_32(A, B, C, D)  (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))
 
#define SIGNATURE_64(A, B, C, D, E, F, G, H) \
    (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))
 
#if defined(_MSC_EXTENSIONS) && !defined (__INTEL_COMPILER) && !defined (MDE_CPU_EBC)
  void * _ReturnAddress(void);
  #pragma intrinsic(_ReturnAddress)
  #define RETURN_ADDRESS(L)     ((L == 0) ? _ReturnAddress() : (VOID *) 0)
#elif defined(__GNUC__)
  void * __builtin_return_address (unsigned int level);
  #define RETURN_ADDRESS(L)     __builtin_return_address (L)
#else
  #define RETURN_ADDRESS(L)     ((VOID *) 0)
#endif
 
#define ARRAY_SIZE(Array) (sizeof (Array) / sizeof ((Array)[0]))
 
#endif