1 /*---------------------------------------------------------------------------------------- 2 Module header file for: ut module 3 ----------------------------------------------------------------------------------------*/ 4 #ifndef UTDATABASE_H 5 6 #define UTDATABASE_H 7 8 #if defined __cplusplus 9 extern "C" { 10 #endif 11 12 #ifndef DD_UTIL_H 13 #include "ddutil.h" 14 #endif 15 16 /* Class reference definitions */ 17 18 #if defined(DD_DEBUG) && !defined(DD_NOSTRICT) 19 typedef struct _struct_utSymtab{char val;} *utSymtab; 20 #define utSymtabNull ((utSymtab)(UINT32_MAX)) 21 #define utSymtab2Index(Symtab) ((uint32)((Symtab) - (utSymtab)(0))) 22 #define utSymtab2ValidIndex(Symtab) ((uint32)(utValidSymtab(Symtab) - (utSymtab)(0))) 23 #define utIndex2Symtab(xSymtab) ((utSymtab)((xSymtab) + (utSymtab)(0))) 24 typedef struct _struct_utSym{char val;} *utSym; 25 #define utSymNull ((utSym)(UINT32_MAX)) 26 #define utSym2Index(Sym) ((uint32)((Sym) - (utSym)(0))) 27 #define utSym2ValidIndex(Sym) ((uint32)(utValidSym(Sym) - (utSym)(0))) 28 #define utIndex2Sym(xSym) ((utSym)((xSym) + (utSym)(0))) 29 typedef struct _struct_utDynarray{char val;} *utDynarray; 30 #define utDynarrayNull ((utDynarray)(UINT32_MAX)) 31 #define utDynarray2Index(Dynarray) ((uint32)((Dynarray) - (utDynarray)(0))) 32 #define utDynarray2ValidIndex(Dynarray) ((uint32)(utValidDynarray(Dynarray) - (utDynarray)(0))) 33 #define utIndex2Dynarray(xDynarray) ((utDynarray)((xDynarray) + (utDynarray)(0))) 34 typedef struct _struct_utSymArray{char val;} *utSymArray; 35 #define utSymArrayNull ((utSymArray)(UINT32_MAX)) 36 #define utSymArray2Index(SymArray) ((uint32)((SymArray) - (utSymArray)(0))) 37 #define utSymArray2ValidIndex(SymArray) ((uint32)(utValidSymArray(SymArray) - (utSymArray)(0))) 38 #define utIndex2SymArray(xSymArray) ((utSymArray)((xSymArray) + (utSymArray)(0))) 39 #else 40 typedef uint32 utSymtab; 41 #define utSymtabNull UINT32_MAX 42 #define utSymtab2Index(Symtab) (Symtab) 43 #define utSymtab2ValidIndex(Symtab) (utValidSymtab(Symtab)) 44 #define utIndex2Symtab(xSymtab) ((xSymtab)) 45 typedef uint32 utSym; 46 #define utSymNull UINT32_MAX 47 #define utSym2Index(Sym) (Sym) 48 #define utSym2ValidIndex(Sym) (utValidSym(Sym)) 49 #define utIndex2Sym(xSym) ((xSym)) 50 typedef uint32 utDynarray; 51 #define utDynarrayNull UINT32_MAX 52 #define utDynarray2Index(Dynarray) (Dynarray) 53 #define utDynarray2ValidIndex(Dynarray) (utValidDynarray(Dynarray)) 54 #define utIndex2Dynarray(xDynarray) ((xDynarray)) 55 typedef uint32 utSymArray; 56 #define utSymArrayNull UINT32_MAX 57 #define utSymArray2Index(SymArray) (SymArray) 58 #define utSymArray2ValidIndex(SymArray) (utValidSymArray(SymArray)) 59 #define utIndex2SymArray(xSymArray) ((xSymArray)) 60 #endif 61 62 /* FieldType enumerated type */ 63 typedef enum { 64 UT_BIT = 0, 65 UT_BOOL = 1, 66 UT_INT = 2, 67 UT_UINT = 3, 68 UT_CHAR = 4, 69 UT_FLOAT = 5, 70 UT_DOUBLE = 6, 71 UT_POINTER = 7, 72 UT_TYPEDEF = 8, 73 UT_ENUM = 9, 74 UT_SYM = 10, 75 UT_UNION = 11 76 } utFieldType; 77 78 /* Validate macros */ 79 #if defined(DD_DEBUG) 80 #define utValidSymtab(Symtab) (utLikely((uint32)((Symtab) - (utSymtab)0) < \ 81 utRootData.usedSymtab)? (Symtab) : (utExit("Invalid Symtab"), (utSymtab)0)) 82 #define utValidSym(Sym) (utLikely((uint32)((Sym) - (utSym)0) < \ 83 utRootData.usedSym)? (Sym) : (utExit("Invalid Sym"), (utSym)0)) 84 #define utValidDynarray(Dynarray) (utLikely((uint32)((Dynarray) - (utDynarray)0) < \ 85 utRootData.usedDynarray)? (Dynarray) : (utExit("Invalid Dynarray"), (utDynarray)0)) 86 #define utValidSymArray(SymArray) (utLikely((uint32)((SymArray) - (utSymArray)0) < \ 87 utRootData.usedSymArray)? (SymArray) : (utExit("Invalid SymArray"), (utSymArray)0)) 88 #else 89 #define utValidSymtab(Symtab) (Symtab) 90 #define utValidSym(Sym) (Sym) 91 #define utValidDynarray(Dynarray) (Dynarray) 92 #define utValidSymArray(SymArray) (SymArray) 93 #endif 94 95 /*---------------------------------------------------------------------------------------- 96 Fields for class Symtab. 97 ----------------------------------------------------------------------------------------*/ 98 struct utSymtabFields { 99 uint32 *TableIndex; 100 uint32 *NumTable; 101 utSym *Table; 102 uint32 *NumSym; 103 }; 104 extern struct utSymtabFields utSymtabs; 105 106 #define utSymtabGetTableIndex(_Symtab) (utSymtabs.TableIndex[utSymtab2ValidIndex(_Symtab)]) 107 #define utSymtabSetTableIndex(_Symtab, value) ( \ 108 (void)utRecordField(utModuleID, 0, utSymtab2ValidIndex(_Symtab), true), \ 109 (utSymtabs.TableIndex)[utSymtab2ValidIndex(_Symtab)] = (value), \ 110 (void)utRecordField(utModuleID, 0, utSymtab2ValidIndex(_Symtab), false)) 111 #define utSymtabGetNumTable(_Symtab) (utSymtabs.NumTable[utSymtab2ValidIndex(_Symtab)]) 112 #define utSymtabSetNumTable(_Symtab, value) ( \ 113 (void)utRecordField(utModuleID, 1, utSymtab2ValidIndex(_Symtab), true), \ 114 (utSymtabs.NumTable)[utSymtab2ValidIndex(_Symtab)] = (value), \ 115 (void)utRecordField(utModuleID, 1, utSymtab2ValidIndex(_Symtab), false)) 116 #if defined(DD_DEBUG) 117 #define utSymtabCheckTableIndex(Symtab, x) ((uint32)(x) < utSymtabGetNumTable(Symtab)? (x) : \ 118 (utAssert(false),(x))) 119 #else 120 #define utSymtabCheckTableIndex(Symtab, x) (x) 121 #endif 122 #define utSymtabGetiTable(_Symtab, x) ((utSymtabs.Table)[ \ 123 utSymtabGetTableIndex(_Symtab) + utSymtabCheckTableIndex(_Symtab, (x))]) 124 #define utSymtabGetTable(Symtab) (utSymtabs.Table + utSymtabGetTableIndex(Symtab)) 125 #define utSymtabGetTables utSymtabGetTable 126 #define utSymtabSetTable(Symtab, valuePtr, numTable) (utSymtabResizeTables(Symtab, numTable), \ 127 (void)utRecordArray(utModuleID, 2, utSymtabGetTableIndex(Symtab), utSymtabGetNumTable(Symtab), true), \ 128 memcpy(utSymtabGetTables(Symtab), valuePtr, \ 129 numTable*sizeof(utSym)), \ 130 (void)utRecordArray(utModuleID, 2, utSymtabGetTableIndex(Symtab), utSymtabGetNumTable(Symtab), false)) 131 #define utSymtabSetiTable(Symtab, x, value) ( \ 132 (void)utRecordField(utModuleID, 2, utSymtabGetTableIndex(Symtab) + (x), true), \ 133 (utSymtabs.Table)[ \ 134 utSymtabGetTableIndex(Symtab) + utSymtabCheckTableIndex(Symtab, (x))] = (value), \ 135 (void)utRecordField(utModuleID, 2, utSymtabGetTableIndex(Symtab) + (x), false)) 136 #define utSymtabGetNumSym(_Symtab) (utSymtabs.NumSym[utSymtab2ValidIndex(_Symtab)]) 137 #define utSymtabSetNumSym(_Symtab, value) ( \ 138 (void)utRecordField(utModuleID, 3, utSymtab2ValidIndex(_Symtab), true), \ 139 (utSymtabs.NumSym)[utSymtab2ValidIndex(_Symtab)] = (value), \ 140 (void)utRecordField(utModuleID, 3, utSymtab2ValidIndex(_Symtab), false)) 141 #define utSymtabSetConstructorCallback(func) (utSymtabConstructorCallback = (func)) 142 #define utSymtabGetConstructorCallback() (utSymtabConstructorCallback) 143 #define utFirstSymtab() (utRootData.usedSymtab == 0? utSymtabNull : utIndex2Symtab(0)) 144 #define utLastSymtab() (utRootData.usedSymtab == 0? utSymtabNull : \ 145 utIndex2Symtab(utRootData.usedSymtab - 1)) 146 #define utNextSymtab(Symtab) (utSymtab2ValidIndex(Symtab) + 1 == utRootData.usedSymtab? utSymtabNull : \ 147 (Symtab) + 1) 148 #define utPrevSymtab(Symtab) (utSymtab2ValidIndex(Symtab) == 0? utSymtabNull : (Symtab) - 1) 149 #define utForeachSymtab(var) \ 150 for(var = utIndex2Symtab(0); utSymtab2Index(var) != utRootData.usedSymtab; var++) 151 #define utEndSymtab 152 #define utSymtabFreeAll() (utSetUsedSymtab(0), utSetUsedSymtabTable(0)) 153 #define utSymtabAllocRaw() ( \ 154 utRootData.usedSymtab == utRootData.allocatedSymtab && (utSymtabAllocMore(), true), \ 155 utTemp_.Symtab = utIndex2Symtab(utRootData.usedSymtab), \ 156 utSetUsedSymtab(utUsedSymtab() + 1), \ 157 utTemp_.Symtab) 158 #define utSymtabAlloc() ( \ 159 utRootData.usedSymtab == utRootData.allocatedSymtab && (utSymtabAllocMore(), true), \ 160 utTemp_.Symtab = utIndex2Symtab(utRootData.usedSymtab), \ 161 utSetUsedSymtab(utUsedSymtab() + 1), \ 162 utSymtabSetTableIndex(utTemp_.Symtab, 0), \ 163 utSymtabSetNumTable(utTemp_.Symtab, 0), \ 164 utSymtabSetNumTable(utTemp_.Symtab, 0), \ 165 utSymtabSetNumSym(utTemp_.Symtab, 0), \ 166 utSymtabConstructorCallback != NULL && (utSymtabConstructorCallback(utTemp_.Symtab), true), \ 167 utTemp_.Symtab) 168 169 void utSymtabAllocMore(void); 170 void utSymtabCopyProps(utSymtab utOldSymtab, utSymtab utNewSymtab); 171 void utSymtabAllocTables(utSymtab Symtab, uint32 numTables); 172 void utSymtabResizeTables(utSymtab Symtab, uint32 numTables); 173 void utSymtabFreeTables(utSymtab Symtab); 174 void utCompactSymtabTables(void); 175 176 /*---------------------------------------------------------------------------------------- 177 Fields for class Sym. 178 ----------------------------------------------------------------------------------------*/ 179 struct utSymFields { 180 uint32 *NameIndex; 181 uint32 *NumName; 182 char *Name; 183 uint32 *HashValue; 184 utSym *Next; 185 }; 186 extern struct utSymFields utSyms; 187 188 #define utSymGetNameIndex(_Sym) (utSyms.NameIndex[utSym2ValidIndex(_Sym)]) 189 #define utSymSetNameIndex(_Sym, value) ( \ 190 (void)utRecordField(utModuleID, 4, utSym2ValidIndex(_Sym), true), \ 191 (utSyms.NameIndex)[utSym2ValidIndex(_Sym)] = (value), \ 192 (void)utRecordField(utModuleID, 4, utSym2ValidIndex(_Sym), false)) 193 #define utSymGetNumName(_Sym) (utSyms.NumName[utSym2ValidIndex(_Sym)]) 194 #define utSymSetNumName(_Sym, value) ( \ 195 (void)utRecordField(utModuleID, 5, utSym2ValidIndex(_Sym), true), \ 196 (utSyms.NumName)[utSym2ValidIndex(_Sym)] = (value), \ 197 (void)utRecordField(utModuleID, 5, utSym2ValidIndex(_Sym), false)) 198 #if defined(DD_DEBUG) 199 #define utSymCheckNameIndex(Sym, x) ((uint32)(x) < utSymGetNumName(Sym)? (x) : \ 200 (utAssert(false),(x))) 201 #else 202 #define utSymCheckNameIndex(Sym, x) (x) 203 #endif 204 #define utSymGetiName(_Sym, x) ((utSyms.Name)[ \ 205 utSymGetNameIndex(_Sym) + utSymCheckNameIndex(_Sym, (x))]) 206 #define utSymGetName(Sym) (utSyms.Name + utSymGetNameIndex(Sym)) 207 #define utSymGetNames utSymGetName 208 #define utSymSetName(Sym, valuePtr, numName) (utSymResizeNames(Sym, numName), \ 209 (void)utRecordArray(utModuleID, 6, utSymGetNameIndex(Sym), utSymGetNumName(Sym), true), \ 210 memcpy(utSymGetNames(Sym), valuePtr, \ 211 numName*sizeof(char)), \ 212 (void)utRecordArray(utModuleID, 6, utSymGetNameIndex(Sym), utSymGetNumName(Sym), false)) 213 #define utSymSetiName(Sym, x, value) ( \ 214 (void)utRecordField(utModuleID, 6, utSymGetNameIndex(Sym) + (x), true), \ 215 (utSyms.Name)[ \ 216 utSymGetNameIndex(Sym) + utSymCheckNameIndex(Sym, (x))] = (value), \ 217 (void)utRecordField(utModuleID, 6, utSymGetNameIndex(Sym) + (x), false)) 218 #define utSymGetHashValue(_Sym) (utSyms.HashValue[utSym2ValidIndex(_Sym)]) 219 #define utSymSetHashValue(_Sym, value) ( \ 220 (void)utRecordField(utModuleID, 7, utSym2ValidIndex(_Sym), true), \ 221 (utSyms.HashValue)[utSym2ValidIndex(_Sym)] = (value), \ 222 (void)utRecordField(utModuleID, 7, utSym2ValidIndex(_Sym), false)) 223 #define utSymGetNext(_Sym) (utSyms.Next[utSym2ValidIndex(_Sym)]) 224 #define utSymSetNext(_Sym, value) ( \ 225 (void)utRecordField(utModuleID, 8, utSym2ValidIndex(_Sym), true), \ 226 (utSyms.Next)[utSym2ValidIndex(_Sym)] = (value), \ 227 (void)utRecordField(utModuleID, 8, utSym2ValidIndex(_Sym), false)) 228 #define utSymSetConstructorCallback(func) (utSymConstructorCallback = (func)) 229 #define utSymGetConstructorCallback() (utSymConstructorCallback) 230 #define utFirstSym() (utRootData.usedSym == 0? utSymNull : utIndex2Sym(0)) 231 #define utLastSym() (utRootData.usedSym == 0? utSymNull : \ 232 utIndex2Sym(utRootData.usedSym - 1)) 233 #define utNextSym(Sym) (utSym2ValidIndex(Sym) + 1 == utRootData.usedSym? utSymNull : \ 234 (Sym) + 1) 235 #define utPrevSym(Sym) (utSym2ValidIndex(Sym) == 0? utSymNull : (Sym) - 1) 236 #define utForeachSym(var) \ 237 for(var = utIndex2Sym(0); utSym2Index(var) != utRootData.usedSym; var++) 238 #define utEndSym 239 #define utSymFreeAll() (utSetUsedSym(0), utSetUsedSymName(0)) 240 #define utSymAllocRaw() ( \ 241 utRootData.usedSym == utRootData.allocatedSym && (utSymAllocMore(), true), \ 242 utTemp_.Sym = utIndex2Sym(utRootData.usedSym), \ 243 utSetUsedSym(utUsedSym() + 1), \ 244 utTemp_.Sym) 245 #define utSymAlloc() ( \ 246 utRootData.usedSym == utRootData.allocatedSym && (utSymAllocMore(), true), \ 247 utTemp_.Sym = utIndex2Sym(utRootData.usedSym), \ 248 utSetUsedSym(utUsedSym() + 1), \ 249 utSymSetNameIndex(utTemp_.Sym, 0), \ 250 utSymSetNumName(utTemp_.Sym, 0), \ 251 utSymSetNumName(utTemp_.Sym, 0), \ 252 utSymSetHashValue(utTemp_.Sym, 0), \ 253 utSymSetNext(utTemp_.Sym, utSymNull), \ 254 utSymConstructorCallback != NULL && (utSymConstructorCallback(utTemp_.Sym), true), \ 255 utTemp_.Sym) 256 257 void utSymAllocMore(void); 258 void utSymCopyProps(utSym utOldSym, utSym utNewSym); 259 void utSymAllocNames(utSym Sym, uint32 numNames); 260 void utSymResizeNames(utSym Sym, uint32 numNames); 261 void utSymFreeNames(utSym Sym); 262 void utCompactSymNames(void); 263 264 /*---------------------------------------------------------------------------------------- 265 Fields for class Dynarray. 266 ----------------------------------------------------------------------------------------*/ 267 struct utDynarrayFields { 268 uint32 *ValueIndex; 269 uint32 *NumValue; 270 uint8 *Value; 271 uint16 *ValueSize; 272 uint32 *UsedValue; 273 uint32 *Size; 274 utDynarray *FreeList; 275 }; 276 extern struct utDynarrayFields utDynarrays; 277 278 #define utDynarrayGetValueIndex(_Dynarray) (utDynarrays.ValueIndex[utDynarray2ValidIndex(_Dynarray)]) 279 #define utDynarraySetValueIndex(_Dynarray, value) ( \ 280 (void)utRecordField(utModuleID, 9, utDynarray2ValidIndex(_Dynarray), true), \ 281 (utDynarrays.ValueIndex)[utDynarray2ValidIndex(_Dynarray)] = (value), \ 282 (void)utRecordField(utModuleID, 9, utDynarray2ValidIndex(_Dynarray), false)) 283 #define utDynarrayGetNumValue(_Dynarray) (utDynarrays.NumValue[utDynarray2ValidIndex(_Dynarray)]) 284 #define utDynarraySetNumValue(_Dynarray, value) ( \ 285 (void)utRecordField(utModuleID, 10, utDynarray2ValidIndex(_Dynarray), true), \ 286 (utDynarrays.NumValue)[utDynarray2ValidIndex(_Dynarray)] = (value), \ 287 (void)utRecordField(utModuleID, 10, utDynarray2ValidIndex(_Dynarray), false)) 288 #if defined(DD_DEBUG) 289 #define utDynarrayCheckValueIndex(Dynarray, x) ((uint32)(x) < utDynarrayGetNumValue(Dynarray)? (x) : \ 290 (utAssert(false),(x))) 291 #else 292 #define utDynarrayCheckValueIndex(Dynarray, x) (x) 293 #endif 294 #define utDynarrayGetiValue(_Dynarray, x) ((utDynarrays.Value)[ \ 295 utDynarrayGetValueIndex(_Dynarray) + utDynarrayCheckValueIndex(_Dynarray, (x))]) 296 #define utDynarrayGetValue(Dynarray) (utDynarrays.Value + utDynarrayGetValueIndex(Dynarray)) 297 #define utDynarrayGetValues utDynarrayGetValue 298 #define utDynarraySetValue(Dynarray, valuePtr, numValue) (utDynarrayResizeValues(Dynarray, numValue), \ 299 (void)utRecordArray(utModuleID, 11, utDynarrayGetValueIndex(Dynarray), utDynarrayGetNumValue(Dynarray), true), \ 300 memcpy(utDynarrayGetValues(Dynarray), valuePtr, \ 301 numValue*sizeof(uint8)), \ 302 (void)utRecordArray(utModuleID, 11, utDynarrayGetValueIndex(Dynarray), utDynarrayGetNumValue(Dynarray), false)) 303 #define utDynarraySetiValue(Dynarray, x, value) ( \ 304 (void)utRecordField(utModuleID, 11, utDynarrayGetValueIndex(Dynarray) + (x), true), \ 305 (utDynarrays.Value)[ \ 306 utDynarrayGetValueIndex(Dynarray) + utDynarrayCheckValueIndex(Dynarray, (x))] = (value), \ 307 (void)utRecordField(utModuleID, 11, utDynarrayGetValueIndex(Dynarray) + (x), false)) 308 #define utDynarrayGetValueSize(_Dynarray) (utDynarrays.ValueSize[utDynarray2ValidIndex(_Dynarray)]) 309 #define utDynarraySetValueSize(_Dynarray, value) ( \ 310 (void)utRecordField(utModuleID, 12, utDynarray2ValidIndex(_Dynarray), true), \ 311 (utDynarrays.ValueSize)[utDynarray2ValidIndex(_Dynarray)] = (value), \ 312 (void)utRecordField(utModuleID, 12, utDynarray2ValidIndex(_Dynarray), false)) 313 #define utDynarrayGetUsedValue(_Dynarray) (utDynarrays.UsedValue[utDynarray2ValidIndex(_Dynarray)]) 314 #define utDynarraySetUsedValue(_Dynarray, value) ( \ 315 (void)utRecordField(utModuleID, 13, utDynarray2ValidIndex(_Dynarray), true), \ 316 (utDynarrays.UsedValue)[utDynarray2ValidIndex(_Dynarray)] = (value), \ 317 (void)utRecordField(utModuleID, 13, utDynarray2ValidIndex(_Dynarray), false)) 318 #define utDynarrayGetSize(_Dynarray) (utDynarrays.Size[utDynarray2ValidIndex(_Dynarray)]) 319 #define utDynarraySetSize(_Dynarray, value) ( \ 320 (void)utRecordField(utModuleID, 14, utDynarray2ValidIndex(_Dynarray), true), \ 321 (utDynarrays.Size)[utDynarray2ValidIndex(_Dynarray)] = (value), \ 322 (void)utRecordField(utModuleID, 14, utDynarray2ValidIndex(_Dynarray), false)) 323 #define utDynarrayGetFreeList(_Dynarray) (utDynarrays.FreeList[utDynarray2ValidIndex(_Dynarray)]) 324 #define utDynarraySetFreeList(_Dynarray, value) ( \ 325 (void)utRecordField(utModuleID, 15, utDynarray2ValidIndex(_Dynarray), true), \ 326 (utDynarrays.FreeList)[utDynarray2ValidIndex(_Dynarray)] = (value), \ 327 (void)utRecordField(utModuleID, 15, utDynarray2ValidIndex(_Dynarray), false)) 328 #define utDynarraySetConstructorCallback(func) (utDynarrayConstructorCallback = (func)) 329 #define utDynarrayGetConstructorCallback() (utDynarrayConstructorCallback) 330 #define utDynarraySetDestructorCallback(func) (utDynarrayDestructorCallback = (func)) 331 #define utDynarrayGetDestructorCallback() (utDynarrayDestructorCallback) 332 #define utDynarrayNextFree(_Dynarray) (((utDynarray *)(void *)(utDynarrays.FreeList))[utDynarray2ValidIndex(_Dynarray)]) 333 #define utDynarraySetNextFree(_Dynarray, value) ( \ 334 (void)utRecordField(utModuleID, 15, utDynarray2ValidIndex(Dynarray), true), \ 335 ((utDynarray *)(void *)(utDynarrays.FreeList)) \ 336 [utDynarray2ValidIndex(_Dynarray)] = (value), \ 337 (void)utRecordField(utModuleID, 15, utDynarray2ValidIndex(Dynarray), false)) 338 #define utDynarrayAllocRaw() ( \ 339 utRootData.firstFreeDynarray != utDynarrayNull? \ 340 (utTemp_.Dynarray = utRootData.firstFreeDynarray, \ 341 utSetFirstFreeDynarray(utDynarrayNextFree(utTemp_.Dynarray)), true) \ 342 : (utRootData.usedDynarray == utRootData.allocatedDynarray && (utDynarrayAllocMore(), true), \ 343 utTemp_.Dynarray = utIndex2Dynarray(utRootData.usedDynarray), \ 344 utSetUsedDynarray(utUsedDynarray() + 1)), \ 345 utTemp_.Dynarray) 346 #define utDynarrayAlloc() ( \ 347 utRootData.firstFreeDynarray != utDynarrayNull? \ 348 (utTemp_.Dynarray = utRootData.firstFreeDynarray, \ 349 utSetFirstFreeDynarray(utDynarrayNextFree(utTemp_.Dynarray)), true) \ 350 : (utRootData.usedDynarray == utRootData.allocatedDynarray && (utDynarrayAllocMore(), true), \ 351 utTemp_.Dynarray = utIndex2Dynarray(utRootData.usedDynarray), \ 352 utSetUsedDynarray(utUsedDynarray() + 1)), \ 353 utDynarraySetValueIndex(utTemp_.Dynarray, 0), \ 354 utDynarraySetNumValue(utTemp_.Dynarray, 0), \ 355 utDynarraySetNumValue(utTemp_.Dynarray, 0), \ 356 utDynarraySetValueSize(utTemp_.Dynarray, 0), \ 357 utDynarraySetUsedValue(utTemp_.Dynarray, 0), \ 358 utDynarraySetSize(utTemp_.Dynarray, 0), \ 359 utDynarraySetFreeList(utTemp_.Dynarray, utDynarrayNull), \ 360 utDynarrayConstructorCallback != NULL && (utDynarrayConstructorCallback(utTemp_.Dynarray), true), \ 361 utTemp_.Dynarray) 362 363 #define utDynarrayFree(Dynarray) (utDynarrayFreeValues(Dynarray), \ 364 utDynarraySetNextFree(Dynarray, utRootData.firstFreeDynarray), \ 365 utSetFirstFreeDynarray(Dynarray)) 366 void utDynarrayDestroy(utDynarray Dynarray); 367 void utDynarrayAllocMore(void); 368 void utDynarrayCopyProps(utDynarray utOldDynarray, utDynarray utNewDynarray); 369 void utDynarrayAllocValues(utDynarray Dynarray, uint32 numValues); 370 void utDynarrayResizeValues(utDynarray Dynarray, uint32 numValues); 371 void utDynarrayFreeValues(utDynarray Dynarray); 372 void utCompactDynarrayValues(void); 373 374 /*---------------------------------------------------------------------------------------- 375 Fields for class SymArray. 376 ----------------------------------------------------------------------------------------*/ 377 struct utSymArrayFields { 378 uint32 *SymIndex; 379 uint32 *NumSym; 380 utSym *Sym; 381 uint32 *UsedSym; 382 utSymArray *FreeList; 383 }; 384 extern struct utSymArrayFields utSymArrays; 385 386 #define utSymArrayGetSymIndex(_SymArray) (utSymArrays.SymIndex[utSymArray2ValidIndex(_SymArray)]) 387 #define utSymArraySetSymIndex(_SymArray, value) ( \ 388 (void)utRecordField(utModuleID, 16, utSymArray2ValidIndex(_SymArray), true), \ 389 (utSymArrays.SymIndex)[utSymArray2ValidIndex(_SymArray)] = (value), \ 390 (void)utRecordField(utModuleID, 16, utSymArray2ValidIndex(_SymArray), false)) 391 #define utSymArrayGetNumSym(_SymArray) (utSymArrays.NumSym[utSymArray2ValidIndex(_SymArray)]) 392 #define utSymArraySetNumSym(_SymArray, value) ( \ 393 (void)utRecordField(utModuleID, 17, utSymArray2ValidIndex(_SymArray), true), \ 394 (utSymArrays.NumSym)[utSymArray2ValidIndex(_SymArray)] = (value), \ 395 (void)utRecordField(utModuleID, 17, utSymArray2ValidIndex(_SymArray), false)) 396 #if defined(DD_DEBUG) 397 #define utSymArrayCheckSymIndex(SymArray, x) ((uint32)(x) < utSymArrayGetNumSym(SymArray)? (x) : \ 398 (utAssert(false),(x))) 399 #else 400 #define utSymArrayCheckSymIndex(SymArray, x) (x) 401 #endif 402 #define utSymArrayGetiSym(_SymArray, x) ((utSymArrays.Sym)[ \ 403 utSymArrayGetSymIndex(_SymArray) + utSymArrayCheckSymIndex(_SymArray, (x))]) 404 #define utSymArrayGetSym(SymArray) (utSymArrays.Sym + utSymArrayGetSymIndex(SymArray)) 405 #define utSymArrayGetSyms utSymArrayGetSym 406 #define utSymArraySetSym(SymArray, valuePtr, numSym) (utSymArrayResizeSyms(SymArray, numSym), \ 407 (void)utRecordArray(utModuleID, 18, utSymArrayGetSymIndex(SymArray), utSymArrayGetNumSym(SymArray), true), \ 408 memcpy(utSymArrayGetSyms(SymArray), valuePtr, \ 409 numSym*sizeof(utSym)), \ 410 (void)utRecordArray(utModuleID, 18, utSymArrayGetSymIndex(SymArray), utSymArrayGetNumSym(SymArray), false)) 411 #define utSymArraySetiSym(SymArray, x, value) ( \ 412 (void)utRecordField(utModuleID, 18, utSymArrayGetSymIndex(SymArray) + (x), true), \ 413 (utSymArrays.Sym)[ \ 414 utSymArrayGetSymIndex(SymArray) + utSymArrayCheckSymIndex(SymArray, (x))] = (value), \ 415 (void)utRecordField(utModuleID, 18, utSymArrayGetSymIndex(SymArray) + (x), false)) 416 #define utSymArrayGetUsedSym(_SymArray) (utSymArrays.UsedSym[utSymArray2ValidIndex(_SymArray)]) 417 #define utSymArraySetUsedSym(_SymArray, value) ( \ 418 (void)utRecordField(utModuleID, 19, utSymArray2ValidIndex(_SymArray), true), \ 419 (utSymArrays.UsedSym)[utSymArray2ValidIndex(_SymArray)] = (value), \ 420 (void)utRecordField(utModuleID, 19, utSymArray2ValidIndex(_SymArray), false)) 421 #define utSymArrayGetFreeList(_SymArray) (utSymArrays.FreeList[utSymArray2ValidIndex(_SymArray)]) 422 #define utSymArraySetFreeList(_SymArray, value) ( \ 423 (void)utRecordField(utModuleID, 20, utSymArray2ValidIndex(_SymArray), true), \ 424 (utSymArrays.FreeList)[utSymArray2ValidIndex(_SymArray)] = (value), \ 425 (void)utRecordField(utModuleID, 20, utSymArray2ValidIndex(_SymArray), false)) 426 #define utForeachSymArraySym(pVar, cVar) { \ 427 uint32 _xSym; \ 428 for(_xSym = 0; _xSym < utSymArrayGetUsedSym(pVar); _xSym++) { \ 429 cVar = utSymArrayGetiSym(pVar, _xSym); \ 430 if(cVar != utSymNull) { 431 #define utEndSymArraySym }}} 432 #define utSymArraySetConstructorCallback(func) (utSymArrayConstructorCallback = (func)) 433 #define utSymArrayGetConstructorCallback() (utSymArrayConstructorCallback) 434 #define utSymArraySetDestructorCallback(func) (utSymArrayDestructorCallback = (func)) 435 #define utSymArrayGetDestructorCallback() (utSymArrayDestructorCallback) 436 #define utSymArrayNextFree(_SymArray) (((utSymArray *)(void *)(utSymArrays.FreeList))[utSymArray2ValidIndex(_SymArray)]) 437 #define utSymArraySetNextFree(_SymArray, value) ( \ 438 (void)utRecordField(utModuleID, 20, utSymArray2ValidIndex(SymArray), true), \ 439 ((utSymArray *)(void *)(utSymArrays.FreeList)) \ 440 [utSymArray2ValidIndex(_SymArray)] = (value), \ 441 (void)utRecordField(utModuleID, 20, utSymArray2ValidIndex(SymArray), false)) 442 #define utSymArrayAllocRaw() ( \ 443 utRootData.firstFreeSymArray != utSymArrayNull? \ 444 (utTemp_.SymArray = utRootData.firstFreeSymArray, \ 445 utSetFirstFreeSymArray(utSymArrayNextFree(utTemp_.SymArray)), true) \ 446 : (utRootData.usedSymArray == utRootData.allocatedSymArray && (utSymArrayAllocMore(), true), \ 447 utTemp_.SymArray = utIndex2SymArray(utRootData.usedSymArray), \ 448 utSetUsedSymArray(utUsedSymArray() + 1)), \ 449 utTemp_.SymArray) 450 #define utSymArrayAlloc() ( \ 451 utRootData.firstFreeSymArray != utSymArrayNull? \ 452 (utTemp_.SymArray = utRootData.firstFreeSymArray, \ 453 utSetFirstFreeSymArray(utSymArrayNextFree(utTemp_.SymArray)), true) \ 454 : (utRootData.usedSymArray == utRootData.allocatedSymArray && (utSymArrayAllocMore(), true), \ 455 utTemp_.SymArray = utIndex2SymArray(utRootData.usedSymArray), \ 456 utSetUsedSymArray(utUsedSymArray() + 1)), \ 457 utSymArraySetSymIndex(utTemp_.SymArray, 0), \ 458 utSymArraySetNumSym(utTemp_.SymArray, 0), \ 459 utSymArraySetNumSym(utTemp_.SymArray, 0), \ 460 utSymArraySetUsedSym(utTemp_.SymArray, 0), \ 461 utSymArraySetFreeList(utTemp_.SymArray, utSymArrayNull), \ 462 utSymArrayConstructorCallback != NULL && (utSymArrayConstructorCallback(utTemp_.SymArray), true), \ 463 utTemp_.SymArray) 464 465 #define utSymArrayFree(SymArray) (utSymArrayFreeSyms(SymArray), \ 466 utSymArraySetNextFree(SymArray, utRootData.firstFreeSymArray), \ 467 utSetFirstFreeSymArray(SymArray)) 468 void utSymArrayDestroy(utSymArray SymArray); 469 void utSymArrayAllocMore(void); 470 void utSymArrayCopyProps(utSymArray utOldSymArray, utSymArray utNewSymArray); 471 void utSymArrayAllocSyms(utSymArray SymArray, uint32 numSyms); 472 void utSymArrayResizeSyms(utSymArray SymArray, uint32 numSyms); 473 void utSymArrayFreeSyms(utSymArray SymArray); 474 void utCompactSymArraySyms(void); 475 void utSymArrayInsertSym(utSymArray SymArray, uint32 x, utSym _Sym); 476 void utSymArrayAppendSym(utSymArray SymArray, utSym _Sym); 477 478 /*---------------------------------------------------------------------------------------- 479 Temp Union structure - Macro temp variables, use only one 480 ----------------------------------------------------------------------------------------*/ 481 union utTempType_ { 482 utSymtab Symtab; 483 utSym Sym; 484 utDynarray Dynarray; 485 utSymArray SymArray; 486 }; 487 488 extern union utTempType_ utTemp_; 489 490 /*---------------------------------------------------------------------------------------- 491 Constructor/Destructor hooks. 492 ----------------------------------------------------------------------------------------*/ 493 extern void(*utSymtabConstructorCallback)(utSymtab); 494 extern void(*utSymConstructorCallback)(utSym); 495 extern void(*utDynarrayConstructorCallback)(utDynarray); 496 extern void(*utDynarrayDestructorCallback)(utDynarray); 497 extern void(*utSymArrayConstructorCallback)(utSymArray); 498 extern void(*utSymArrayDestructorCallback)(utSymArray); 499 500 /*---------------------------------------------------------------------------------------- 501 Root structure 502 ----------------------------------------------------------------------------------------*/ 503 struct utRootType_ { 504 uint32 hash; /* This depends only on the structure of the database */ 505 uint32 usedSymtab, allocatedSymtab; 506 uint32 usedSymtabTable, allocatedSymtabTable, freeSymtabTable; 507 uint32 usedSym, allocatedSym; 508 uint32 usedSymName, allocatedSymName, freeSymName; 509 utDynarray firstFreeDynarray; 510 uint32 usedDynarray, allocatedDynarray; 511 uint32 usedDynarrayValue, allocatedDynarrayValue, freeDynarrayValue; 512 utSymArray firstFreeSymArray; 513 uint32 usedSymArray, allocatedSymArray; 514 uint32 usedSymArraySym, allocatedSymArraySym, freeSymArraySym; 515 }; 516 extern struct utRootType_ utRootData; 517 518 #define utHash() (utRootData.hash) 519 #define utUsedSymtab() utRootData.usedSymtab 520 #define utAllocatedSymtab() utRootData.allocatedSymtab 521 #define utSetUsedSymtab(value) ( \ 522 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedSymtab, true), \ 523 utRootData.usedSymtab = (value), \ 524 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedSymtab, false)) 525 #define utSetAllocatedSymtab(value) ( \ 526 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedSymtab, true), \ 527 utRootData.allocatedSymtab = (value), \ 528 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedSymtab, false)) 529 #define utUsedSymtabTable() utRootData.usedSymtabTable 530 #define utAllocatedSymtabTable() utRootData.allocatedSymtabTable 531 #define utFreeSymtabTable() utRootData.freeSymtabTable 532 #define utSetUsedSymtabTable(value) ( \ 533 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedSymtabTable, true), \ 534 utRootData.usedSymtabTable = (value), \ 535 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedSymtabTable, false)) 536 #define utSetAllocatedSymtabTable(value) ( \ 537 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedSymtabTable, true), \ 538 utRootData.allocatedSymtabTable = (value), \ 539 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedSymtabTable, false)) 540 #define utSetFreeSymtabTable(value) ( \ 541 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeSymtabTable, true), \ 542 utRootData.freeSymtabTable = (value), \ 543 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeSymtabTable, false)) 544 #define utUsedSym() utRootData.usedSym 545 #define utAllocatedSym() utRootData.allocatedSym 546 #define utSetUsedSym(value) ( \ 547 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedSym, true), \ 548 utRootData.usedSym = (value), \ 549 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedSym, false)) 550 #define utSetAllocatedSym(value) ( \ 551 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedSym, true), \ 552 utRootData.allocatedSym = (value), \ 553 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedSym, false)) 554 #define utUsedSymName() utRootData.usedSymName 555 #define utAllocatedSymName() utRootData.allocatedSymName 556 #define utFreeSymName() utRootData.freeSymName 557 #define utSetUsedSymName(value) ( \ 558 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedSymName, true), \ 559 utRootData.usedSymName = (value), \ 560 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedSymName, false)) 561 #define utSetAllocatedSymName(value) ( \ 562 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedSymName, true), \ 563 utRootData.allocatedSymName = (value), \ 564 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedSymName, false)) 565 #define utSetFreeSymName(value) ( \ 566 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeSymName, true), \ 567 utRootData.freeSymName = (value), \ 568 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeSymName, false)) 569 #define utFirstFreeDynarray() utRootData.firstFreeDynarray 570 #define utSetFirstFreeDynarray(value) ( \ 571 (void)utRecordGlobal(utModuleID, 4, &utRootData.firstFreeDynarray, true), \ 572 utRootData.firstFreeDynarray = (value), \ 573 (void)utRecordGlobal(utModuleID, 4, &utRootData.firstFreeDynarray, false)) 574 #define utUsedDynarray() utRootData.usedDynarray 575 #define utAllocatedDynarray() utRootData.allocatedDynarray 576 #define utSetUsedDynarray(value) ( \ 577 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedDynarray, true), \ 578 utRootData.usedDynarray = (value), \ 579 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedDynarray, false)) 580 #define utSetAllocatedDynarray(value) ( \ 581 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedDynarray, true), \ 582 utRootData.allocatedDynarray = (value), \ 583 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedDynarray, false)) 584 #define utUsedDynarrayValue() utRootData.usedDynarrayValue 585 #define utAllocatedDynarrayValue() utRootData.allocatedDynarrayValue 586 #define utFreeDynarrayValue() utRootData.freeDynarrayValue 587 #define utSetUsedDynarrayValue(value) ( \ 588 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedDynarrayValue, true), \ 589 utRootData.usedDynarrayValue = (value), \ 590 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedDynarrayValue, false)) 591 #define utSetAllocatedDynarrayValue(value) ( \ 592 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedDynarrayValue, true), \ 593 utRootData.allocatedDynarrayValue = (value), \ 594 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedDynarrayValue, false)) 595 #define utSetFreeDynarrayValue(value) ( \ 596 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeDynarrayValue, true), \ 597 utRootData.freeDynarrayValue = (value), \ 598 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeDynarrayValue, false)) 599 #define utFirstFreeSymArray() utRootData.firstFreeSymArray 600 #define utSetFirstFreeSymArray(value) ( \ 601 (void)utRecordGlobal(utModuleID, 4, &utRootData.firstFreeSymArray, true), \ 602 utRootData.firstFreeSymArray = (value), \ 603 (void)utRecordGlobal(utModuleID, 4, &utRootData.firstFreeSymArray, false)) 604 #define utUsedSymArray() utRootData.usedSymArray 605 #define utAllocatedSymArray() utRootData.allocatedSymArray 606 #define utSetUsedSymArray(value) ( \ 607 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedSymArray, true), \ 608 utRootData.usedSymArray = (value), \ 609 (void)utRecordGlobal(utModuleID, 4, &utRootData.usedSymArray, false)) 610 #define utSetAllocatedSymArray(value) ( \ 611 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedSymArray, true), \ 612 utRootData.allocatedSymArray = (value), \ 613 (void)utRecordGlobal(utModuleID, 4, &utRootData.allocatedSymArray, false)) 614 #define utUsedSymArraySym() utRootData.usedSymArraySym 615 #define utAllocatedSymArraySym() utRootData.allocatedSymArraySym 616 #define utFreeSymArraySym() utRootData.freeSymArraySym 617 #define utSetUsedSymArraySym(value) ( \ 618 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedSymArraySym, true), \ 619 utRootData.usedSymArraySym = (value), \ 620 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.usedSymArraySym, false)) 621 #define utSetAllocatedSymArraySym(value) ( \ 622 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedSymArraySym, true), \ 623 utRootData.allocatedSymArraySym = (value), \ 624 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.allocatedSymArraySym, false)) 625 #define utSetFreeSymArraySym(value) ( \ 626 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeSymArraySym, true), \ 627 utRootData.freeSymArraySym = (value), \ 628 (void)utRecordGlobal(utModuleID, sizeof(uint32), &utRootData.freeSymArraySym, false)) 629 630 extern uint8 utModuleID; 631 void utDatabaseStart(void); 632 void utDatabaseStop(void); 633 #if defined __cplusplus 634 } 635 #endif 636 637 #endif 638