/* * Copyright (c) 1997-2024 Ross Cunniff * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #ifndef _OADL_VAR_H_INCLUDED // [ #define _OADL_VAR_H_INCLUDED #include <stdint.h> #include <cstddef> using std::size_t; using std::ptrdiff_t; #if !defined(ASSERT) #define ASSERT(x) #endif /* Base types used by OADL */ typedef uint16_t OADL_HLF; typedef uint32_t OADL_WCH; #if defined(OADL64) // [ /* OADL 'var's are 64-bit values: */ typedef uint64_t OADL_BaseVar; typedef int64_t OADL_SignedVar; #else /* OADL 'var's are 32-bit values: */ typedef uint32_t OADL_BaseVar; typedef int32_t OADL_SignedVar; #endif // ] OADL64 /* The structure of a 64-bit OadlVar is as follows (although they * are stacked as if little-endian, that may not be the case): * * OADL_VT_DOUBLE - 63 significant bits, bit 0 is 0: * * 3 * 1 1 0 * +-+-----------------------------------------------------------+-+ * | MantLo:31 |0| * +-+-----------------------------------------------------------+-+ * +-+---------------------+---------------------------------------+ * |S| Exp:11 | MantHi:20 | * +-+---------------------+---------------------------------------+ * 6 6 5 3 * 3 2 2 2 * * OADL_VT_LONG - 62 significant bits, bit 0 is 1, bit 1 is 0: * * 3 * 1 2 1 0 * +-----------------------------------------------------------+---+ * | valueLo:30 |0 1| * +-----------------------------------------------------------+---+ * +---------------------------------------------------------------+ * | valueHi:32 | * +---------------------------------------------------------------+ * 6 3 * 3 2 * * OADL_VT_NULL - 0 significant bits, all bits are 1: * * 3 * 1 0 * +---------------------------------------------------------------+ * |1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1| * +---------------------------------------------------------------+ * +---------------------------------------------------------------+ * |1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1| * +---------------------------------------------------------------+ * 6 3 * 3 2 * * Everything else - 32 significant bits, bits 0-2 are 1 (items * shorter than 32 bits are right-justified in the value field): * * 3 * 1 8 7 2 1 0 * +-----------------------------------------------+-----------+---+ * |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0| Type:6 |1 1| * +-----------------------------------------------+-----------+---+ * +---------------------------------------------------------------+ * | value:32 | * +---------------------------------------------------------------+ * 6 3 * 3 2 * * The structure of a 32-bit OadlVar is as follows: * * OADL_VT_FLOAT - 31 significant bits, bit 0 is 0: * * 3 3 2 2 * 1 0 3 2 1 0 * +-+---------------+-------------------------------------------+-+ * |S| Exp:8 | Mantissa:22 |0| * +-+---------------+-------------------------------------------+-+ * * OADL_VT_INT - 30 significant bits, bit 0 is 1, bit 1 is 0: * * 3 * 1 2 1 0 * +-----------------------------------------------------------+---+ * | value : 30 |0 1| * +-----------------------------------------------------------+---+ * * OADL_VT_NULL - 0 significant bits, all bits are 1: * * 3 * 1 0 * +---------------------------------------------------------------+ * |1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1| * +---------------------------------------------------------------+ * * Everything else - 24 significant bits, bits 0-2 are 1 (items * shorter than 24 bits are right-justified in the value field): * * 3 * 1 8 7 2 1 0 * +-----------------------------------------------+-----------+---+ * | value : 24 | Type:6 |1 1| * +-----------------------------------------------+-----------+---+ */ /***************************************************************************** * Type enumeration ****************************************************************************/ #if defined(OADL64) #define OADL_VT_DOUBLE 0 // 63 valid bits #define OADL_VT_LONG 1 // 62 valid bits #define OADL_VT_FLOAT 2 // 32 valid bits #define OADL_VT_INT 3 // 32 valid bits #else #define OADL_VT_FLOAT 0 // 31 valid bits #define OADL_VT_INT 1 // 30 valid bits #define OADL_VT_DOUBLE 2 // 24 valid bits, atom idx #define OADL_VT_LONG 3 // 24 valid bits, atom idx #endif #define OADL_VT_ULONG 4 // 24/32 valid bits, atom idx #define OADL_VT_UINT 5 // 24/32 valid bits, atom idx iff 24 #define OADL_VT_ARRAY 6 // 24/32 valid bits #define OADL_VT_OBJECT 7 // 24/32 valid bits #define OADL_VT_ARR_TYPE 8 // 24/32 valid bits #define OADL_VT_ENCLOSURE 9 // 24/32 valid bits // Unused 24-bit 10-15 // Future 24/32-bit type slots #define OADL_VT_POINTER 16 // 24/32 valid bits, atom idx #define OADL_VT_DICT 17 // 24/32 valid bits #define OADL_VT_PROC 18 // 24/32 valid bits #define OADL_VT_EXTERN 19 // 24/32 valid bits #define OADL_VT_PUBLIC 20 // 24/32 valid bits #define OADL_VT_EXCEPT 21 // 24/32 valid bits (actually, 8) #define OADL_VT_FILE 22 // 24/32 valid bits // Unused 24-bit 23-31 // Future 24/32-bit type slots // Internal types #define OADL_VT_GLOBAL 32 // 24/32 valid bits #define OADL_VT_LOCAL 33 // 24/32 valid bits #define OADL_VT_ARG 34 // 24/32 valid bits #define OADL_VT_PROP 35 // 24/32 valid bits #define OADL_VT_INTR 36 // 24/32 valid bits #define OADL_VT_FORMAT 37 // 24/32 valid bits #define OADL_VT_PATTERN 38 // 24/32 valid bits // Unused internal 39-47 // Future 24/32-bit type slots // Inline numeric value types // Unused internal 48-53 // Future inline num. val. type slots #define OADL_VT_WCHAR 54 // 24/32 valid bits (actually, 21) #define OADL_VT_HALF 55 // 24/32 valid bits (actually, 16) #define OADL_VT_USHORT 56 // 24/32 valid bits (actually, 16) #define OADL_VT_SHORT 57 // 24/32 valid bits (actually, 16) #define OADL_VT_UBYTE 58 // 24/32 valid bits (actually, 8) #define OADL_VT_BYTE 59 // 24/32 valid bits (actually, 8) #define OADL_VT_CHAR 60 // 24/32 valid bits (actually, 7) #define OADL_VT_TYPE 61 // 24/32 valid bits (actually, 7) #define OADL_VT_BOOL 62 // 24/32 valid bits (actually, 1) #define OADL_VT_NULL 63 // 0 valid bits #define OADL_NUM_INLINE 64 // number of inline types // Pseudo-types returned by TypeOf. Always >= 64. #define OADL_MIN_PACK_TYPE 64 // First packed type #define OADL_VT_PACK_DOUBLE 64 // Array of IEEE double-precision #define OADL_VT_PACK_ULONG 65 // Array of signed 64-bit ints #define OADL_VT_PACK_LONG 66 // Array of signed 64-bit ints #define OADL_VT_PACK_FLOAT 67 // Array of IEEE single-precision #define OADL_VT_PACK_UINT 68 // Array of signed 32-bit ints #define OADL_VT_PACK_INT 69 // Array of signed 32-bit ints #define OADL_VT_PACK_WCHAR 70 // Array of 21-bit chars #define OADL_VT_PACK_HALF 71 // Array of 16-bit floats #define OADL_VT_PACK_USHORT 72 // Array of 16-bit unsigned ints #define OADL_VT_PACK_SHORT 73 // Array of 16-bit ints #define OADL_VT_PACK_UBYTE 74 // Array of unsigned 8-bit ints #define OADL_VT_PACK_BYTE 75 // Array of signed 8-bit ints #define OADL_VT_PACK_CHAR 76 // Array of 7-bit chars #define OADL_VT_PACK_BOOL 77 // Packed boolean #define OADL_VT_WIDE_STRING 78 // 1D Array of 21-bit chars #define OADL_VT_STRING 79 // 1D Array of 7-bit chars #define OADL_MAX_PACK_TYPE 79 // Last packed type #define OADL_VT_LIST 80 // 1D Array of OadlVar #define OADL_VT_CLASS 81 // A class (vs. an Object) #define OADL_VT_UNIV_ARRAY 82 // Array[*] #define OADL_NUM_TYPES 83 // number of types // Distinguish between the "inline" floating point or integer type, // and the alternate (either atomic or smaller) type #if defined(OADL64) // [ #define OADL_INL_FP OADL_VT_DOUBLE #define OADL_INL_INT OADL_VT_LONG #define OADL_ALT_FP OADL_VT_FLOAT #define OADL_ALT_INT OADL_VT_INT #define OADL_IOFFS 32 #else // ] [ #define OADL_INL_FP OADL_VT_FLOAT #define OADL_INL_INT OADL_VT_INT #define OADL_ALT_FP OADL_VT_DOUBLE #define OADL_ALT_INT OADL_VT_LONG #define OADL_IOFFS 8 #endif // ] /***************************************************************************** * Useful constants ****************************************************************************/ #if defined(OADL64) // [ /* Maximum positive signed int value we support */ #define OADL_MAX_INT 0x7FFFFFFF // 31 bits /* The maximum dynamic index value we support */ #define OADL_MAX_DYNAMIC 0xFFFFFFFFU // 32 bits /* NIL - 64 bits of type, no value. */ #define OADL_NIL_BITS ((OADL_BaseVar)0xFFFFFFFFFFFFFFFFULL) #else // ] [ /* Maximum positive signed int value we support */ #define OADL_MAX_INT 0x1FFFFFFF // 29 bits /* The maximum dynamic index value we support */ #define OADL_MAX_DYNAMIC 0x00FFFFFF // 24 bits /* NIL - 32 bits of type, no value. */ #define OADL_NIL_BITS ((OADL_BaseVar)0xFFFFFFFFU) #endif // ] OADL64 // 16-bit representation of max half precision value - same as 65504.h #define OADL_MAX_HALF (0x7B00 | 0x03FF) #define OADL_MIN_HALF (0x8000 | OADL_MAX_HALF) #define OADL_MAX_HALF_F 65504.0f /* The maximum dimensionality (rank) of an OADL array. Arrays of higher * rank can be created, but they end up as Array of Array datastructures. * For efficiency, this number must be 2**n - 1 */ #define OADL_MAX_RANK 15 /* The maximum positive signed long value we support. Note that * this is the same in 32- and 64-bit OADL - the scalar table * in 32-bit OADL truncates signed longs to this precision for * compatibility. */ #define OADL_MAX_LONG ((int64_t)0x1FFFFFFFFFFFFFFFLL) // 61 bits // Other maximum type values #define OADL_MAX_FLOAT ((float)FLT_MAX) #define OADL_MAX_DOUBLE DBL_MAX #define OADL_MAX_BOOL 1 #define OADL_MAX_BYTE 127 #define OADL_MAX_CHAR 127 #define OADL_MAX_UBYTE 255 #define OADL_MAX_SHORT 32767 #define OADL_MAX_USHORT 65535 #define OADL_MAX_WCHAR 0x1FFFFF #define OADL_MAX_UINT 0xFFFFFFFFU #define OADL_MAX_ULONG 0xFFFFFFFFFFFFFFFFULL // Predeclare various tables and procs namespace oadl { extern const uint8_t typeTable[]; extern const char *typeNames[]; extern const char *typeAbbrevs[]; extern const int typeSizes[]; extern const uint8_t isSigned[]; extern const uint8_t isNumeric[]; extern const uint8_t isIntegral[]; extern const uint8_t isAtomic[]; extern const uint8_t isDynamic[]; /************************************************************************* * Utilities for converting between half and float * From http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf * Tables are generated by TESTS/Automated/fp16tables.oad ************************************************************************/ extern uint32_t mantissatable[2048]; extern uint32_t exponenttable[64]; extern uint16_t offsettable[64]; inline const float hlfToFlt(const OADL_HLF x) { union {float f; uint32_t i;} u; u.i = mantissatable[offsettable[x>>10]+(x&0x3ff)]+exponenttable[x>>10]; return u.f; } extern uint16_t basetable[512]; extern uint8_t shifttable[512]; inline const OADL_HLF fltToHlf(const float f) { union {float f; uint32_t i;} u; u.f = f; return basetable[(u.i>>23)&0x1ff]+((u.i&0x007FFFFF)>>shifttable[(u.i>>23)&0x1ff]); } } /***************************************************************************** * The heart of OADL - the OadlVar ****************************************************************************/ class OadlVar { public : // The only data item in the class - a 32- or 64-bit thing OADL_BaseVar v; private : inline int CHECK_TYPE(int t) const { return (v & 0xFF) == ((t << 2) | 3); } public : // If no initial value, don't initialize anything OadlVar() {} // Explicitly give type and value OadlVar(int t, OADL_BaseVar val) { if (t == OADL_INL_INT) v = (val << 2) | 1; else if (t == OADL_INL_FP) v = val & ~(OADL_BaseVar) 1; else if (t == OADL_VT_NULL) v = OADL_NIL_BITS; else v = (val << OADL_IOFFS) | (t<<2) | 3; } // Copy-in operator OadlVar(OADL_BaseVar val) { v = val; } // Returns OADL_VT_* - what is this OadlVar? inline int getType() const {return oadl::typeTable[v & 0xFF];} // Type query methods #if defined(OADL64) inline int isDouble() const {return (v&1) == 0;} inline int isLong() const {return (v&3) == 1;} inline int isFloat() const {return CHECK_TYPE(OADL_VT_FLOAT);} inline int isInt() const {return CHECK_TYPE(OADL_VT_INT);} #else inline int isFloat() const {return (v&1) == 0;} inline int isInt() const {return (v&3) == 1;} inline int isDouble() const {return CHECK_TYPE(OADL_VT_DOUBLE);} inline int isLong() const {return CHECK_TYPE(OADL_VT_LONG);} #endif inline int isPointer() const {return CHECK_TYPE(OADL_VT_POINTER);} inline int isUlong() const {return CHECK_TYPE(OADL_VT_ULONG);} inline int isUint() const {return CHECK_TYPE(OADL_VT_UINT);} inline int isArray() const {return CHECK_TYPE(OADL_VT_ARRAY);} inline int isObject() const {return CHECK_TYPE(OADL_VT_OBJECT);} inline int isDict() const {return CHECK_TYPE(OADL_VT_DICT);} inline int isProc() const {return CHECK_TYPE(OADL_VT_PROC);} inline int isExtern() const {return CHECK_TYPE(OADL_VT_EXTERN);} inline int isPublic() const {return CHECK_TYPE(OADL_VT_PUBLIC);} inline int isFile() const {return CHECK_TYPE(OADL_VT_FILE);} inline int isExcept() const {return CHECK_TYPE(OADL_VT_EXCEPT);} inline int isArrType() const {return CHECK_TYPE(OADL_VT_ARR_TYPE);} inline int isWchar() const {return CHECK_TYPE(OADL_VT_WCHAR);} inline int isHalf() const {return CHECK_TYPE(OADL_VT_HALF);} inline int isUshort() const {return CHECK_TYPE(OADL_VT_USHORT);} inline int isShort() const {return CHECK_TYPE(OADL_VT_SHORT);} inline int isUbyte() const {return CHECK_TYPE(OADL_VT_UBYTE);} inline int isByte() const {return CHECK_TYPE(OADL_VT_BYTE);} inline int isChar() const {return CHECK_TYPE(OADL_VT_CHAR);} inline int isType() const {return CHECK_TYPE(OADL_VT_TYPE);} inline int isBool() const {return CHECK_TYPE(OADL_VT_BOOL);} inline int isProp() const {return CHECK_TYPE(OADL_VT_PROP);} inline int isIntr() const {return CHECK_TYPE(OADL_VT_INTR);} inline int isNull() const {return CHECK_TYPE(OADL_VT_NULL);} inline int isEnclosure() const {return CHECK_TYPE(OADL_VT_ENCLOSURE);} inline int isFormat() const {return CHECK_TYPE(OADL_VT_FORMAT);} inline int isPattern() const {return CHECK_TYPE(OADL_VT_PATTERN);} inline int isType(int t) const {return getType() == t;} /* Many of these get methods rely on the macro OADL_FIND_ATOM being * defined as the routine that can look up an index and return a pointer * to the atom it refers to. Many others rely on OADL_MAKE_ATOM being * defined as the routine that can store an atom in the heap. */ #if defined(OADL64) // [ /* Int/float/double/long/uint gets are different in 32- vs. 64-bit * implementations */ inline int getInt() const { ASSERT(isInt()); return ((OADL_SignedVar) v) >> OADL_IOFFS; } inline float getFloat() const { union {uint32_t x; float f;} u; ASSERT(isFloat()); u.x = ((OADL_BaseVar) v) >> OADL_IOFFS; return u.f; } inline double getDouble(void *ctx) const { ASSERT(isDouble()); return *(double *) &v; } inline int64_t getLong(void *ctx) const { ASSERT(isLong()); return ((int64_t) v) >> 2; } inline uint32_t getUint(void *ctx) const { ASSERT(isUint()); return (v >> OADL_IOFFS) & 0xFFFFFFFFU; } #else // ] [ inline int getInt() const { ASSERT(isInt()); return ((int) v) >> 2; } inline float getFloat() const { ASSERT(isFloat()); return *(float *) &v; } inline double getDouble(void *ctx) const { ASSERT(isDouble()); #if defined(OADL_FIND_ATOM) void *ptr = OADL_FIND_ATOM(ctx, v >> OADL_IOFFS); return *(double *)ptr; #else union {double d; uint64_t x; } u; u.x = ~(int64_t) 0; return u.d; // NaN #endif } inline int64_t getLong(void *ctx) const { ASSERT(isLong()); #if defined(OADL_FIND_ATOM) void *ptr = OADL_FIND_ATOM(ctx, v >> OADL_IOFFS); return *(int64_t *)ptr; #else return ~(uint64_t)0; #endif } inline uint32_t getUint(void *ctx) const { ASSERT(isUint()); #if defined(OADL_FIND_ATOM) void *ptr = OADL_FIND_ATOM(ctx, v >> OADL_IOFFS); return *(uint32_t *)ptr; #else return ~(uint32_t)0; #endif } #endif // ] !OADL64 inline uint64_t getUlong(void *ctx) const { ASSERT(isUlong()); #if defined(OADL_FIND_ATOM) void *ptr = OADL_FIND_ATOM(ctx, v >> OADL_IOFFS); return *(uint64_t *)ptr; #else return ~(uint64_t)0; #endif } inline void *getPointer(void *ctx) const { ASSERT(isPointer()); #if defined(OADL_FIND_ATOM) void *ptr = OADL_FIND_ATOM(ctx, v >> OADL_IOFFS); return *(void **)ptr; #else return (void *)0; #endif } inline void *getPattern(void *ctx) const { ASSERT(isPattern()); #if defined(OADL_FIND_ATOM) void *ptr = OADL_FIND_ATOM(ctx, v >> OADL_IOFFS); return *(void **)ptr; #else return (void *)0; #endif } inline float getHalf() const { ASSERT(isHalf()); return oadl::hlfToFlt(v >> OADL_IOFFS); } inline OADL_HLF getHalfBits() const { ASSERT(isHalf()); return (v >> OADL_IOFFS) & OADL_MAX_DYNAMIC; } inline OADL_WCH getWchar() const { ASSERT(isWchar()); return (v >> OADL_IOFFS) & 0x1FFFFF; } inline uint16_t getUshort() const { ASSERT(isUshort()); return (v >> OADL_IOFFS) & 0xFFFF; } inline int16_t getShort() const { ASSERT(isShort()); return (v >> OADL_IOFFS) & 0xFFFF; } inline uint8_t getUbyte() const { ASSERT(isUbyte()); return (v >> OADL_IOFFS) & 0xFF; } inline int8_t getByte() const { ASSERT(isByte()); return (v >> OADL_IOFFS) & 0xFF; } inline uint8_t getChar() const { ASSERT(isChar()); return (v >> OADL_IOFFS) & 0x7F; } inline uint8_t getBool() const { ASSERT(isBool()); return (v >> OADL_IOFFS) & 1; } inline int extractIval() { if ((v & 3) == 3) return v >> OADL_IOFFS; else if ((v & 3) == 1) return ((OADL_SignedVar)v) >> 2; else return v; } inline OADL_BaseVar getVal() const { ASSERT((v&3)==3); return (v >> OADL_IOFFS) & OADL_MAX_DYNAMIC; } inline OADL_BaseVar getVal(int typ) const { ASSERT((v&0xFF)==((typ<<2)|3)); return (v >> OADL_IOFFS) & OADL_MAX_DYNAMIC; } inline int isSigned() const { return oadl::isSigned[(v & 0xF8) >> 3] & (1 << (v & 0x7)); } inline int isNumeric() const { return oadl::isNumeric[(v & 0xF8) >> 3] & (1 << (v & 0x7)); } inline int isIntegral() const { return oadl::isIntegral[(v & 0xF8) >> 3] & (1 << (v & 0x7)); } inline int isAtomic() const { return oadl::isAtomic[(v & 0xF8) >> 3] & (1 << (v & 0x7)); } inline int isDynamic() const { return oadl::isDynamic[(v & 0xF8) >> 3] & (1 << (v & 0x7)); } inline int isNil() const { return v == OADL_NIL_BITS; } // Easily convert from OadlVar to OADL_BaseVar operator OADL_BaseVar() const { return v; } // Equivalence operators int operator == (OadlVar const rhs) { return v == rhs.v; } int operator != (OadlVar const rhs) { return v != rhs.v; } template <class typ> inline int getNumeric(void *ctx, typ *res, int idx = 1) const { switch (getType()) { case OADL_VT_INT : *res = (typ) getInt(); return 1; case OADL_VT_USHORT : *res = (typ) getUshort(); return 1; case OADL_VT_SHORT : *res = (typ) getShort(); return 1; case OADL_VT_UBYTE : *res = (typ) getUbyte(); return 1; case OADL_VT_BYTE : *res = (typ) getByte(); return 1; case OADL_VT_HALF : *res = (typ) getHalf(); return 1; case OADL_VT_FLOAT : *res = (typ) getFloat(); return 1; case OADL_VT_BOOL : *res = (typ) getBool(); return idx; case OADL_VT_CHAR : *res = (typ) getChar(); return idx; case OADL_VT_WCHAR : *res = (typ) getWchar(); return idx; case OADL_VT_ULONG : *res = (typ) getUlong(ctx); return 1; case OADL_VT_LONG : *res = (typ) getLong(ctx); return 1; case OADL_VT_UINT : *res = (typ) getUint(ctx); return 1; case OADL_VT_DOUBLE : *res = (typ) getDouble(ctx); return 1; default : return 0; } } }; /* Various convenience subclasses for OADLtypes that don't easily fit * in the initializer scheme of OadlVar. Note again the difference * between 32- and 64-bit in Int/Float/Double/Long/Uint */ #if defined(OADL64) // [ class OadlInt : public OadlVar { public : OadlInt(int i) { v = ((OADL_BaseVar)i << OADL_IOFFS) | (OADL_VT_INT << 2) | 3; } }; class OadlFloat : public OadlVar { public : OadlFloat(float f) { union {float f; uint32_t x;} u; u.f = f; v = ((OADL_BaseVar)u.x << OADL_IOFFS) | (OADL_VT_FLOAT << 2) | 3; } }; class OadlLong : public OadlVar { public : OadlLong(void *ctx, int64_t i) { v = (i << 2) | 1; } }; class OadlDouble : public OadlVar { public : OadlDouble(void *ctx, double d) { v = (*(uint64_t *) &d) & ~1; } }; class OadlUint : public OadlVar { public : OadlUint(void *ctx, uint32_t i) { v = (((OADL_BaseVar) i) << OADL_IOFFS) | (OADL_VT_UINT << 2) | 3; } }; #else // ] [ class OadlInt : public OadlVar { public : OadlInt(int i) { v = (i << 2) | 1; } }; class OadlFloat : public OadlVar { public : OadlFloat(float f) { v = (*(uint32_t *) &f) & ~1; } }; class OadlLong : public OadlVar { public : OadlLong(void *ctx, int64_t l) { #if defined(OADL_MAKE_ATOM) OADL_BaseVar i = OADL_MAKE_ATOM(ctx, OADL_VT_LONG, (void *)&l); v = (i << OADL_IOFFS) | (OADL_VT_LONG << 2) | 3; #else v = OADL_NIL_BITS; #endif } }; class OadlDouble : public OadlVar { public : OadlDouble(void *ctx, double d) { #if defined(OADL_MAKE_ATOM) OADL_BaseVar i = OADL_MAKE_ATOM(ctx, OADL_VT_DOUBLE, (void *)&d); v = (i << OADL_IOFFS) | (OADL_VT_DOUBLE << 2) | 3; #else v = OADL_NIL_BITS; #endif } }; class OadlUint : public OadlVar { public : OadlUint(void *ctx, uint32_t i) { #if defined(OADL_MAKE_ATOM) OADL_BaseVar a = OADL_MAKE_ATOM(ctx, OADL_VT_UINT, (void *)&i); v = (a << OADL_IOFFS) | (OADL_VT_UINT << 2) | 3; #else v = OADL_NIL_BITS; #endif } }; #endif // ] !OADL64 class OadlWchar : public OadlVar { public : OadlWchar(OADL_BaseVar x) { v = ((x & 0x001FFFFF) << OADL_IOFFS) | (OADL_VT_WCHAR << 2) | 3; } }; class OadlShort : public OadlVar { public : OadlShort(OADL_BaseVar x) { v = ((x & 0x0000FFFF) << OADL_IOFFS) | (OADL_VT_SHORT << 2) | 3; } }; class OadlUshort : public OadlVar { public : OadlUshort(OADL_BaseVar x) { v = ((x & 0x0000FFFF) << OADL_IOFFS) | (OADL_VT_USHORT << 2) | 3; } }; class OadlUbyte : public OadlVar { public : OadlUbyte(OADL_BaseVar x) { v = ((x & 0x000000FF) << OADL_IOFFS) | (OADL_VT_UBYTE << 2) | 3; } }; class OadlByte : public OadlVar { public : OadlByte(OADL_BaseVar x) { v = ((x & 0x000000FF) << OADL_IOFFS) | (OADL_VT_BYTE << 2) | 3; } }; class OadlChar : public OadlVar { public : OadlChar(OADL_BaseVar x) { v = ((x & 0x0000007F) << OADL_IOFFS) | (OADL_VT_CHAR << 2) | 3; } }; class OadlBool : public OadlVar { public : OadlBool (OADL_BaseVar x) { v = ((x & 0x00000001) << OADL_IOFFS) | (OADL_VT_BOOL << 2) | 3; } }; class OadlHalf : public OadlVar { public : OadlHalf(float f) { OADL_BaseVar h = oadl::fltToHlf(f); v = (h << OADL_IOFFS) | (OADL_VT_HALF << 2) | 3; } }; class OadlArray : public OadlVar { public : OadlArray(OADL_BaseVar x) { v = (x << OADL_IOFFS) | (OADL_VT_ARRAY << 2) | 3; } }; class OadlObject : public OadlVar { public : OadlObject(OADL_BaseVar x) { v = (x << OADL_IOFFS) | (OADL_VT_OBJECT << 2) | 3; } }; class OadlDict : public OadlVar { public : OadlDict(OADL_BaseVar x) { v = (x << OADL_IOFFS) | (OADL_VT_DICT << 2) | 3; } }; class OadlPointer : public OadlVar { public : OadlPointer(void *ctx, void *ptr) { #if defined(OADL_MAKE_ATOM) OADL_BaseVar i = OADL_MAKE_ATOM(ctx, OADL_VT_POINTER, (void *)&ptr); v = (i << OADL_IOFFS) | (OADL_VT_POINTER << 2) | 3; #else v = OADL_NIL_BITS; #endif } }; class OadlPattern : public OadlVar { public : OadlPattern(void *ctx, void *ptr) { #if defined(OADL_MAKE_ATOM) OADL_BaseVar i = OADL_MAKE_ATOM(ctx, OADL_VT_PATTERN, (void *)&ptr); v = (i << OADL_IOFFS) | (OADL_VT_PATTERN << 2) | 3; #else v = OADL_NIL_BITS; #endif } }; class OadlUlong : public OadlVar { public : OadlUlong(void *ctx, uint64_t ul) { #if defined(OADL_MAKE_ATOM) OADL_BaseVar i = OADL_MAKE_ATOM(ctx, OADL_VT_ULONG, (void *)&ul); v = (i << OADL_IOFFS) | (OADL_VT_ULONG << 2) | 3; #else v = OADL_NIL_BITS; #endif } }; namespace oadl { static inline int typeIsSigned(unsigned t) { if ((t == OADL_INL_FP) || (t == OADL_INL_INT)) return 1; if (t >= OADL_NUM_INLINE) return 0; OadlVar v = OadlVar(t,0); return v.isSigned(); } static inline int typeIsNumeric(unsigned t) { if ((t == OADL_INL_FP) || (t == OADL_INL_INT)) return 1; if (t >= OADL_NUM_INLINE) return 0; OadlVar v = OadlVar(t,0); return v.isNumeric(); } static inline int typeIsIntegral(unsigned t) { if (t == OADL_INL_INT) return 1; if (t >= OADL_NUM_INLINE) return 0; OadlVar v = OadlVar(t,0); return v.isIntegral(); } static inline int typeIsAtomic(unsigned t) { if ((t == OADL_INL_FP) || (t == OADL_INL_INT)) return 0; if (t >= OADL_NUM_INLINE) return 0; OadlVar v = OadlVar(t,0); return v.isAtomic(); } } /* Standard constants, heavily used everywhere */ static const OadlVar OADL_NIL = OadlVar(OADL_NIL_BITS); static const OadlVar OADL_TRUE = OadlVar(OADL_VT_BOOL, 1); static const OadlVar OADL_FALSE = OadlVar(OADL_VT_BOOL, 0); /****************************************************************************** * Convenience arrays: * 1. Mapping the least-significant bits of an OadlVar to a type * 2. table of packed array sizes for each type (or 0 if none) * 3. Map a type to a character string * 4. Map a type to an abbreviated character string * 5. table of whether a variable is numeric * 6. table of whether a variable is integral * 7. table of whether a variable is atomic * 8. table of whether a variable is dynamic *****************************************************************************/ #if defined(OADL_DEFINE_TYPE_TABLE) // [ namespace oadl { const uint8_t typeTable[256] = { // Double-long-float-int only range OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 000000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 000001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_ALT_FP, // 000010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_ALT_INT, // 000011 xx // 24/32-bit value range (type number of 4 to 15) OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_ULONG, // 000100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_UINT, // 000101 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_ARRAY, // 000110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_OBJECT, // 000111 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_ARR_TYPE,// 001000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_ENCLOSURE,//001001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 001010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 001011 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 001100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 001101 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 001110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 001111 xx // More 24/32-bit types (non-promotable) OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_POINTER, // 010000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_DICT, // 010001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_PROC, // 010010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_EXTERN, // 010011 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_PUBLIC, // 010100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_EXCEPT, // 010101 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_FILE, // 010110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 010111 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011011 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011101 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 011111 xx // Internal types (type number of 32 to 36) OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_GLOBAL, // 100000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_LOCAL, // 100001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_ARG, // 100010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_PROP, // 100011 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_INTR, // 100100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_FORMAT, // 100101 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_PATTERN, // 100110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 100111 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101011 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101101 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 101111 xx // Possible inline numeric types OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 110000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 110001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 110010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 110011 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 110100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 110101 xx // Shorter types (type number of 54 to 63) OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_WCHAR, // 110110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_HALF, // 110111 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_USHORT, // 111000 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_SHORT, // 111001 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_UBYTE, // 111010 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_BYTE, // 111011 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_CHAR, // 111100 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_TYPE, // 111101 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_BOOL, // 111110 xx OADL_INL_FP, OADL_INL_INT, OADL_INL_FP, OADL_VT_NULL, // 111111 xx }; /* Packed array type sizes */ const int typeSizes[] = { #if defined(OADL64) 8, /* DOUBLE */ 8, /* LONG */ 4, /* FLOAT */ 4, /* INT */ #else 4, /* FLOAT */ 4, /* INT */ 8, /* DOUBLE */ 8, /* LONG */ #endif 8, /* ULONG */ 4, /* UINT */ sizeof(OadlVar), 0, /* OBJECT */ 0, /* ARR_TYPE */0, /* ENCL */ 0, /* 10 */ 0, /* 11 */ 0, /* 12 */ 0, /* 13 */ 0, /* 14 */ 0, /* 15 */ 0, /* POINTER */ 0, /* DICT */ 0, /* PROC */ 0, /* EXTERN */ 0, /* PUBLIC */ 0, /* EXCEPT */ 0, /* FILE */ 0, /* 23 */ 0, /* 24 */ 0, /* 25 */ 0, /* 26 */ 0, /* 27 */ 0, /* 28 */ 0, /* 29 */ 0, /* 30 */ 0, /* 31 */ 0, /* GLOBAL */ 0, /* LOCAL */ 0, /* ARG */ 0, /* PROP */ 0, /* INTRINSIC*/0, /* FORMAT */ 0, /* PATTERN */ 0, /* 39 */ 0, /* 40 */ 0, /* 41 */ 0, /* 42 */ 0, /* 43 */ 0, /* 44 */ 0, /* 45 */ 0, /* 46 */ 0, /* 47 */ 0, /* 48 */ 0, /* 49 */ 0, /* 50 */ 0, /* 51 */ 0, /* 52 */ 0, /* 53 */ 4, /* WCHAR */ 2, /* HALF */ 2, /* USHORT */ 2, /* SHORT */ 1, /* UBYTE */ 1, /* BYTE */ 1, /* CHAR */ 0, /* TYPE */ 1, /* BOOL */ 0, /* NULL */ }; const char *typeNames[] = { #if defined(OADL64) // [ "Double", "Long", "Float", "Int", // 0 #else "Float", "Int", "Double", "Long", // 0 #endif // ] "Ulong", "Uint", "Array", "Object", // 4 "ArrayType", "Enclosure", 0, 0, // 8 0, 0, 0, 0, // 12 "Pointer", "Dict", "Proc", "Extern", // 16 "Public", "Exception", "File", 0, // 20 0, 0, 0, 0, // 24 0, 0, 0, 0, // 28 "Global", "Local", "Arg", "Prop", // 32 "Intrinsic", "Format", "Pattern", 0, // 36 0, 0, 0, 0, // 40 0, 0, 0, 0, // 44 0, 0, 0, 0, // 48 0, 0, "WideChar", "Half", // 52 "Ushort", "Short", "Ubyte", "Byte", // 54 "Char", "Type", "Bool", "Null", // 58 "PackDouble","PackUlong", "PackLong", "PackFloat", // 64 "PackUint", "PackInt", "PackWideChar", "PackHalf", // 68 "PackUshort","PackShort", "PackUbyte", "PackByte", // 72 "PackChar", "PackBool", "WideString", "String", // 76 "List", "Class", "Array[*]" // 80 }; const char *typeAbbrevs[] = { #if defined(OADL64) // [ "DBL", "I64", "FLT", "INT", // 0 #else "FLT", "INT", "DBL", "I64", // 0 #endif // ] "U64", "U32", "ARR", "#OBJ", // 4 "ATY", "ENC", 0, 0, // 8 0, 0, 0, 0, // 12 "#PTR", "DCT", "#PRC", "EXT", // 16 "PUB", "XCP", "FIL", 0, // 20 0, 0, 0, 0, // 24 0, 0, 0, 0, // 28 "GLB", "LCL", "ARG", "PRP", // 32 "NTR", "FMT", "PAT", 0, // 36 0, 0, 0, 0, // 40 0, 0, 0, 0, // 44 0, 0, 0, 0, // 48 0, 0, "WCH", "F16", // 52 "U16", "I16", "UI8", "BYT", // 56 "CHR", "TYP", "BOO", "NUL", // 60 }; const uint8_t isSigned[32] = { 0x77, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0xFF, // 00001 xxx : F,I,F, F32/F64, F,I,F, I32/I64 2 0x77, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x77, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x77, // 00100 xxx : F,I,F, ATY, F,I,F, ill 8 0x77, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x77, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 14 0x77, // 01001 xxx : F,I,F, PTR, F,I,F, DCT 16 0x77, // 01001 xxx : F,I,F, PRC, F,I,F, EXT 18 0x77, // 01001 xxx : F,I,F, PUB, F,I,F, XCP 20 0x77, // 01001 xxx : F,I,F, FIL, F,I,F, ill 22 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 24 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 26 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 28 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 30 0x77, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x77, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x77, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x77, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0xF7, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0xF7, // 01100 xxx : F,I,F, U16, F,I,F, I16 56 0xF7, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x77, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x77, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; const uint8_t isNumeric[32] = { 0x77, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0xFF, // 00001 xxx : F,I,F, F32/F64, F,I,F, I32/I64 2 0xFF, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x77, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x77, // 00100 xxx : F,I,F, ATY, F,I,F, ill 8 0x77, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x77, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 14 0x77, // 01001 xxx : F,I,F, PTR, F,I,F, DCT 16 0x77, // 01001 xxx : F,I,F, PRC, F,I,F, EXT 18 0x77, // 01001 xxx : F,I,F, PUB, F,I,F, XCP 20 0x77, // 01001 xxx : F,I,F, FIL, F,I,F, ill 22 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 24 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 26 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 28 0x77, // 01001 xxx : F,I,F, ill, F,I,F, ill 30 0x77, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x77, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x77, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x77, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x77, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0xFF, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0xFF, // 01100 xxx : F,I,F, U16, F,I,F, I16 56 0xFF, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x7F, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x77, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; #if defined(OADL64) // [ /* Note that U32 is not integral because generally we cannot * extract it in one step */ const uint8_t isIntegral[32] = { 0x00, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0x80, // 00001 xxx : F,I,F, F32/F64, F,I,F, I32/I64 2 0x00, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x00, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x00, // 00100 xxx : F,I,F, ATY, F,I,F, ill 8 0x00, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x00, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 14 0x00, // 01010 xxx : F,I,F, PTR, F,I,F, DCT 16 0x00, // 01010 xxx : F,I,F, PRC, F,I,F, EXT 18 0x00, // 01010 xxx : F,I,F, PUB, F,I,F, XCP 20 0x00, // 01010 xxx : F,I,F, FIL, F,I,F, ill 22 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 24 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 26 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 28 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 30 0x00, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x00, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x00, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x00, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0x08, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0x88, // 01100 xxx : F,I,F, U16, F,I,F, I16 56 0x88, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x08, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x00, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; #else // ] [ /* Note that U32 is not integral because generally we cannot * extract it in one step */ const uint8_t isIntegral[32] = { 0x22, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0x22, // 00001 xxx : F,I,F, F32/F64, F,I,F, I32/I64 2 0x22, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x22, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x22, // 00100 xxx : F,I,F, ATY, F,I,F, ill 8 0x22, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x22, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 14 0x22, // 01010 xxx : F,I,F, PTR, F,I,F, DCT 16 0x22, // 01010 xxx : F,I,F, PRC, F,I,F, EXT 18 0x22, // 01010 xxx : F,I,F, PUB, F,I,F, XCP 20 0x22, // 01010 xxx : F,I,F, FIL, F,I,F, ill 22 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 24 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 26 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 28 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 30 0x22, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x22, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x22, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x22, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x22, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0x2A, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0xAA, // 01100 xxx : F,I,F, U16, F,I,F, I16 56 0xAA, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x2A, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x22, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; #endif // ] #if defined(OADL64) // [ const uint8_t isAtomic[32] = { 0x00, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0x00, // 00001 xxx : F,I,F, F32, F,I,F, I32 2 0x08, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x00, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x00, // 00100 xxx : F,I,F, ATY, F,I,F, ill 8 0x00, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x00, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 14 0x08, // 01010 xxx : F,I,F, PTR, F,I,F, DCT 16 0x00, // 01010 xxx : F,I,F, PRC, F,I,F, EXT 18 0x00, // 01010 xxx : F,I,F, PUB, F,I,F, XCP 20 0x00, // 01010 xxx : F,I,F, FIL, F,I,F, ill 22 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 24 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 26 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 28 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 30 0x00, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x00, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x00, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x08, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0x00, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0x00, // 01100 xxx : F,I,F, U16, F,I,F, I16 56 0x00, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x00, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x00, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; #else // ] [ const uint8_t isAtomic[32] = { 0x00, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0x88, // 00001 xxx : F,I,F, F64, F,I,F, I64 2 0x88, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x00, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x00, // 00100 xxx : F,I,F, ATY, F,I,F, ill 8 0x00, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x00, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 14 0x08, // 01010 xxx : F,I,F, PTR, F,I,F, DCT 16 0x00, // 01010 xxx : F,I,F, PRC, F,I,F, EXT 18 0x00, // 01010 xxx : F,I,F, PUB, F,I,F, XCP 20 0x00, // 01010 xxx : F,I,F, FIL, F,I,F, ill 22 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 24 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 26 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 28 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 30 0x00, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x00, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x00, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x08, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0x00, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0x00, // 01100 xxx : F,I,F, U16, F,I,F, I16 54 0x00, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x00, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x00, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; #endif // ] #if defined(OADL64) // [ const uint8_t isDynamic[32] = { 0x00, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0x00, // 00001 xxx : F,I,F, F32, F,I,F, I32 2 0x08, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x88, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x88, // 00100 xxx : F,I,F, ATY, F,I,F, ENC 8 0x00, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x00, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 14 0x88, // 01010 xxx : F,I,F, PTR, F,I,F, DCT 16 0x00, // 01010 xxx : F,I,F, PRC, F,I,F, EXT 18 0x00, // 01010 xxx : F,I,F, PUB, F,I,F, XCP 20 0x00, // 01010 xxx : F,I,F, FIL, F,I,F, ill 22 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 24 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 26 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 28 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 30 0x00, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x00, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x80, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x08, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0x00, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0x00, // 01100 xxx : F,I,F, U16, F,I,F, I16 56 0x00, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x00, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x00, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; #else // ] [ const uint8_t isDynamic[32] = { 0x00, // 00000 xxx : F,I,F, ill, F,I,F, ill 0 0x88, // 00001 xxx : F,I,F, F64, F,I,F, I64 2 0x88, // 00010 xxx : F,I,F, U64, F,I,F, U32 4 0x88, // 00011 xxx : F,I,F, ARR, F,I,F, OBJ 6 0x88, // 00100 xxx : F,I,F, ATY, F,I,F, ENC 8 0x00, // 00101 xxx : F,I,F, ill, F,I,F, ill 10 0x00, // 00110 xxx : F,I,F, ill, F,I,F, ill 12 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 14 0x88, // 01010 xxx : F,I,F, PTR, F,I,F, DCT 16 0x00, // 01010 xxx : F,I,F, PRC, F,I,F, EXT 18 0x00, // 01010 xxx : F,I,F, PUB, F,I,F, XCP 20 0x00, // 01010 xxx : F,I,F, FIL, F,I,F, ill 22 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 24 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 26 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 28 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 30 0x00, // 00111 xxx : F,I,F, GLB, F,I,F, LCL 32 0x00, // 01000 xxx : F,I,F, ARG, F,I,F, PRP 34 0x80, // 01001 xxx : F,I,F, NTR, F,I,F, FMT 36 0x08, // 01010 xxx : F,I,F, PAT, F,I,F, ill 38 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 40 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 42 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 44 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 46 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 48 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 50 0x00, // 01010 xxx : F,I,F, ill, F,I,F, ill 52 0x00, // 01011 xxx : F,I,F, WCH, F,I,F, F16 54 0x00, // 01100 xxx : F,I,F, U16, F,I,F, I16 54 0x00, // 01101 xxx : F,I,F, UI8, F,I,F, SI8 58 0x00, // 01110 xxx : F,I,F, CHR, F,I,F, TYP 60 0x00, // 01111 xxx : F,I,F, BIT, F,I,F, NUL 62 }; #endif // ] } // namespace oadl #endif // ] OADL_DEFINE_TYPE_TABLE #endif // ] _OADL_VAR_H_INCLUDED