1 /*---------------------------------------------------------------------------------------- 2 Module header file for: dv module 3 ----------------------------------------------------------------------------------------*/ 4 #ifndef DVDATABASE_H 5 6 #define DVDATABASE_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)) || defined(DD_STRICT) 19 typedef struct _struct_dvRoot{char val;} *dvRoot; 20 #define dvRootNull ((dvRoot)(UINT32_MAX)) 21 #define dvRoot2Index(Root) ((uint32)((Root) - (dvRoot)(0))) 22 #define dvRoot2ValidIndex(Root) ((uint32)(dvValidRoot(Root) - (dvRoot)(0))) 23 #define dvIndex2Root(xRoot) ((dvRoot)((xRoot) + (dvRoot)(0))) 24 typedef struct _struct_dvModpath{char val;} *dvModpath; 25 #define dvModpathNull ((dvModpath)(UINT32_MAX)) 26 #define dvModpath2Index(Modpath) ((uint32)((Modpath) - (dvModpath)(0))) 27 #define dvModpath2ValidIndex(Modpath) ((uint32)(dvValidModpath(Modpath) - (dvModpath)(0))) 28 #define dvIndex2Modpath(xModpath) ((dvModpath)((xModpath) + (dvModpath)(0))) 29 typedef struct _struct_dvModule{char val;} *dvModule; 30 #define dvModuleNull ((dvModule)(UINT32_MAX)) 31 #define dvModule2Index(Module) ((uint32)((Module) - (dvModule)(0))) 32 #define dvModule2ValidIndex(Module) ((uint32)(dvValidModule(Module) - (dvModule)(0))) 33 #define dvIndex2Module(xModule) ((dvModule)((xModule) + (dvModule)(0))) 34 typedef struct _struct_dvLink{char val;} *dvLink; 35 #define dvLinkNull ((dvLink)(UINT32_MAX)) 36 #define dvLink2Index(Link) ((uint32)((Link) - (dvLink)(0))) 37 #define dvLink2ValidIndex(Link) ((uint32)(dvValidLink(Link) - (dvLink)(0))) 38 #define dvIndex2Link(xLink) ((dvLink)((xLink) + (dvLink)(0))) 39 typedef struct _struct_dvSchema{char val;} *dvSchema; 40 #define dvSchemaNull ((dvSchema)(UINT32_MAX)) 41 #define dvSchema2Index(Schema) ((uint32)((Schema) - (dvSchema)(0))) 42 #define dvSchema2ValidIndex(Schema) ((uint32)(dvValidSchema(Schema) - (dvSchema)(0))) 43 #define dvIndex2Schema(xSchema) ((dvSchema)((xSchema) + (dvSchema)(0))) 44 typedef struct _struct_dvEnum{char val;} *dvEnum; 45 #define dvEnumNull ((dvEnum)(UINT32_MAX)) 46 #define dvEnum2Index(Enum) ((uint32)((Enum) - (dvEnum)(0))) 47 #define dvEnum2ValidIndex(Enum) ((uint32)(dvValidEnum(Enum) - (dvEnum)(0))) 48 #define dvIndex2Enum(xEnum) ((dvEnum)((xEnum) + (dvEnum)(0))) 49 typedef struct _struct_dvEntry{char val;} *dvEntry; 50 #define dvEntryNull ((dvEntry)(UINT32_MAX)) 51 #define dvEntry2Index(Entry) ((uint32)((Entry) - (dvEntry)(0))) 52 #define dvEntry2ValidIndex(Entry) ((uint32)(dvValidEntry(Entry) - (dvEntry)(0))) 53 #define dvIndex2Entry(xEntry) ((dvEntry)((xEntry) + (dvEntry)(0))) 54 typedef struct _struct_dvTypedef{char val;} *dvTypedef; 55 #define dvTypedefNull ((dvTypedef)(UINT32_MAX)) 56 #define dvTypedef2Index(Typedef) ((uint32)((Typedef) - (dvTypedef)(0))) 57 #define dvTypedef2ValidIndex(Typedef) ((uint32)(dvValidTypedef(Typedef) - (dvTypedef)(0))) 58 #define dvIndex2Typedef(xTypedef) ((dvTypedef)((xTypedef) + (dvTypedef)(0))) 59 typedef struct _struct_dvClass{char val;} *dvClass; 60 #define dvClassNull ((dvClass)(UINT32_MAX)) 61 #define dvClass2Index(Class) ((uint32)((Class) - (dvClass)(0))) 62 #define dvClass2ValidIndex(Class) ((uint32)(dvValidClass(Class) - (dvClass)(0))) 63 #define dvIndex2Class(xClass) ((dvClass)((xClass) + (dvClass)(0))) 64 typedef struct _struct_dvProperty{char val;} *dvProperty; 65 #define dvPropertyNull ((dvProperty)(UINT32_MAX)) 66 #define dvProperty2Index(Property) ((uint32)((Property) - (dvProperty)(0))) 67 #define dvProperty2ValidIndex(Property) ((uint32)(dvValidProperty(Property) - (dvProperty)(0))) 68 #define dvIndex2Property(xProperty) ((dvProperty)((xProperty) + (dvProperty)(0))) 69 typedef struct _struct_dvSparsegroup{char val;} *dvSparsegroup; 70 #define dvSparsegroupNull ((dvSparsegroup)(UINT32_MAX)) 71 #define dvSparsegroup2Index(Sparsegroup) ((uint32)((Sparsegroup) - (dvSparsegroup)(0))) 72 #define dvSparsegroup2ValidIndex(Sparsegroup) ((uint32)(dvValidSparsegroup(Sparsegroup) - (dvSparsegroup)(0))) 73 #define dvIndex2Sparsegroup(xSparsegroup) ((dvSparsegroup)((xSparsegroup) + (dvSparsegroup)(0))) 74 typedef struct _struct_dvRelationship{char val;} *dvRelationship; 75 #define dvRelationshipNull ((dvRelationship)(UINT32_MAX)) 76 #define dvRelationship2Index(Relationship) ((uint32)((Relationship) - (dvRelationship)(0))) 77 #define dvRelationship2ValidIndex(Relationship) ((uint32)(dvValidRelationship(Relationship) - (dvRelationship)(0))) 78 #define dvIndex2Relationship(xRelationship) ((dvRelationship)((xRelationship) + (dvRelationship)(0))) 79 typedef struct _struct_dvKey{char val;} *dvKey; 80 #define dvKeyNull ((dvKey)(UINT32_MAX)) 81 #define dvKey2Index(Key) ((uint32)((Key) - (dvKey)(0))) 82 #define dvKey2ValidIndex(Key) ((uint32)(dvValidKey(Key) - (dvKey)(0))) 83 #define dvIndex2Key(xKey) ((dvKey)((xKey) + (dvKey)(0))) 84 typedef struct _struct_dvUnion{char val;} *dvUnion; 85 #define dvUnionNull ((dvUnion)(UINT32_MAX)) 86 #define dvUnion2Index(Union) ((uint32)((Union) - (dvUnion)(0))) 87 #define dvUnion2ValidIndex(Union) ((uint32)(dvValidUnion(Union) - (dvUnion)(0))) 88 #define dvIndex2Union(xUnion) ((dvUnion)((xUnion) + (dvUnion)(0))) 89 typedef struct _struct_dvCase{char val;} *dvCase; 90 #define dvCaseNull ((dvCase)(UINT32_MAX)) 91 #define dvCase2Index(Case) ((uint32)((Case) - (dvCase)(0))) 92 #define dvCase2ValidIndex(Case) ((uint32)(dvValidCase(Case) - (dvCase)(0))) 93 #define dvIndex2Case(xCase) ((dvCase)((xCase) + (dvCase)(0))) 94 #else 95 typedef uint32 dvRoot; 96 #define dvRootNull UINT32_MAX 97 #define dvRoot2Index(Root) (Root) 98 #define dvRoot2ValidIndex(Root) (dvValidRoot(Root)) 99 #define dvIndex2Root(xRoot) ((xRoot)) 100 typedef uint32 dvModpath; 101 #define dvModpathNull UINT32_MAX 102 #define dvModpath2Index(Modpath) (Modpath) 103 #define dvModpath2ValidIndex(Modpath) (dvValidModpath(Modpath)) 104 #define dvIndex2Modpath(xModpath) ((xModpath)) 105 typedef uint32 dvModule; 106 #define dvModuleNull UINT32_MAX 107 #define dvModule2Index(Module) (Module) 108 #define dvModule2ValidIndex(Module) (dvValidModule(Module)) 109 #define dvIndex2Module(xModule) ((xModule)) 110 typedef uint32 dvLink; 111 #define dvLinkNull UINT32_MAX 112 #define dvLink2Index(Link) (Link) 113 #define dvLink2ValidIndex(Link) (dvValidLink(Link)) 114 #define dvIndex2Link(xLink) ((xLink)) 115 typedef uint32 dvSchema; 116 #define dvSchemaNull UINT32_MAX 117 #define dvSchema2Index(Schema) (Schema) 118 #define dvSchema2ValidIndex(Schema) (dvValidSchema(Schema)) 119 #define dvIndex2Schema(xSchema) ((xSchema)) 120 typedef uint32 dvEnum; 121 #define dvEnumNull UINT32_MAX 122 #define dvEnum2Index(Enum) (Enum) 123 #define dvEnum2ValidIndex(Enum) (dvValidEnum(Enum)) 124 #define dvIndex2Enum(xEnum) ((xEnum)) 125 typedef uint32 dvEntry; 126 #define dvEntryNull UINT32_MAX 127 #define dvEntry2Index(Entry) (Entry) 128 #define dvEntry2ValidIndex(Entry) (dvValidEntry(Entry)) 129 #define dvIndex2Entry(xEntry) ((xEntry)) 130 typedef uint32 dvTypedef; 131 #define dvTypedefNull UINT32_MAX 132 #define dvTypedef2Index(Typedef) (Typedef) 133 #define dvTypedef2ValidIndex(Typedef) (dvValidTypedef(Typedef)) 134 #define dvIndex2Typedef(xTypedef) ((xTypedef)) 135 typedef uint32 dvClass; 136 #define dvClassNull UINT32_MAX 137 #define dvClass2Index(Class) (Class) 138 #define dvClass2ValidIndex(Class) (dvValidClass(Class)) 139 #define dvIndex2Class(xClass) ((xClass)) 140 typedef uint32 dvProperty; 141 #define dvPropertyNull UINT32_MAX 142 #define dvProperty2Index(Property) (Property) 143 #define dvProperty2ValidIndex(Property) (dvValidProperty(Property)) 144 #define dvIndex2Property(xProperty) ((xProperty)) 145 typedef uint32 dvSparsegroup; 146 #define dvSparsegroupNull UINT32_MAX 147 #define dvSparsegroup2Index(Sparsegroup) (Sparsegroup) 148 #define dvSparsegroup2ValidIndex(Sparsegroup) (dvValidSparsegroup(Sparsegroup)) 149 #define dvIndex2Sparsegroup(xSparsegroup) ((xSparsegroup)) 150 typedef uint32 dvRelationship; 151 #define dvRelationshipNull UINT32_MAX 152 #define dvRelationship2Index(Relationship) (Relationship) 153 #define dvRelationship2ValidIndex(Relationship) (dvValidRelationship(Relationship)) 154 #define dvIndex2Relationship(xRelationship) ((xRelationship)) 155 typedef uint32 dvKey; 156 #define dvKeyNull UINT32_MAX 157 #define dvKey2Index(Key) (Key) 158 #define dvKey2ValidIndex(Key) (dvValidKey(Key)) 159 #define dvIndex2Key(xKey) ((xKey)) 160 typedef uint32 dvUnion; 161 #define dvUnionNull UINT32_MAX 162 #define dvUnion2Index(Union) (Union) 163 #define dvUnion2ValidIndex(Union) (dvValidUnion(Union)) 164 #define dvIndex2Union(xUnion) ((xUnion)) 165 typedef uint32 dvCase; 166 #define dvCaseNull UINT32_MAX 167 #define dvCase2Index(Case) (Case) 168 #define dvCase2ValidIndex(Case) (dvValidCase(Case)) 169 #define dvIndex2Case(xCase) ((xCase)) 170 #endif 171 172 /* RelationshipType enumerated type */ 173 typedef enum { 174 REL_LINKED_LIST = 0, 175 REL_DOUBLY_LINKED = 1, 176 REL_TAIL_LINKED = 2, 177 REL_POINTER = 3, 178 REL_ARRAY = 4, 179 REL_HEAP = 5, 180 REL_HASHED = 6, 181 REL_UNBOUND = 7 182 } dvRelationshipType; 183 184 /* PropertyType enumerated type */ 185 typedef enum { 186 PROP_INT = 0, 187 PROP_UINT = 1, 188 PROP_FLOAT = 2, 189 PROP_DOUBLE = 3, 190 PROP_BIT = 4, 191 PROP_BOOL = 5, 192 PROP_CHAR = 6, 193 PROP_ENUM = 7, 194 PROP_TYPEDEF = 8, 195 PROP_POINTER = 9, 196 PROP_SYM = 10, 197 PROP_UNBOUND = 11 198 } dvPropertyType; 199 200 /* MemoryStyle enumerated type */ 201 typedef enum { 202 MEM_CREATE_ONLY = 0, 203 MEM_FREE_LIST = 1 204 } dvMemoryStyle; 205 206 /* Validate macros */ 207 #if defined(DD_DEBUG) 208 #define dvValidRoot(Root) (utLikely((uint32)((Root) - (dvRoot)0) < \ 209 dvRootData.usedRoot)? (Root) : (utExit("Invalid Root"), (dvRoot)0)) 210 #define dvValidModpath(Modpath) (utLikely((uint32)((Modpath) - (dvModpath)0) < \ 211 dvRootData.usedModpath)? (Modpath) : (utExit("Invalid Modpath"), (dvModpath)0)) 212 #define dvValidModule(Module) (utLikely((uint32)((Module) - (dvModule)0) < \ 213 dvRootData.usedModule)? (Module) : (utExit("Invalid Module"), (dvModule)0)) 214 #define dvValidLink(Link) (utLikely((uint32)((Link) - (dvLink)0) < \ 215 dvRootData.usedLink)? (Link) : (utExit("Invalid Link"), (dvLink)0)) 216 #define dvValidSchema(Schema) (utLikely((uint32)((Schema) - (dvSchema)0) < \ 217 dvRootData.usedSchema)? (Schema) : (utExit("Invalid Schema"), (dvSchema)0)) 218 #define dvValidEnum(Enum) (utLikely((uint32)((Enum) - (dvEnum)0) < \ 219 dvRootData.usedEnum)? (Enum) : (utExit("Invalid Enum"), (dvEnum)0)) 220 #define dvValidEntry(Entry) (utLikely((uint32)((Entry) - (dvEntry)0) < \ 221 dvRootData.usedEntry)? (Entry) : (utExit("Invalid Entry"), (dvEntry)0)) 222 #define dvValidTypedef(Typedef) (utLikely((uint32)((Typedef) - (dvTypedef)0) < \ 223 dvRootData.usedTypedef)? (Typedef) : (utExit("Invalid Typedef"), (dvTypedef)0)) 224 #define dvValidClass(Class) (utLikely((uint32)((Class) - (dvClass)0) < \ 225 dvRootData.usedClass)? (Class) : (utExit("Invalid Class"), (dvClass)0)) 226 #define dvValidProperty(Property) (utLikely((uint32)((Property) - (dvProperty)0) < \ 227 dvRootData.usedProperty)? (Property) : (utExit("Invalid Property"), (dvProperty)0)) 228 #define dvValidSparsegroup(Sparsegroup) (utLikely((uint32)((Sparsegroup) - (dvSparsegroup)0) < \ 229 dvRootData.usedSparsegroup)? (Sparsegroup) : (utExit("Invalid Sparsegroup"), (dvSparsegroup)0)) 230 #define dvValidRelationship(Relationship) (utLikely((uint32)((Relationship) - (dvRelationship)0) < \ 231 dvRootData.usedRelationship)? (Relationship) : (utExit("Invalid Relationship"), (dvRelationship)0)) 232 #define dvValidKey(Key) (utLikely((uint32)((Key) - (dvKey)0) < \ 233 dvRootData.usedKey)? (Key) : (utExit("Invalid Key"), (dvKey)0)) 234 #define dvValidUnion(Union) (utLikely((uint32)((Union) - (dvUnion)0) < \ 235 dvRootData.usedUnion)? (Union) : (utExit("Invalid Union"), (dvUnion)0)) 236 #define dvValidCase(Case) (utLikely((uint32)((Case) - (dvCase)0) < \ 237 dvRootData.usedCase)? (Case) : (utExit("Invalid Case"), (dvCase)0)) 238 #else 239 #define dvValidRoot(Root) (Root) 240 #define dvValidModpath(Modpath) (Modpath) 241 #define dvValidModule(Module) (Module) 242 #define dvValidLink(Link) (Link) 243 #define dvValidSchema(Schema) (Schema) 244 #define dvValidEnum(Enum) (Enum) 245 #define dvValidEntry(Entry) (Entry) 246 #define dvValidTypedef(Typedef) (Typedef) 247 #define dvValidClass(Class) (Class) 248 #define dvValidProperty(Property) (Property) 249 #define dvValidSparsegroup(Sparsegroup) (Sparsegroup) 250 #define dvValidRelationship(Relationship) (Relationship) 251 #define dvValidKey(Key) (Key) 252 #define dvValidUnion(Union) (Union) 253 #define dvValidCase(Case) (Case) 254 #endif 255 256 /*---------------------------------------------------------------------------------------- 257 Fields for class Root. 258 ----------------------------------------------------------------------------------------*/ 259 struct dvRootFields { 260 dvModpath *FirstModpath; 261 dvModpath *LastModpath; 262 uint32 *ModpathTableIndex; 263 uint32 *NumModpathTable; 264 dvModpath *ModpathTable; 265 uint32 *NumModpath; 266 dvModule *FirstModule; 267 dvModule *LastModule; 268 uint32 *ModuleTableIndex; 269 uint32 *NumModuleTable; 270 dvModule *ModuleTable; 271 uint32 *NumModule; 272 }; 273 extern struct dvRootFields dvRoots; 274 275 #define dvRootGetFirstModpath(_Root) (dvRoots.FirstModpath[dvRoot2ValidIndex(_Root)]) 276 #define dvRootSetFirstModpath(_Root, value) ((dvRoots.FirstModpath)[dvRoot2ValidIndex(_Root)] = (value)) 277 #define dvRootGetLastModpath(_Root) (dvRoots.LastModpath[dvRoot2ValidIndex(_Root)]) 278 #define dvRootSetLastModpath(_Root, value) ((dvRoots.LastModpath)[dvRoot2ValidIndex(_Root)] = (value)) 279 #define dvRootGetModpathTableIndex(_Root) (dvRoots.ModpathTableIndex[dvRoot2ValidIndex(_Root)]) 280 #define dvRootSetModpathTableIndex(_Root, value) ((dvRoots.ModpathTableIndex)[dvRoot2ValidIndex(_Root)] = (value)) 281 #define dvRootGetNumModpathTable(_Root) (dvRoots.NumModpathTable[dvRoot2ValidIndex(_Root)]) 282 #define dvRootSetNumModpathTable(_Root, value) ((dvRoots.NumModpathTable)[dvRoot2ValidIndex(_Root)] = (value)) 283 #if defined(DD_DEBUG) 284 #define dvRootCheckModpathTableIndex(Root, x) ((uint32)(x) < dvRootGetNumModpathTable(Root)? (x) : \ 285 (utAssert(false),(x))) 286 #else 287 #define dvRootCheckModpathTableIndex(Root, x) (x) 288 #endif 289 #define dvRootGetiModpathTable(_Root, x) ((dvRoots.ModpathTable)[ \ 290 dvRootGetModpathTableIndex(_Root) + dvRootCheckModpathTableIndex(_Root, (x))]) 291 #define dvRootGetModpathTable(Root) (dvRoots.ModpathTable + dvRootGetModpathTableIndex(Root)) 292 #define dvRootGetModpathTables dvRootGetModpathTable 293 #define dvRootSetModpathTable(Root, valuePtr, numModpathTable) (dvRootResizeModpathTables(Root, numModpathTable), memcpy(dvRootGetModpathTables(Root), valuePtr, \ 294 numModpathTable*sizeof(dvModpath))) 295 #define dvRootSetiModpathTable(Root, x, value) ((dvRoots.ModpathTable)[ \ 296 dvRootGetModpathTableIndex(Root) + dvRootCheckModpathTableIndex(Root, (x))] = (value)) 297 #define dvRootGetNumModpath(_Root) (dvRoots.NumModpath[dvRoot2ValidIndex(_Root)]) 298 #define dvRootSetNumModpath(_Root, value) ((dvRoots.NumModpath)[dvRoot2ValidIndex(_Root)] = (value)) 299 #define dvRootGetFirstModule(_Root) (dvRoots.FirstModule[dvRoot2ValidIndex(_Root)]) 300 #define dvRootSetFirstModule(_Root, value) ((dvRoots.FirstModule)[dvRoot2ValidIndex(_Root)] = (value)) 301 #define dvRootGetLastModule(_Root) (dvRoots.LastModule[dvRoot2ValidIndex(_Root)]) 302 #define dvRootSetLastModule(_Root, value) ((dvRoots.LastModule)[dvRoot2ValidIndex(_Root)] = (value)) 303 #define dvRootGetModuleTableIndex(_Root) (dvRoots.ModuleTableIndex[dvRoot2ValidIndex(_Root)]) 304 #define dvRootSetModuleTableIndex(_Root, value) ((dvRoots.ModuleTableIndex)[dvRoot2ValidIndex(_Root)] = (value)) 305 #define dvRootGetNumModuleTable(_Root) (dvRoots.NumModuleTable[dvRoot2ValidIndex(_Root)]) 306 #define dvRootSetNumModuleTable(_Root, value) ((dvRoots.NumModuleTable)[dvRoot2ValidIndex(_Root)] = (value)) 307 #if defined(DD_DEBUG) 308 #define dvRootCheckModuleTableIndex(Root, x) ((uint32)(x) < dvRootGetNumModuleTable(Root)? (x) : \ 309 (utAssert(false),(x))) 310 #else 311 #define dvRootCheckModuleTableIndex(Root, x) (x) 312 #endif 313 #define dvRootGetiModuleTable(_Root, x) ((dvRoots.ModuleTable)[ \ 314 dvRootGetModuleTableIndex(_Root) + dvRootCheckModuleTableIndex(_Root, (x))]) 315 #define dvRootGetModuleTable(Root) (dvRoots.ModuleTable + dvRootGetModuleTableIndex(Root)) 316 #define dvRootGetModuleTables dvRootGetModuleTable 317 #define dvRootSetModuleTable(Root, valuePtr, numModuleTable) (dvRootResizeModuleTables(Root, numModuleTable), memcpy(dvRootGetModuleTables(Root), valuePtr, \ 318 numModuleTable*sizeof(dvModule))) 319 #define dvRootSetiModuleTable(Root, x, value) ((dvRoots.ModuleTable)[ \ 320 dvRootGetModuleTableIndex(Root) + dvRootCheckModuleTableIndex(Root, (x))] = (value)) 321 #define dvRootGetNumModule(_Root) (dvRoots.NumModule[dvRoot2ValidIndex(_Root)]) 322 #define dvRootSetNumModule(_Root, value) ((dvRoots.NumModule)[dvRoot2ValidIndex(_Root)] = (value)) 323 dvModpath dvRootFindModpath(dvRoot Root, utSym Sym); 324 void dvRootRenameModpath(dvRoot Root, dvModpath _Modpath, utSym sym); 325 #define dvModpathGetName(Modpath) utSymGetName(dvModpathGetSym(Modpath)) 326 #define dvForeachRootModpath(pVar, cVar) \ 327 for(cVar = dvRootGetFirstModpath(pVar); cVar != dvModpathNull; \ 328 cVar = dvModpathGetNextRootModpath(cVar)) 329 #define dvEndRootModpath 330 #define dvSafeForeachRootModpath(pVar, cVar) { \ 331 dvModpath _nextModpath; \ 332 for(cVar = dvRootGetFirstModpath(pVar); cVar != dvModpathNull; cVar = _nextModpath) { \ 333 _nextModpath = dvModpathGetNextRootModpath(cVar); 334 #define dvEndSafeRootModpath }} 335 dvModule dvRootFindModule(dvRoot Root, utSym Sym); 336 void dvRootRenameModule(dvRoot Root, dvModule _Module, utSym sym); 337 #define dvModuleGetName(Module) utSymGetName(dvModuleGetSym(Module)) 338 #define dvForeachRootModule(pVar, cVar) \ 339 for(cVar = dvRootGetFirstModule(pVar); cVar != dvModuleNull; \ 340 cVar = dvModuleGetNextRootModule(cVar)) 341 #define dvEndRootModule 342 #define dvSafeForeachRootModule(pVar, cVar) { \ 343 dvModule _nextModule; \ 344 for(cVar = dvRootGetFirstModule(pVar); cVar != dvModuleNull; cVar = _nextModule) { \ 345 _nextModule = dvModuleGetNextRootModule(cVar); 346 #define dvEndSafeRootModule }} 347 #define dvRootSetConstructorCallback(func) (dvRootConstructorCallback = (func)) 348 #define dvRootGetConstructorCallback() (dvRootConstructorCallback) 349 #define dvFirstRoot() (dvRootData.usedRoot == 0? dvRootNull : dvIndex2Root(0)) 350 #define dvLastRoot() (dvRootData.usedRoot == 0? dvRootNull : \ 351 dvIndex2Root(dvRootData.usedRoot - 1)) 352 #define dvNextRoot(Root) (dvRoot2ValidIndex(Root) + 1 == dvRootData.usedRoot? dvRootNull : \ 353 (Root) + 1) 354 #define dvPrevRoot(Root) (dvRoot2ValidIndex(Root) == 0? dvRootNull : (Root) - 1) 355 #define dvForeachRoot(var) \ 356 for(var = dvIndex2Root(0); dvRoot2Index(var) != dvRootData.usedRoot; var++) 357 #define dvEndRoot 358 #define dvRootFreeAll() (dvSetUsedRoot(0), dvSetUsedRootModpathTable(0), dvSetUsedRootModuleTable(0)) 359 #define dvRootAllocRaw() ( \ 360 dvRootData.usedRoot == dvRootData.allocatedRoot && (dvRootAllocMore(), true), \ 361 dvTemp_.Root = dvIndex2Root(dvRootData.usedRoot), \ 362 dvSetUsedRoot(dvUsedRoot() + 1), \ 363 dvTemp_.Root) 364 #define dvRootAlloc() ( \ 365 dvRootData.usedRoot == dvRootData.allocatedRoot && (dvRootAllocMore(), true), \ 366 dvTemp_.Root = dvIndex2Root(dvRootData.usedRoot), \ 367 dvSetUsedRoot(dvUsedRoot() + 1), \ 368 dvRootSetFirstModpath(dvTemp_.Root, dvModpathNull), \ 369 dvRootSetLastModpath(dvTemp_.Root, dvModpathNull), \ 370 dvRootSetModpathTableIndex(dvTemp_.Root, 0), \ 371 dvRootSetNumModpathTable(dvTemp_.Root, 0), \ 372 dvRootSetNumModpathTable(dvTemp_.Root, 0), \ 373 dvRootSetNumModpath(dvTemp_.Root, 0), \ 374 dvRootSetFirstModule(dvTemp_.Root, dvModuleNull), \ 375 dvRootSetLastModule(dvTemp_.Root, dvModuleNull), \ 376 dvRootSetModuleTableIndex(dvTemp_.Root, 0), \ 377 dvRootSetNumModuleTable(dvTemp_.Root, 0), \ 378 dvRootSetNumModuleTable(dvTemp_.Root, 0), \ 379 dvRootSetNumModule(dvTemp_.Root, 0), \ 380 dvRootConstructorCallback != NULL && (dvRootConstructorCallback(dvTemp_.Root), true), \ 381 dvTemp_.Root) 382 383 void dvRootAllocMore(void); 384 void dvRootCopyProps(dvRoot dvOldRoot, dvRoot dvNewRoot); 385 void dvRootAllocModpathTables(dvRoot Root, uint32 numModpathTables); 386 void dvRootResizeModpathTables(dvRoot Root, uint32 numModpathTables); 387 void dvRootFreeModpathTables(dvRoot Root); 388 void dvCompactRootModpathTables(void); 389 void dvRootAllocModuleTables(dvRoot Root, uint32 numModuleTables); 390 void dvRootResizeModuleTables(dvRoot Root, uint32 numModuleTables); 391 void dvRootFreeModuleTables(dvRoot Root); 392 void dvCompactRootModuleTables(void); 393 void dvRootInsertModpath(dvRoot Root, dvModpath _Modpath); 394 void dvRootRemoveModpath(dvRoot Root, dvModpath _Modpath); 395 void dvRootInsertAfterModpath(dvRoot Root, dvModpath prevModpath, dvModpath _Modpath); 396 void dvRootAppendModpath(dvRoot Root, dvModpath _Modpath); 397 void dvRootInsertModule(dvRoot Root, dvModule _Module); 398 void dvRootRemoveModule(dvRoot Root, dvModule _Module); 399 void dvRootInsertAfterModule(dvRoot Root, dvModule prevModule, dvModule _Module); 400 void dvRootAppendModule(dvRoot Root, dvModule _Module); 401 402 /*---------------------------------------------------------------------------------------- 403 Fields for class Modpath. 404 ----------------------------------------------------------------------------------------*/ 405 struct dvModpathFields { 406 utSym *Sym; 407 dvRoot *Root; 408 dvModpath *NextRootModpath; 409 dvModpath *PrevRootModpath; 410 dvModpath *NextTableRootModpath; 411 }; 412 extern struct dvModpathFields dvModpaths; 413 414 #define dvModpathGetSym(_Modpath) (dvModpaths.Sym[dvModpath2ValidIndex(_Modpath)]) 415 #define dvModpathSetSym(_Modpath, value) ((dvModpaths.Sym)[dvModpath2ValidIndex(_Modpath)] = (value)) 416 #define dvModpathGetRoot(_Modpath) (dvModpaths.Root[dvModpath2ValidIndex(_Modpath)]) 417 #define dvModpathSetRoot(_Modpath, value) ((dvModpaths.Root)[dvModpath2ValidIndex(_Modpath)] = (value)) 418 #define dvModpathGetNextRootModpath(_Modpath) (dvModpaths.NextRootModpath[dvModpath2ValidIndex(_Modpath)]) 419 #define dvModpathSetNextRootModpath(_Modpath, value) ((dvModpaths.NextRootModpath)[dvModpath2ValidIndex(_Modpath)] = (value)) 420 #define dvModpathGetPrevRootModpath(_Modpath) (dvModpaths.PrevRootModpath[dvModpath2ValidIndex(_Modpath)]) 421 #define dvModpathSetPrevRootModpath(_Modpath, value) ((dvModpaths.PrevRootModpath)[dvModpath2ValidIndex(_Modpath)] = (value)) 422 #define dvModpathGetNextTableRootModpath(_Modpath) (dvModpaths.NextTableRootModpath[dvModpath2ValidIndex(_Modpath)]) 423 #define dvModpathSetNextTableRootModpath(_Modpath, value) ((dvModpaths.NextTableRootModpath)[dvModpath2ValidIndex(_Modpath)] = (value)) 424 #define dvModpathSetConstructorCallback(func) (dvModpathConstructorCallback = (func)) 425 #define dvModpathGetConstructorCallback() (dvModpathConstructorCallback) 426 #define dvFirstModpath() (dvRootData.usedModpath == 0? dvModpathNull : dvIndex2Modpath(0)) 427 #define dvLastModpath() (dvRootData.usedModpath == 0? dvModpathNull : \ 428 dvIndex2Modpath(dvRootData.usedModpath - 1)) 429 #define dvNextModpath(Modpath) (dvModpath2ValidIndex(Modpath) + 1 == dvRootData.usedModpath? dvModpathNull : \ 430 (Modpath) + 1) 431 #define dvPrevModpath(Modpath) (dvModpath2ValidIndex(Modpath) == 0? dvModpathNull : (Modpath) - 1) 432 #define dvForeachModpath(var) \ 433 for(var = dvIndex2Modpath(0); dvModpath2Index(var) != dvRootData.usedModpath; var++) 434 #define dvEndModpath 435 #define dvModpathFreeAll() (dvSetUsedModpath(0)) 436 #define dvModpathAllocRaw() ( \ 437 dvRootData.usedModpath == dvRootData.allocatedModpath && (dvModpathAllocMore(), true), \ 438 dvTemp_.Modpath = dvIndex2Modpath(dvRootData.usedModpath), \ 439 dvSetUsedModpath(dvUsedModpath() + 1), \ 440 dvTemp_.Modpath) 441 #define dvModpathAlloc() ( \ 442 dvRootData.usedModpath == dvRootData.allocatedModpath && (dvModpathAllocMore(), true), \ 443 dvTemp_.Modpath = dvIndex2Modpath(dvRootData.usedModpath), \ 444 dvSetUsedModpath(dvUsedModpath() + 1), \ 445 dvModpathSetSym(dvTemp_.Modpath, utSymNull), \ 446 dvModpathSetRoot(dvTemp_.Modpath, dvRootNull), \ 447 dvModpathSetNextRootModpath(dvTemp_.Modpath, dvModpathNull), \ 448 dvModpathSetPrevRootModpath(dvTemp_.Modpath, dvModpathNull), \ 449 dvModpathSetNextTableRootModpath(dvTemp_.Modpath, dvModpathNull), \ 450 dvModpathConstructorCallback != NULL && (dvModpathConstructorCallback(dvTemp_.Modpath), true), \ 451 dvTemp_.Modpath) 452 453 void dvModpathAllocMore(void); 454 void dvModpathCopyProps(dvModpath dvOldModpath, dvModpath dvNewModpath); 455 456 /*---------------------------------------------------------------------------------------- 457 Fields for class Module. 458 ----------------------------------------------------------------------------------------*/ 459 struct dvModuleFields { 460 utSym *Sym; 461 utSym *PrefixSym; 462 uint8 *Persistent; 463 uint8 *UndoRedo; 464 uint8 *HasSparseData; 465 uint16 *NumFields; 466 uint32 *NumClasses; 467 uint32 *NumEnums; 468 dvModule *NextRootModule; 469 dvModule *PrevRootModule; 470 dvModule *NextTableRootModule; 471 dvClass *FirstClass; 472 dvClass *LastClass; 473 uint32 *ClassTableIndex; 474 uint32 *NumClassTable; 475 dvClass *ClassTable; 476 uint32 *NumClass; 477 dvEnum *FirstEnum; 478 dvEnum *LastEnum; 479 uint32 *EnumTableIndex; 480 uint32 *NumEnumTable; 481 dvEnum *EnumTable; 482 uint32 *NumEnum; 483 dvTypedef *FirstTypedef; 484 dvTypedef *LastTypedef; 485 uint32 *TypedefTableIndex; 486 uint32 *NumTypedefTable; 487 dvTypedef *TypedefTable; 488 uint32 *NumTypedef; 489 dvSchema *FirstSchema; 490 dvSchema *LastSchema; 491 uint32 *SchemaTableIndex; 492 uint32 *NumSchemaTable; 493 dvSchema *SchemaTable; 494 uint32 *NumSchema; 495 dvLink *FirstImportLink; 496 dvLink *LastImportLink; 497 dvLink *FirstExportLink; 498 dvLink *LastExportLink; 499 }; 500 extern struct dvModuleFields dvModules; 501 502 #define dvModuleGetSym(_Module) (dvModules.Sym[dvModule2ValidIndex(_Module)]) 503 #define dvModuleSetSym(_Module, value) ((dvModules.Sym)[dvModule2ValidIndex(_Module)] = (value)) 504 #define dvModuleGetPrefixSym(_Module) (dvModules.PrefixSym[dvModule2ValidIndex(_Module)]) 505 #define dvModuleSetPrefixSym(_Module, value) ((dvModules.PrefixSym)[dvModule2ValidIndex(_Module)] = (value)) 506 #define dvModulePersistent(_Module) (((dvModules.Persistent)[dvModule2ValidIndex(_Module) >> 3] >> \ 507 (dvModule2ValidIndex(_Module) & 7)) & 1) 508 #define dvModuleSetPersistent(_Module, value) ((dvModules.Persistent)[dvModule2ValidIndex(_Module) >> 3] = \ 509 (uint8)(((dvModules.Persistent)[dvModule2ValidIndex(_Module) >> 3] & ~(1 << (dvModule2ValidIndex(_Module) & 7))) | \ 510 (((value) != 0) << (dvModule2ValidIndex(_Module) & 7)))) 511 #define dvModuleUndoRedo(_Module) (((dvModules.UndoRedo)[dvModule2ValidIndex(_Module) >> 3] >> \ 512 (dvModule2ValidIndex(_Module) & 7)) & 1) 513 #define dvModuleSetUndoRedo(_Module, value) ((dvModules.UndoRedo)[dvModule2ValidIndex(_Module) >> 3] = \ 514 (uint8)(((dvModules.UndoRedo)[dvModule2ValidIndex(_Module) >> 3] & ~(1 << (dvModule2ValidIndex(_Module) & 7))) | \ 515 (((value) != 0) << (dvModule2ValidIndex(_Module) & 7)))) 516 #define dvModuleHasSparseData(_Module) (((dvModules.HasSparseData)[dvModule2ValidIndex(_Module) >> 3] >> \ 517 (dvModule2ValidIndex(_Module) & 7)) & 1) 518 #define dvModuleSetHasSparseData(_Module, value) ((dvModules.HasSparseData)[dvModule2ValidIndex(_Module) >> 3] = \ 519 (uint8)(((dvModules.HasSparseData)[dvModule2ValidIndex(_Module) >> 3] & ~(1 << (dvModule2ValidIndex(_Module) & 7))) | \ 520 (((value) != 0) << (dvModule2ValidIndex(_Module) & 7)))) 521 #define dvModuleGetNumFields(_Module) (dvModules.NumFields[dvModule2ValidIndex(_Module)]) 522 #define dvModuleSetNumFields(_Module, value) ((dvModules.NumFields)[dvModule2ValidIndex(_Module)] = (value)) 523 #define dvModuleGetNumClasses(_Module) (dvModules.NumClasses[dvModule2ValidIndex(_Module)]) 524 #define dvModuleSetNumClasses(_Module, value) ((dvModules.NumClasses)[dvModule2ValidIndex(_Module)] = (value)) 525 #define dvModuleGetNumEnums(_Module) (dvModules.NumEnums[dvModule2ValidIndex(_Module)]) 526 #define dvModuleSetNumEnums(_Module, value) ((dvModules.NumEnums)[dvModule2ValidIndex(_Module)] = (value)) 527 #define dvModuleGetNextRootModule(_Module) (dvModules.NextRootModule[dvModule2ValidIndex(_Module)]) 528 #define dvModuleSetNextRootModule(_Module, value) ((dvModules.NextRootModule)[dvModule2ValidIndex(_Module)] = (value)) 529 #define dvModuleGetPrevRootModule(_Module) (dvModules.PrevRootModule[dvModule2ValidIndex(_Module)]) 530 #define dvModuleSetPrevRootModule(_Module, value) ((dvModules.PrevRootModule)[dvModule2ValidIndex(_Module)] = (value)) 531 #define dvModuleGetNextTableRootModule(_Module) (dvModules.NextTableRootModule[dvModule2ValidIndex(_Module)]) 532 #define dvModuleSetNextTableRootModule(_Module, value) ((dvModules.NextTableRootModule)[dvModule2ValidIndex(_Module)] = (value)) 533 #define dvModuleGetFirstClass(_Module) (dvModules.FirstClass[dvModule2ValidIndex(_Module)]) 534 #define dvModuleSetFirstClass(_Module, value) ((dvModules.FirstClass)[dvModule2ValidIndex(_Module)] = (value)) 535 #define dvModuleGetLastClass(_Module) (dvModules.LastClass[dvModule2ValidIndex(_Module)]) 536 #define dvModuleSetLastClass(_Module, value) ((dvModules.LastClass)[dvModule2ValidIndex(_Module)] = (value)) 537 #define dvModuleGetClassTableIndex(_Module) (dvModules.ClassTableIndex[dvModule2ValidIndex(_Module)]) 538 #define dvModuleSetClassTableIndex(_Module, value) ((dvModules.ClassTableIndex)[dvModule2ValidIndex(_Module)] = (value)) 539 #define dvModuleGetNumClassTable(_Module) (dvModules.NumClassTable[dvModule2ValidIndex(_Module)]) 540 #define dvModuleSetNumClassTable(_Module, value) ((dvModules.NumClassTable)[dvModule2ValidIndex(_Module)] = (value)) 541 #if defined(DD_DEBUG) 542 #define dvModuleCheckClassTableIndex(Module, x) ((uint32)(x) < dvModuleGetNumClassTable(Module)? (x) : \ 543 (utAssert(false),(x))) 544 #else 545 #define dvModuleCheckClassTableIndex(Module, x) (x) 546 #endif 547 #define dvModuleGetiClassTable(_Module, x) ((dvModules.ClassTable)[ \ 548 dvModuleGetClassTableIndex(_Module) + dvModuleCheckClassTableIndex(_Module, (x))]) 549 #define dvModuleGetClassTable(Module) (dvModules.ClassTable + dvModuleGetClassTableIndex(Module)) 550 #define dvModuleGetClassTables dvModuleGetClassTable 551 #define dvModuleSetClassTable(Module, valuePtr, numClassTable) (dvModuleResizeClassTables(Module, numClassTable), memcpy(dvModuleGetClassTables(Module), valuePtr, \ 552 numClassTable*sizeof(dvClass))) 553 #define dvModuleSetiClassTable(Module, x, value) ((dvModules.ClassTable)[ \ 554 dvModuleGetClassTableIndex(Module) + dvModuleCheckClassTableIndex(Module, (x))] = (value)) 555 #define dvModuleGetNumClass(_Module) (dvModules.NumClass[dvModule2ValidIndex(_Module)]) 556 #define dvModuleSetNumClass(_Module, value) ((dvModules.NumClass)[dvModule2ValidIndex(_Module)] = (value)) 557 #define dvModuleGetFirstEnum(_Module) (dvModules.FirstEnum[dvModule2ValidIndex(_Module)]) 558 #define dvModuleSetFirstEnum(_Module, value) ((dvModules.FirstEnum)[dvModule2ValidIndex(_Module)] = (value)) 559 #define dvModuleGetLastEnum(_Module) (dvModules.LastEnum[dvModule2ValidIndex(_Module)]) 560 #define dvModuleSetLastEnum(_Module, value) ((dvModules.LastEnum)[dvModule2ValidIndex(_Module)] = (value)) 561 #define dvModuleGetEnumTableIndex(_Module) (dvModules.EnumTableIndex[dvModule2ValidIndex(_Module)]) 562 #define dvModuleSetEnumTableIndex(_Module, value) ((dvModules.EnumTableIndex)[dvModule2ValidIndex(_Module)] = (value)) 563 #define dvModuleGetNumEnumTable(_Module) (dvModules.NumEnumTable[dvModule2ValidIndex(_Module)]) 564 #define dvModuleSetNumEnumTable(_Module, value) ((dvModules.NumEnumTable)[dvModule2ValidIndex(_Module)] = (value)) 565 #if defined(DD_DEBUG) 566 #define dvModuleCheckEnumTableIndex(Module, x) ((uint32)(x) < dvModuleGetNumEnumTable(Module)? (x) : \ 567 (utAssert(false),(x))) 568 #else 569 #define dvModuleCheckEnumTableIndex(Module, x) (x) 570 #endif 571 #define dvModuleGetiEnumTable(_Module, x) ((dvModules.EnumTable)[ \ 572 dvModuleGetEnumTableIndex(_Module) + dvModuleCheckEnumTableIndex(_Module, (x))]) 573 #define dvModuleGetEnumTable(Module) (dvModules.EnumTable + dvModuleGetEnumTableIndex(Module)) 574 #define dvModuleGetEnumTables dvModuleGetEnumTable 575 #define dvModuleSetEnumTable(Module, valuePtr, numEnumTable) (dvModuleResizeEnumTables(Module, numEnumTable), memcpy(dvModuleGetEnumTables(Module), valuePtr, \ 576 numEnumTable*sizeof(dvEnum))) 577 #define dvModuleSetiEnumTable(Module, x, value) ((dvModules.EnumTable)[ \ 578 dvModuleGetEnumTableIndex(Module) + dvModuleCheckEnumTableIndex(Module, (x))] = (value)) 579 #define dvModuleGetNumEnum(_Module) (dvModules.NumEnum[dvModule2ValidIndex(_Module)]) 580 #define dvModuleSetNumEnum(_Module, value) ((dvModules.NumEnum)[dvModule2ValidIndex(_Module)] = (value)) 581 #define dvModuleGetFirstTypedef(_Module) (dvModules.FirstTypedef[dvModule2ValidIndex(_Module)]) 582 #define dvModuleSetFirstTypedef(_Module, value) ((dvModules.FirstTypedef)[dvModule2ValidIndex(_Module)] = (value)) 583 #define dvModuleGetLastTypedef(_Module) (dvModules.LastTypedef[dvModule2ValidIndex(_Module)]) 584 #define dvModuleSetLastTypedef(_Module, value) ((dvModules.LastTypedef)[dvModule2ValidIndex(_Module)] = (value)) 585 #define dvModuleGetTypedefTableIndex(_Module) (dvModules.TypedefTableIndex[dvModule2ValidIndex(_Module)]) 586 #define dvModuleSetTypedefTableIndex(_Module, value) ((dvModules.TypedefTableIndex)[dvModule2ValidIndex(_Module)] = (value)) 587 #define dvModuleGetNumTypedefTable(_Module) (dvModules.NumTypedefTable[dvModule2ValidIndex(_Module)]) 588 #define dvModuleSetNumTypedefTable(_Module, value) ((dvModules.NumTypedefTable)[dvModule2ValidIndex(_Module)] = (value)) 589 #if defined(DD_DEBUG) 590 #define dvModuleCheckTypedefTableIndex(Module, x) ((uint32)(x) < dvModuleGetNumTypedefTable(Module)? (x) : \ 591 (utAssert(false),(x))) 592 #else 593 #define dvModuleCheckTypedefTableIndex(Module, x) (x) 594 #endif 595 #define dvModuleGetiTypedefTable(_Module, x) ((dvModules.TypedefTable)[ \ 596 dvModuleGetTypedefTableIndex(_Module) + dvModuleCheckTypedefTableIndex(_Module, (x))]) 597 #define dvModuleGetTypedefTable(Module) (dvModules.TypedefTable + dvModuleGetTypedefTableIndex(Module)) 598 #define dvModuleGetTypedefTables dvModuleGetTypedefTable 599 #define dvModuleSetTypedefTable(Module, valuePtr, numTypedefTable) (dvModuleResizeTypedefTables(Module, numTypedefTable), memcpy(dvModuleGetTypedefTables(Module), valuePtr, \ 600 numTypedefTable*sizeof(dvTypedef))) 601 #define dvModuleSetiTypedefTable(Module, x, value) ((dvModules.TypedefTable)[ \ 602 dvModuleGetTypedefTableIndex(Module) + dvModuleCheckTypedefTableIndex(Module, (x))] = (value)) 603 #define dvModuleGetNumTypedef(_Module) (dvModules.NumTypedef[dvModule2ValidIndex(_Module)]) 604 #define dvModuleSetNumTypedef(_Module, value) ((dvModules.NumTypedef)[dvModule2ValidIndex(_Module)] = (value)) 605 #define dvModuleGetFirstSchema(_Module) (dvModules.FirstSchema[dvModule2ValidIndex(_Module)]) 606 #define dvModuleSetFirstSchema(_Module, value) ((dvModules.FirstSchema)[dvModule2ValidIndex(_Module)] = (value)) 607 #define dvModuleGetLastSchema(_Module) (dvModules.LastSchema[dvModule2ValidIndex(_Module)]) 608 #define dvModuleSetLastSchema(_Module, value) ((dvModules.LastSchema)[dvModule2ValidIndex(_Module)] = (value)) 609 #define dvModuleGetSchemaTableIndex(_Module) (dvModules.SchemaTableIndex[dvModule2ValidIndex(_Module)]) 610 #define dvModuleSetSchemaTableIndex(_Module, value) ((dvModules.SchemaTableIndex)[dvModule2ValidIndex(_Module)] = (value)) 611 #define dvModuleGetNumSchemaTable(_Module) (dvModules.NumSchemaTable[dvModule2ValidIndex(_Module)]) 612 #define dvModuleSetNumSchemaTable(_Module, value) ((dvModules.NumSchemaTable)[dvModule2ValidIndex(_Module)] = (value)) 613 #if defined(DD_DEBUG) 614 #define dvModuleCheckSchemaTableIndex(Module, x) ((uint32)(x) < dvModuleGetNumSchemaTable(Module)? (x) : \ 615 (utAssert(false),(x))) 616 #else 617 #define dvModuleCheckSchemaTableIndex(Module, x) (x) 618 #endif 619 #define dvModuleGetiSchemaTable(_Module, x) ((dvModules.SchemaTable)[ \ 620 dvModuleGetSchemaTableIndex(_Module) + dvModuleCheckSchemaTableIndex(_Module, (x))]) 621 #define dvModuleGetSchemaTable(Module) (dvModules.SchemaTable + dvModuleGetSchemaTableIndex(Module)) 622 #define dvModuleGetSchemaTables dvModuleGetSchemaTable 623 #define dvModuleSetSchemaTable(Module, valuePtr, numSchemaTable) (dvModuleResizeSchemaTables(Module, numSchemaTable), memcpy(dvModuleGetSchemaTables(Module), valuePtr, \ 624 numSchemaTable*sizeof(dvSchema))) 625 #define dvModuleSetiSchemaTable(Module, x, value) ((dvModules.SchemaTable)[ \ 626 dvModuleGetSchemaTableIndex(Module) + dvModuleCheckSchemaTableIndex(Module, (x))] = (value)) 627 #define dvModuleGetNumSchema(_Module) (dvModules.NumSchema[dvModule2ValidIndex(_Module)]) 628 #define dvModuleSetNumSchema(_Module, value) ((dvModules.NumSchema)[dvModule2ValidIndex(_Module)] = (value)) 629 #define dvModuleGetFirstImportLink(_Module) (dvModules.FirstImportLink[dvModule2ValidIndex(_Module)]) 630 #define dvModuleSetFirstImportLink(_Module, value) ((dvModules.FirstImportLink)[dvModule2ValidIndex(_Module)] = (value)) 631 #define dvModuleGetLastImportLink(_Module) (dvModules.LastImportLink[dvModule2ValidIndex(_Module)]) 632 #define dvModuleSetLastImportLink(_Module, value) ((dvModules.LastImportLink)[dvModule2ValidIndex(_Module)] = (value)) 633 #define dvModuleGetFirstExportLink(_Module) (dvModules.FirstExportLink[dvModule2ValidIndex(_Module)]) 634 #define dvModuleSetFirstExportLink(_Module, value) ((dvModules.FirstExportLink)[dvModule2ValidIndex(_Module)] = (value)) 635 #define dvModuleGetLastExportLink(_Module) (dvModules.LastExportLink[dvModule2ValidIndex(_Module)]) 636 #define dvModuleSetLastExportLink(_Module, value) ((dvModules.LastExportLink)[dvModule2ValidIndex(_Module)] = (value)) 637 dvClass dvModuleFindClass(dvModule Module, utSym Sym); 638 void dvModuleRenameClass(dvModule Module, dvClass _Class, utSym sym); 639 #define dvClassGetName(Class) utSymGetName(dvClassGetSym(Class)) 640 #define dvForeachModuleClass(pVar, cVar) \ 641 for(cVar = dvModuleGetFirstClass(pVar); cVar != dvClassNull; \ 642 cVar = dvClassGetNextModuleClass(cVar)) 643 #define dvEndModuleClass 644 #define dvSafeForeachModuleClass(pVar, cVar) { \ 645 dvClass _nextClass; \ 646 for(cVar = dvModuleGetFirstClass(pVar); cVar != dvClassNull; cVar = _nextClass) { \ 647 _nextClass = dvClassGetNextModuleClass(cVar); 648 #define dvEndSafeModuleClass }} 649 dvEnum dvModuleFindEnum(dvModule Module, utSym Sym); 650 void dvModuleRenameEnum(dvModule Module, dvEnum _Enum, utSym sym); 651 #define dvEnumGetName(Enum) utSymGetName(dvEnumGetSym(Enum)) 652 #define dvForeachModuleEnum(pVar, cVar) \ 653 for(cVar = dvModuleGetFirstEnum(pVar); cVar != dvEnumNull; \ 654 cVar = dvEnumGetNextModuleEnum(cVar)) 655 #define dvEndModuleEnum 656 #define dvSafeForeachModuleEnum(pVar, cVar) { \ 657 dvEnum _nextEnum; \ 658 for(cVar = dvModuleGetFirstEnum(pVar); cVar != dvEnumNull; cVar = _nextEnum) { \ 659 _nextEnum = dvEnumGetNextModuleEnum(cVar); 660 #define dvEndSafeModuleEnum }} 661 dvTypedef dvModuleFindTypedef(dvModule Module, utSym Sym); 662 void dvModuleRenameTypedef(dvModule Module, dvTypedef _Typedef, utSym sym); 663 #define dvTypedefGetName(Typedef) utSymGetName(dvTypedefGetSym(Typedef)) 664 #define dvForeachModuleTypedef(pVar, cVar) \ 665 for(cVar = dvModuleGetFirstTypedef(pVar); cVar != dvTypedefNull; \ 666 cVar = dvTypedefGetNextModuleTypedef(cVar)) 667 #define dvEndModuleTypedef 668 #define dvSafeForeachModuleTypedef(pVar, cVar) { \ 669 dvTypedef _nextTypedef; \ 670 for(cVar = dvModuleGetFirstTypedef(pVar); cVar != dvTypedefNull; cVar = _nextTypedef) { \ 671 _nextTypedef = dvTypedefGetNextModuleTypedef(cVar); 672 #define dvEndSafeModuleTypedef }} 673 dvSchema dvModuleFindSchema(dvModule Module, utSym Sym); 674 void dvModuleRenameSchema(dvModule Module, dvSchema _Schema, utSym sym); 675 #define dvSchemaGetName(Schema) utSymGetName(dvSchemaGetSym(Schema)) 676 #define dvForeachModuleSchema(pVar, cVar) \ 677 for(cVar = dvModuleGetFirstSchema(pVar); cVar != dvSchemaNull; \ 678 cVar = dvSchemaGetNextModuleSchema(cVar)) 679 #define dvEndModuleSchema 680 #define dvSafeForeachModuleSchema(pVar, cVar) { \ 681 dvSchema _nextSchema; \ 682 for(cVar = dvModuleGetFirstSchema(pVar); cVar != dvSchemaNull; cVar = _nextSchema) { \ 683 _nextSchema = dvSchemaGetNextModuleSchema(cVar); 684 #define dvEndSafeModuleSchema }} 685 #define dvForeachModuleImportLink(pVar, cVar) \ 686 for(cVar = dvModuleGetFirstImportLink(pVar); cVar != dvLinkNull; \ 687 cVar = dvLinkGetNextModuleImportLink(cVar)) 688 #define dvEndModuleImportLink 689 #define dvSafeForeachModuleImportLink(pVar, cVar) { \ 690 dvLink _nextLink; \ 691 for(cVar = dvModuleGetFirstImportLink(pVar); cVar != dvLinkNull; cVar = _nextLink) { \ 692 _nextLink = dvLinkGetNextModuleImportLink(cVar); 693 #define dvEndSafeModuleImportLink }} 694 #define dvForeachModuleExportLink(pVar, cVar) \ 695 for(cVar = dvModuleGetFirstExportLink(pVar); cVar != dvLinkNull; \ 696 cVar = dvLinkGetNextModuleExportLink(cVar)) 697 #define dvEndModuleExportLink 698 #define dvSafeForeachModuleExportLink(pVar, cVar) { \ 699 dvLink _nextLink; \ 700 for(cVar = dvModuleGetFirstExportLink(pVar); cVar != dvLinkNull; cVar = _nextLink) { \ 701 _nextLink = dvLinkGetNextModuleExportLink(cVar); 702 #define dvEndSafeModuleExportLink }} 703 #define dvModuleSetConstructorCallback(func) (dvModuleConstructorCallback = (func)) 704 #define dvModuleGetConstructorCallback() (dvModuleConstructorCallback) 705 #define dvFirstModule() (dvRootData.usedModule == 0? dvModuleNull : dvIndex2Module(0)) 706 #define dvLastModule() (dvRootData.usedModule == 0? dvModuleNull : \ 707 dvIndex2Module(dvRootData.usedModule - 1)) 708 #define dvNextModule(Module) (dvModule2ValidIndex(Module) + 1 == dvRootData.usedModule? dvModuleNull : \ 709 (Module) + 1) 710 #define dvPrevModule(Module) (dvModule2ValidIndex(Module) == 0? dvModuleNull : (Module) - 1) 711 #define dvForeachModule(var) \ 712 for(var = dvIndex2Module(0); dvModule2Index(var) != dvRootData.usedModule; var++) 713 #define dvEndModule 714 #define dvModuleFreeAll() (dvSetUsedModule(0), dvSetUsedModuleClassTable(0), dvSetUsedModuleEnumTable(0), dvSetUsedModuleTypedefTable(0), dvSetUsedModuleSchemaTable(0)) 715 #define dvModuleAllocRaw() ( \ 716 dvRootData.usedModule == dvRootData.allocatedModule && (dvModuleAllocMore(), true), \ 717 dvTemp_.Module = dvIndex2Module(dvRootData.usedModule), \ 718 dvSetUsedModule(dvUsedModule() + 1), \ 719 dvTemp_.Module) 720 #define dvModuleAlloc() ( \ 721 dvRootData.usedModule == dvRootData.allocatedModule && (dvModuleAllocMore(), true), \ 722 dvTemp_.Module = dvIndex2Module(dvRootData.usedModule), \ 723 dvSetUsedModule(dvUsedModule() + 1), \ 724 dvModuleSetSym(dvTemp_.Module, utSymNull), \ 725 dvModuleSetPrefixSym(dvTemp_.Module, utSymNull), \ 726 dvModuleSetPersistent(dvTemp_.Module, 0), \ 727 dvModuleSetUndoRedo(dvTemp_.Module, 0), \ 728 dvModuleSetHasSparseData(dvTemp_.Module, 0), \ 729 dvModuleSetNumFields(dvTemp_.Module, 0), \ 730 dvModuleSetNumClasses(dvTemp_.Module, 0), \ 731 dvModuleSetNumEnums(dvTemp_.Module, 0), \ 732 dvModuleSetNextRootModule(dvTemp_.Module, dvModuleNull), \ 733 dvModuleSetPrevRootModule(dvTemp_.Module, dvModuleNull), \ 734 dvModuleSetNextTableRootModule(dvTemp_.Module, dvModuleNull), \ 735 dvModuleSetFirstClass(dvTemp_.Module, dvClassNull), \ 736 dvModuleSetLastClass(dvTemp_.Module, dvClassNull), \ 737 dvModuleSetClassTableIndex(dvTemp_.Module, 0), \ 738 dvModuleSetNumClassTable(dvTemp_.Module, 0), \ 739 dvModuleSetNumClassTable(dvTemp_.Module, 0), \ 740 dvModuleSetNumClass(dvTemp_.Module, 0), \ 741 dvModuleSetFirstEnum(dvTemp_.Module, dvEnumNull), \ 742 dvModuleSetLastEnum(dvTemp_.Module, dvEnumNull), \ 743 dvModuleSetEnumTableIndex(dvTemp_.Module, 0), \ 744 dvModuleSetNumEnumTable(dvTemp_.Module, 0), \ 745 dvModuleSetNumEnumTable(dvTemp_.Module, 0), \ 746 dvModuleSetNumEnum(dvTemp_.Module, 0), \ 747 dvModuleSetFirstTypedef(dvTemp_.Module, dvTypedefNull), \ 748 dvModuleSetLastTypedef(dvTemp_.Module, dvTypedefNull), \ 749 dvModuleSetTypedefTableIndex(dvTemp_.Module, 0), \ 750 dvModuleSetNumTypedefTable(dvTemp_.Module, 0), \ 751 dvModuleSetNumTypedefTable(dvTemp_.Module, 0), \ 752 dvModuleSetNumTypedef(dvTemp_.Module, 0), \ 753 dvModuleSetFirstSchema(dvTemp_.Module, dvSchemaNull), \ 754 dvModuleSetLastSchema(dvTemp_.Module, dvSchemaNull), \ 755 dvModuleSetSchemaTableIndex(dvTemp_.Module, 0), \ 756 dvModuleSetNumSchemaTable(dvTemp_.Module, 0), \ 757 dvModuleSetNumSchemaTable(dvTemp_.Module, 0), \ 758 dvModuleSetNumSchema(dvTemp_.Module, 0), \ 759 dvModuleSetFirstImportLink(dvTemp_.Module, dvLinkNull), \ 760 dvModuleSetLastImportLink(dvTemp_.Module, dvLinkNull), \ 761 dvModuleSetFirstExportLink(dvTemp_.Module, dvLinkNull), \ 762 dvModuleSetLastExportLink(dvTemp_.Module, dvLinkNull), \ 763 dvModuleConstructorCallback != NULL && (dvModuleConstructorCallback(dvTemp_.Module), true), \ 764 dvTemp_.Module) 765 766 void dvModuleAllocMore(void); 767 void dvModuleCopyProps(dvModule dvOldModule, dvModule dvNewModule); 768 void dvModuleSetBitfield(dvModule _Module, uint32 bitfield); 769 uint32 dvModuleGetBitfield(dvModule _Module); 770 void dvModuleAllocClassTables(dvModule Module, uint32 numClassTables); 771 void dvModuleResizeClassTables(dvModule Module, uint32 numClassTables); 772 void dvModuleFreeClassTables(dvModule Module); 773 void dvCompactModuleClassTables(void); 774 void dvModuleAllocEnumTables(dvModule Module, uint32 numEnumTables); 775 void dvModuleResizeEnumTables(dvModule Module, uint32 numEnumTables); 776 void dvModuleFreeEnumTables(dvModule Module); 777 void dvCompactModuleEnumTables(void); 778 void dvModuleAllocTypedefTables(dvModule Module, uint32 numTypedefTables); 779 void dvModuleResizeTypedefTables(dvModule Module, uint32 numTypedefTables); 780 void dvModuleFreeTypedefTables(dvModule Module); 781 void dvCompactModuleTypedefTables(void); 782 void dvModuleAllocSchemaTables(dvModule Module, uint32 numSchemaTables); 783 void dvModuleResizeSchemaTables(dvModule Module, uint32 numSchemaTables); 784 void dvModuleFreeSchemaTables(dvModule Module); 785 void dvCompactModuleSchemaTables(void); 786 void dvModuleInsertClass(dvModule Module, dvClass _Class); 787 void dvModuleRemoveClass(dvModule Module, dvClass _Class); 788 void dvModuleInsertAfterClass(dvModule Module, dvClass prevClass, dvClass _Class); 789 void dvModuleAppendClass(dvModule Module, dvClass _Class); 790 void dvModuleInsertEnum(dvModule Module, dvEnum _Enum); 791 void dvModuleRemoveEnum(dvModule Module, dvEnum _Enum); 792 void dvModuleInsertAfterEnum(dvModule Module, dvEnum prevEnum, dvEnum _Enum); 793 void dvModuleAppendEnum(dvModule Module, dvEnum _Enum); 794 void dvModuleInsertTypedef(dvModule Module, dvTypedef _Typedef); 795 void dvModuleRemoveTypedef(dvModule Module, dvTypedef _Typedef); 796 void dvModuleInsertAfterTypedef(dvModule Module, dvTypedef prevTypedef, dvTypedef _Typedef); 797 void dvModuleAppendTypedef(dvModule Module, dvTypedef _Typedef); 798 void dvModuleInsertSchema(dvModule Module, dvSchema _Schema); 799 void dvModuleRemoveSchema(dvModule Module, dvSchema _Schema); 800 void dvModuleInsertAfterSchema(dvModule Module, dvSchema prevSchema, dvSchema _Schema); 801 void dvModuleAppendSchema(dvModule Module, dvSchema _Schema); 802 void dvModuleInsertImportLink(dvModule Module, dvLink _Link); 803 void dvModuleRemoveImportLink(dvModule Module, dvLink _Link); 804 void dvModuleInsertAfterImportLink(dvModule Module, dvLink prevLink, dvLink _Link); 805 void dvModuleAppendImportLink(dvModule Module, dvLink _Link); 806 void dvModuleInsertExportLink(dvModule Module, dvLink _Link); 807 void dvModuleRemoveExportLink(dvModule Module, dvLink _Link); 808 void dvModuleInsertAfterExportLink(dvModule Module, dvLink prevLink, dvLink _Link); 809 void dvModuleAppendExportLink(dvModule Module, dvLink _Link); 810 811 /*---------------------------------------------------------------------------------------- 812 Fields for class Link. 813 ----------------------------------------------------------------------------------------*/ 814 struct dvLinkFields { 815 dvModule *ImportModule; 816 dvLink *NextModuleImportLink; 817 dvModule *ExportModule; 818 dvLink *NextModuleExportLink; 819 }; 820 extern struct dvLinkFields dvLinks; 821 822 #define dvLinkGetImportModule(_Link) (dvLinks.ImportModule[dvLink2ValidIndex(_Link)]) 823 #define dvLinkSetImportModule(_Link, value) ((dvLinks.ImportModule)[dvLink2ValidIndex(_Link)] = (value)) 824 #define dvLinkGetNextModuleImportLink(_Link) (dvLinks.NextModuleImportLink[dvLink2ValidIndex(_Link)]) 825 #define dvLinkSetNextModuleImportLink(_Link, value) ((dvLinks.NextModuleImportLink)[dvLink2ValidIndex(_Link)] = (value)) 826 #define dvLinkGetExportModule(_Link) (dvLinks.ExportModule[dvLink2ValidIndex(_Link)]) 827 #define dvLinkSetExportModule(_Link, value) ((dvLinks.ExportModule)[dvLink2ValidIndex(_Link)] = (value)) 828 #define dvLinkGetNextModuleExportLink(_Link) (dvLinks.NextModuleExportLink[dvLink2ValidIndex(_Link)]) 829 #define dvLinkSetNextModuleExportLink(_Link, value) ((dvLinks.NextModuleExportLink)[dvLink2ValidIndex(_Link)] = (value)) 830 #define dvLinkSetConstructorCallback(func) (dvLinkConstructorCallback = (func)) 831 #define dvLinkGetConstructorCallback() (dvLinkConstructorCallback) 832 #define dvFirstLink() (dvRootData.usedLink == 0? dvLinkNull : dvIndex2Link(0)) 833 #define dvLastLink() (dvRootData.usedLink == 0? dvLinkNull : \ 834 dvIndex2Link(dvRootData.usedLink - 1)) 835 #define dvNextLink(Link) (dvLink2ValidIndex(Link) + 1 == dvRootData.usedLink? dvLinkNull : \ 836 (Link) + 1) 837 #define dvPrevLink(Link) (dvLink2ValidIndex(Link) == 0? dvLinkNull : (Link) - 1) 838 #define dvForeachLink(var) \ 839 for(var = dvIndex2Link(0); dvLink2Index(var) != dvRootData.usedLink; var++) 840 #define dvEndLink 841 #define dvLinkFreeAll() (dvSetUsedLink(0)) 842 #define dvLinkAllocRaw() ( \ 843 dvRootData.usedLink == dvRootData.allocatedLink && (dvLinkAllocMore(), true), \ 844 dvTemp_.Link = dvIndex2Link(dvRootData.usedLink), \ 845 dvSetUsedLink(dvUsedLink() + 1), \ 846 dvTemp_.Link) 847 #define dvLinkAlloc() ( \ 848 dvRootData.usedLink == dvRootData.allocatedLink && (dvLinkAllocMore(), true), \ 849 dvTemp_.Link = dvIndex2Link(dvRootData.usedLink), \ 850 dvSetUsedLink(dvUsedLink() + 1), \ 851 dvLinkSetImportModule(dvTemp_.Link, dvModuleNull), \ 852 dvLinkSetNextModuleImportLink(dvTemp_.Link, dvLinkNull), \ 853 dvLinkSetExportModule(dvTemp_.Link, dvModuleNull), \ 854 dvLinkSetNextModuleExportLink(dvTemp_.Link, dvLinkNull), \ 855 dvLinkConstructorCallback != NULL && (dvLinkConstructorCallback(dvTemp_.Link), true), \ 856 dvTemp_.Link) 857 858 void dvLinkAllocMore(void); 859 void dvLinkCopyProps(dvLink dvOldLink, dvLink dvNewLink); 860 861 /*---------------------------------------------------------------------------------------- 862 Fields for class Schema. 863 ----------------------------------------------------------------------------------------*/ 864 struct dvSchemaFields { 865 utSym *Sym; 866 dvModule *Module; 867 dvSchema *NextModuleSchema; 868 dvSchema *PrevModuleSchema; 869 dvSchema *NextTableModuleSchema; 870 dvRelationship *FirstRelationship; 871 dvRelationship *LastRelationship; 872 }; 873 extern struct dvSchemaFields dvSchemas; 874 875 #define dvSchemaGetSym(_Schema) (dvSchemas.Sym[dvSchema2ValidIndex(_Schema)]) 876 #define dvSchemaSetSym(_Schema, value) ((dvSchemas.Sym)[dvSchema2ValidIndex(_Schema)] = (value)) 877 #define dvSchemaGetModule(_Schema) (dvSchemas.Module[dvSchema2ValidIndex(_Schema)]) 878 #define dvSchemaSetModule(_Schema, value) ((dvSchemas.Module)[dvSchema2ValidIndex(_Schema)] = (value)) 879 #define dvSchemaGetNextModuleSchema(_Schema) (dvSchemas.NextModuleSchema[dvSchema2ValidIndex(_Schema)]) 880 #define dvSchemaSetNextModuleSchema(_Schema, value) ((dvSchemas.NextModuleSchema)[dvSchema2ValidIndex(_Schema)] = (value)) 881 #define dvSchemaGetPrevModuleSchema(_Schema) (dvSchemas.PrevModuleSchema[dvSchema2ValidIndex(_Schema)]) 882 #define dvSchemaSetPrevModuleSchema(_Schema, value) ((dvSchemas.PrevModuleSchema)[dvSchema2ValidIndex(_Schema)] = (value)) 883 #define dvSchemaGetNextTableModuleSchema(_Schema) (dvSchemas.NextTableModuleSchema[dvSchema2ValidIndex(_Schema)]) 884 #define dvSchemaSetNextTableModuleSchema(_Schema, value) ((dvSchemas.NextTableModuleSchema)[dvSchema2ValidIndex(_Schema)] = (value)) 885 #define dvSchemaGetFirstRelationship(_Schema) (dvSchemas.FirstRelationship[dvSchema2ValidIndex(_Schema)]) 886 #define dvSchemaSetFirstRelationship(_Schema, value) ((dvSchemas.FirstRelationship)[dvSchema2ValidIndex(_Schema)] = (value)) 887 #define dvSchemaGetLastRelationship(_Schema) (dvSchemas.LastRelationship[dvSchema2ValidIndex(_Schema)]) 888 #define dvSchemaSetLastRelationship(_Schema, value) ((dvSchemas.LastRelationship)[dvSchema2ValidIndex(_Schema)] = (value)) 889 #define dvForeachSchemaRelationship(pVar, cVar) \ 890 for(cVar = dvSchemaGetFirstRelationship(pVar); cVar != dvRelationshipNull; \ 891 cVar = dvRelationshipGetNextSchemaRelationship(cVar)) 892 #define dvEndSchemaRelationship 893 #define dvSafeForeachSchemaRelationship(pVar, cVar) { \ 894 dvRelationship _nextRelationship; \ 895 for(cVar = dvSchemaGetFirstRelationship(pVar); cVar != dvRelationshipNull; cVar = _nextRelationship) { \ 896 _nextRelationship = dvRelationshipGetNextSchemaRelationship(cVar); 897 #define dvEndSafeSchemaRelationship }} 898 #define dvSchemaSetConstructorCallback(func) (dvSchemaConstructorCallback = (func)) 899 #define dvSchemaGetConstructorCallback() (dvSchemaConstructorCallback) 900 #define dvFirstSchema() (dvRootData.usedSchema == 0? dvSchemaNull : dvIndex2Schema(0)) 901 #define dvLastSchema() (dvRootData.usedSchema == 0? dvSchemaNull : \ 902 dvIndex2Schema(dvRootData.usedSchema - 1)) 903 #define dvNextSchema(Schema) (dvSchema2ValidIndex(Schema) + 1 == dvRootData.usedSchema? dvSchemaNull : \ 904 (Schema) + 1) 905 #define dvPrevSchema(Schema) (dvSchema2ValidIndex(Schema) == 0? dvSchemaNull : (Schema) - 1) 906 #define dvForeachSchema(var) \ 907 for(var = dvIndex2Schema(0); dvSchema2Index(var) != dvRootData.usedSchema; var++) 908 #define dvEndSchema 909 #define dvSchemaFreeAll() (dvSetUsedSchema(0)) 910 #define dvSchemaAllocRaw() ( \ 911 dvRootData.usedSchema == dvRootData.allocatedSchema && (dvSchemaAllocMore(), true), \ 912 dvTemp_.Schema = dvIndex2Schema(dvRootData.usedSchema), \ 913 dvSetUsedSchema(dvUsedSchema() + 1), \ 914 dvTemp_.Schema) 915 #define dvSchemaAlloc() ( \ 916 dvRootData.usedSchema == dvRootData.allocatedSchema && (dvSchemaAllocMore(), true), \ 917 dvTemp_.Schema = dvIndex2Schema(dvRootData.usedSchema), \ 918 dvSetUsedSchema(dvUsedSchema() + 1), \ 919 dvSchemaSetSym(dvTemp_.Schema, utSymNull), \ 920 dvSchemaSetModule(dvTemp_.Schema, dvModuleNull), \ 921 dvSchemaSetNextModuleSchema(dvTemp_.Schema, dvSchemaNull), \ 922 dvSchemaSetPrevModuleSchema(dvTemp_.Schema, dvSchemaNull), \ 923 dvSchemaSetNextTableModuleSchema(dvTemp_.Schema, dvSchemaNull), \ 924 dvSchemaSetFirstRelationship(dvTemp_.Schema, dvRelationshipNull), \ 925 dvSchemaSetLastRelationship(dvTemp_.Schema, dvRelationshipNull), \ 926 dvSchemaConstructorCallback != NULL && (dvSchemaConstructorCallback(dvTemp_.Schema), true), \ 927 dvTemp_.Schema) 928 929 void dvSchemaAllocMore(void); 930 void dvSchemaCopyProps(dvSchema dvOldSchema, dvSchema dvNewSchema); 931 void dvSchemaInsertRelationship(dvSchema Schema, dvRelationship _Relationship); 932 void dvSchemaRemoveRelationship(dvSchema Schema, dvRelationship _Relationship); 933 void dvSchemaInsertAfterRelationship(dvSchema Schema, dvRelationship prevRelationship, dvRelationship _Relationship); 934 void dvSchemaAppendRelationship(dvSchema Schema, dvRelationship _Relationship); 935 936 /*---------------------------------------------------------------------------------------- 937 Fields for class Enum. 938 ----------------------------------------------------------------------------------------*/ 939 struct dvEnumFields { 940 utSym *Sym; 941 utSym *PrefixSym; 942 uint16 *NumEntries; 943 dvModule *Module; 944 dvEnum *NextModuleEnum; 945 dvEnum *PrevModuleEnum; 946 dvEnum *NextTableModuleEnum; 947 dvEntry *FirstEntry; 948 dvEntry *LastEntry; 949 uint32 *EntryTableIndex; 950 uint32 *NumEntryTable; 951 dvEntry *EntryTable; 952 uint32 *NumEntry; 953 }; 954 extern struct dvEnumFields dvEnums; 955 956 #define dvEnumGetSym(_Enum) (dvEnums.Sym[dvEnum2ValidIndex(_Enum)]) 957 #define dvEnumSetSym(_Enum, value) ((dvEnums.Sym)[dvEnum2ValidIndex(_Enum)] = (value)) 958 #define dvEnumGetPrefixSym(_Enum) (dvEnums.PrefixSym[dvEnum2ValidIndex(_Enum)]) 959 #define dvEnumSetPrefixSym(_Enum, value) ((dvEnums.PrefixSym)[dvEnum2ValidIndex(_Enum)] = (value)) 960 #define dvEnumGetNumEntries(_Enum) (dvEnums.NumEntries[dvEnum2ValidIndex(_Enum)]) 961 #define dvEnumSetNumEntries(_Enum, value) ((dvEnums.NumEntries)[dvEnum2ValidIndex(_Enum)] = (value)) 962 #define dvEnumGetModule(_Enum) (dvEnums.Module[dvEnum2ValidIndex(_Enum)]) 963 #define dvEnumSetModule(_Enum, value) ((dvEnums.Module)[dvEnum2ValidIndex(_Enum)] = (value)) 964 #define dvEnumGetNextModuleEnum(_Enum) (dvEnums.NextModuleEnum[dvEnum2ValidIndex(_Enum)]) 965 #define dvEnumSetNextModuleEnum(_Enum, value) ((dvEnums.NextModuleEnum)[dvEnum2ValidIndex(_Enum)] = (value)) 966 #define dvEnumGetPrevModuleEnum(_Enum) (dvEnums.PrevModuleEnum[dvEnum2ValidIndex(_Enum)]) 967 #define dvEnumSetPrevModuleEnum(_Enum, value) ((dvEnums.PrevModuleEnum)[dvEnum2ValidIndex(_Enum)] = (value)) 968 #define dvEnumGetNextTableModuleEnum(_Enum) (dvEnums.NextTableModuleEnum[dvEnum2ValidIndex(_Enum)]) 969 #define dvEnumSetNextTableModuleEnum(_Enum, value) ((dvEnums.NextTableModuleEnum)[dvEnum2ValidIndex(_Enum)] = (value)) 970 #define dvEnumGetFirstEntry(_Enum) (dvEnums.FirstEntry[dvEnum2ValidIndex(_Enum)]) 971 #define dvEnumSetFirstEntry(_Enum, value) ((dvEnums.FirstEntry)[dvEnum2ValidIndex(_Enum)] = (value)) 972 #define dvEnumGetLastEntry(_Enum) (dvEnums.LastEntry[dvEnum2ValidIndex(_Enum)]) 973 #define dvEnumSetLastEntry(_Enum, value) ((dvEnums.LastEntry)[dvEnum2ValidIndex(_Enum)] = (value)) 974 #define dvEnumGetEntryTableIndex(_Enum) (dvEnums.EntryTableIndex[dvEnum2ValidIndex(_Enum)]) 975 #define dvEnumSetEntryTableIndex(_Enum, value) ((dvEnums.EntryTableIndex)[dvEnum2ValidIndex(_Enum)] = (value)) 976 #define dvEnumGetNumEntryTable(_Enum) (dvEnums.NumEntryTable[dvEnum2ValidIndex(_Enum)]) 977 #define dvEnumSetNumEntryTable(_Enum, value) ((dvEnums.NumEntryTable)[dvEnum2ValidIndex(_Enum)] = (value)) 978 #if defined(DD_DEBUG) 979 #define dvEnumCheckEntryTableIndex(Enum, x) ((uint32)(x) < dvEnumGetNumEntryTable(Enum)? (x) : \ 980 (utAssert(false),(x))) 981 #else 982 #define dvEnumCheckEntryTableIndex(Enum, x) (x) 983 #endif 984 #define dvEnumGetiEntryTable(_Enum, x) ((dvEnums.EntryTable)[ \ 985 dvEnumGetEntryTableIndex(_Enum) + dvEnumCheckEntryTableIndex(_Enum, (x))]) 986 #define dvEnumGetEntryTable(Enum) (dvEnums.EntryTable + dvEnumGetEntryTableIndex(Enum)) 987 #define dvEnumGetEntryTables dvEnumGetEntryTable 988 #define dvEnumSetEntryTable(Enum, valuePtr, numEntryTable) (dvEnumResizeEntryTables(Enum, numEntryTable), memcpy(dvEnumGetEntryTables(Enum), valuePtr, \ 989 numEntryTable*sizeof(dvEntry))) 990 #define dvEnumSetiEntryTable(Enum, x, value) ((dvEnums.EntryTable)[ \ 991 dvEnumGetEntryTableIndex(Enum) + dvEnumCheckEntryTableIndex(Enum, (x))] = (value)) 992 #define dvEnumGetNumEntry(_Enum) (dvEnums.NumEntry[dvEnum2ValidIndex(_Enum)]) 993 #define dvEnumSetNumEntry(_Enum, value) ((dvEnums.NumEntry)[dvEnum2ValidIndex(_Enum)] = (value)) 994 dvEntry dvEnumFindEntry(dvEnum Enum, utSym Sym); 995 void dvEnumRenameEntry(dvEnum Enum, dvEntry _Entry, utSym sym); 996 #define dvEntryGetName(Entry) utSymGetName(dvEntryGetSym(Entry)) 997 #define dvForeachEnumEntry(pVar, cVar) \ 998 for(cVar = dvEnumGetFirstEntry(pVar); cVar != dvEntryNull; \ 999 cVar = dvEntryGetNextEnumEntry(cVar)) 1000 #define dvEndEnumEntry 1001 #define dvSafeForeachEnumEntry(pVar, cVar) { \ 1002 dvEntry _nextEntry; \ 1003 for(cVar = dvEnumGetFirstEntry(pVar); cVar != dvEntryNull; cVar = _nextEntry) { \ 1004 _nextEntry = dvEntryGetNextEnumEntry(cVar); 1005 #define dvEndSafeEnumEntry }} 1006 #define dvEnumSetConstructorCallback(func) (dvEnumConstructorCallback = (func)) 1007 #define dvEnumGetConstructorCallback() (dvEnumConstructorCallback) 1008 #define dvFirstEnum() (dvRootData.usedEnum == 0? dvEnumNull : dvIndex2Enum(0)) 1009 #define dvLastEnum() (dvRootData.usedEnum == 0? dvEnumNull : \ 1010 dvIndex2Enum(dvRootData.usedEnum - 1)) 1011 #define dvNextEnum(Enum) (dvEnum2ValidIndex(Enum) + 1 == dvRootData.usedEnum? dvEnumNull : \ 1012 (Enum) + 1) 1013 #define dvPrevEnum(Enum) (dvEnum2ValidIndex(Enum) == 0? dvEnumNull : (Enum) - 1) 1014 #define dvForeachEnum(var) \ 1015 for(var = dvIndex2Enum(0); dvEnum2Index(var) != dvRootData.usedEnum; var++) 1016 #define dvEndEnum 1017 #define dvEnumFreeAll() (dvSetUsedEnum(0), dvSetUsedEnumEntryTable(0)) 1018 #define dvEnumAllocRaw() ( \ 1019 dvRootData.usedEnum == dvRootData.allocatedEnum && (dvEnumAllocMore(), true), \ 1020 dvTemp_.Enum = dvIndex2Enum(dvRootData.usedEnum), \ 1021 dvSetUsedEnum(dvUsedEnum() + 1), \ 1022 dvTemp_.Enum) 1023 #define dvEnumAlloc() ( \ 1024 dvRootData.usedEnum == dvRootData.allocatedEnum && (dvEnumAllocMore(), true), \ 1025 dvTemp_.Enum = dvIndex2Enum(dvRootData.usedEnum), \ 1026 dvSetUsedEnum(dvUsedEnum() + 1), \ 1027 dvEnumSetSym(dvTemp_.Enum, utSymNull), \ 1028 dvEnumSetPrefixSym(dvTemp_.Enum, utSymNull), \ 1029 dvEnumSetNumEntries(dvTemp_.Enum, 0), \ 1030 dvEnumSetModule(dvTemp_.Enum, dvModuleNull), \ 1031 dvEnumSetNextModuleEnum(dvTemp_.Enum, dvEnumNull), \ 1032 dvEnumSetPrevModuleEnum(dvTemp_.Enum, dvEnumNull), \ 1033 dvEnumSetNextTableModuleEnum(dvTemp_.Enum, dvEnumNull), \ 1034 dvEnumSetFirstEntry(dvTemp_.Enum, dvEntryNull), \ 1035 dvEnumSetLastEntry(dvTemp_.Enum, dvEntryNull), \ 1036 dvEnumSetEntryTableIndex(dvTemp_.Enum, 0), \ 1037 dvEnumSetNumEntryTable(dvTemp_.Enum, 0), \ 1038 dvEnumSetNumEntryTable(dvTemp_.Enum, 0), \ 1039 dvEnumSetNumEntry(dvTemp_.Enum, 0), \ 1040 dvEnumConstructorCallback != NULL && (dvEnumConstructorCallback(dvTemp_.Enum), true), \ 1041 dvTemp_.Enum) 1042 1043 void dvEnumAllocMore(void); 1044 void dvEnumCopyProps(dvEnum dvOldEnum, dvEnum dvNewEnum); 1045 void dvEnumAllocEntryTables(dvEnum Enum, uint32 numEntryTables); 1046 void dvEnumResizeEntryTables(dvEnum Enum, uint32 numEntryTables); 1047 void dvEnumFreeEntryTables(dvEnum Enum); 1048 void dvCompactEnumEntryTables(void); 1049 void dvEnumInsertEntry(dvEnum Enum, dvEntry _Entry); 1050 void dvEnumRemoveEntry(dvEnum Enum, dvEntry _Entry); 1051 void dvEnumInsertAfterEntry(dvEnum Enum, dvEntry prevEntry, dvEntry _Entry); 1052 void dvEnumAppendEntry(dvEnum Enum, dvEntry _Entry); 1053 1054 /*---------------------------------------------------------------------------------------- 1055 Fields for class Entry. 1056 ----------------------------------------------------------------------------------------*/ 1057 struct dvEntryFields { 1058 utSym *Sym; 1059 uint32 *Value; 1060 dvEnum *Enum; 1061 dvEntry *NextEnumEntry; 1062 dvEntry *PrevEnumEntry; 1063 dvEntry *NextTableEnumEntry; 1064 dvCase *FirstCase; 1065 dvCase *LastCase; 1066 }; 1067 extern struct dvEntryFields dvEntrys; 1068 1069 #define dvEntryGetSym(_Entry) (dvEntrys.Sym[dvEntry2ValidIndex(_Entry)]) 1070 #define dvEntrySetSym(_Entry, value) ((dvEntrys.Sym)[dvEntry2ValidIndex(_Entry)] = (value)) 1071 #define dvEntryGetValue(_Entry) (dvEntrys.Value[dvEntry2ValidIndex(_Entry)]) 1072 #define dvEntrySetValue(_Entry, value) ((dvEntrys.Value)[dvEntry2ValidIndex(_Entry)] = (value)) 1073 #define dvEntryGetEnum(_Entry) (dvEntrys.Enum[dvEntry2ValidIndex(_Entry)]) 1074 #define dvEntrySetEnum(_Entry, value) ((dvEntrys.Enum)[dvEntry2ValidIndex(_Entry)] = (value)) 1075 #define dvEntryGetNextEnumEntry(_Entry) (dvEntrys.NextEnumEntry[dvEntry2ValidIndex(_Entry)]) 1076 #define dvEntrySetNextEnumEntry(_Entry, value) ((dvEntrys.NextEnumEntry)[dvEntry2ValidIndex(_Entry)] = (value)) 1077 #define dvEntryGetPrevEnumEntry(_Entry) (dvEntrys.PrevEnumEntry[dvEntry2ValidIndex(_Entry)]) 1078 #define dvEntrySetPrevEnumEntry(_Entry, value) ((dvEntrys.PrevEnumEntry)[dvEntry2ValidIndex(_Entry)] = (value)) 1079 #define dvEntryGetNextTableEnumEntry(_Entry) (dvEntrys.NextTableEnumEntry[dvEntry2ValidIndex(_Entry)]) 1080 #define dvEntrySetNextTableEnumEntry(_Entry, value) ((dvEntrys.NextTableEnumEntry)[dvEntry2ValidIndex(_Entry)] = (value)) 1081 #define dvEntryGetFirstCase(_Entry) (dvEntrys.FirstCase[dvEntry2ValidIndex(_Entry)]) 1082 #define dvEntrySetFirstCase(_Entry, value) ((dvEntrys.FirstCase)[dvEntry2ValidIndex(_Entry)] = (value)) 1083 #define dvEntryGetLastCase(_Entry) (dvEntrys.LastCase[dvEntry2ValidIndex(_Entry)]) 1084 #define dvEntrySetLastCase(_Entry, value) ((dvEntrys.LastCase)[dvEntry2ValidIndex(_Entry)] = (value)) 1085 #define dvForeachEntryCase(pVar, cVar) \ 1086 for(cVar = dvEntryGetFirstCase(pVar); cVar != dvCaseNull; \ 1087 cVar = dvCaseGetNextEntryCase(cVar)) 1088 #define dvEndEntryCase 1089 #define dvSafeForeachEntryCase(pVar, cVar) { \ 1090 dvCase _nextCase; \ 1091 for(cVar = dvEntryGetFirstCase(pVar); cVar != dvCaseNull; cVar = _nextCase) { \ 1092 _nextCase = dvCaseGetNextEntryCase(cVar); 1093 #define dvEndSafeEntryCase }} 1094 #define dvEntrySetConstructorCallback(func) (dvEntryConstructorCallback = (func)) 1095 #define dvEntryGetConstructorCallback() (dvEntryConstructorCallback) 1096 #define dvFirstEntry() (dvRootData.usedEntry == 0? dvEntryNull : dvIndex2Entry(0)) 1097 #define dvLastEntry() (dvRootData.usedEntry == 0? dvEntryNull : \ 1098 dvIndex2Entry(dvRootData.usedEntry - 1)) 1099 #define dvNextEntry(Entry) (dvEntry2ValidIndex(Entry) + 1 == dvRootData.usedEntry? dvEntryNull : \ 1100 (Entry) + 1) 1101 #define dvPrevEntry(Entry) (dvEntry2ValidIndex(Entry) == 0? dvEntryNull : (Entry) - 1) 1102 #define dvForeachEntry(var) \ 1103 for(var = dvIndex2Entry(0); dvEntry2Index(var) != dvRootData.usedEntry; var++) 1104 #define dvEndEntry 1105 #define dvEntryFreeAll() (dvSetUsedEntry(0)) 1106 #define dvEntryAllocRaw() ( \ 1107 dvRootData.usedEntry == dvRootData.allocatedEntry && (dvEntryAllocMore(), true), \ 1108 dvTemp_.Entry = dvIndex2Entry(dvRootData.usedEntry), \ 1109 dvSetUsedEntry(dvUsedEntry() + 1), \ 1110 dvTemp_.Entry) 1111 #define dvEntryAlloc() ( \ 1112 dvRootData.usedEntry == dvRootData.allocatedEntry && (dvEntryAllocMore(), true), \ 1113 dvTemp_.Entry = dvIndex2Entry(dvRootData.usedEntry), \ 1114 dvSetUsedEntry(dvUsedEntry() + 1), \ 1115 dvEntrySetSym(dvTemp_.Entry, utSymNull), \ 1116 dvEntrySetValue(dvTemp_.Entry, 0), \ 1117 dvEntrySetEnum(dvTemp_.Entry, dvEnumNull), \ 1118 dvEntrySetNextEnumEntry(dvTemp_.Entry, dvEntryNull), \ 1119 dvEntrySetPrevEnumEntry(dvTemp_.Entry, dvEntryNull), \ 1120 dvEntrySetNextTableEnumEntry(dvTemp_.Entry, dvEntryNull), \ 1121 dvEntrySetFirstCase(dvTemp_.Entry, dvCaseNull), \ 1122 dvEntrySetLastCase(dvTemp_.Entry, dvCaseNull), \ 1123 dvEntryConstructorCallback != NULL && (dvEntryConstructorCallback(dvTemp_.Entry), true), \ 1124 dvTemp_.Entry) 1125 1126 void dvEntryAllocMore(void); 1127 void dvEntryCopyProps(dvEntry dvOldEntry, dvEntry dvNewEntry); 1128 void dvEntryInsertCase(dvEntry Entry, dvCase _Case); 1129 void dvEntryRemoveCase(dvEntry Entry, dvCase _Case); 1130 void dvEntryInsertAfterCase(dvEntry Entry, dvCase prevCase, dvCase _Case); 1131 void dvEntryAppendCase(dvEntry Entry, dvCase _Case); 1132 1133 /*---------------------------------------------------------------------------------------- 1134 Fields for class Typedef. 1135 ----------------------------------------------------------------------------------------*/ 1136 struct dvTypedefFields { 1137 utSym *Sym; 1138 uint32 *InitializerIndex; 1139 uint32 *NumInitializer; 1140 char *Initializer; 1141 dvModule *Module; 1142 dvTypedef *NextModuleTypedef; 1143 dvTypedef *PrevModuleTypedef; 1144 dvTypedef *NextTableModuleTypedef; 1145 }; 1146 extern struct dvTypedefFields dvTypedefs; 1147 1148 #define dvTypedefGetSym(_Typedef) (dvTypedefs.Sym[dvTypedef2ValidIndex(_Typedef)]) 1149 #define dvTypedefSetSym(_Typedef, value) ((dvTypedefs.Sym)[dvTypedef2ValidIndex(_Typedef)] = (value)) 1150 #define dvTypedefGetInitializerIndex(_Typedef) (dvTypedefs.InitializerIndex[dvTypedef2ValidIndex(_Typedef)]) 1151 #define dvTypedefSetInitializerIndex(_Typedef, value) ((dvTypedefs.InitializerIndex)[dvTypedef2ValidIndex(_Typedef)] = (value)) 1152 #define dvTypedefGetNumInitializer(_Typedef) (dvTypedefs.NumInitializer[dvTypedef2ValidIndex(_Typedef)]) 1153 #define dvTypedefSetNumInitializer(_Typedef, value) ((dvTypedefs.NumInitializer)[dvTypedef2ValidIndex(_Typedef)] = (value)) 1154 #if defined(DD_DEBUG) 1155 #define dvTypedefCheckInitializerIndex(Typedef, x) ((uint32)(x) < dvTypedefGetNumInitializer(Typedef)? (x) : \ 1156 (utAssert(false),(x))) 1157 #else 1158 #define dvTypedefCheckInitializerIndex(Typedef, x) (x) 1159 #endif 1160 #define dvTypedefGetiInitializer(_Typedef, x) ((dvTypedefs.Initializer)[ \ 1161 dvTypedefGetInitializerIndex(_Typedef) + dvTypedefCheckInitializerIndex(_Typedef, (x))]) 1162 #define dvTypedefGetInitializer(Typedef) (dvTypedefs.Initializer + dvTypedefGetInitializerIndex(Typedef)) 1163 #define dvTypedefGetInitializers dvTypedefGetInitializer 1164 #define dvTypedefSetInitializer(Typedef, valuePtr, numInitializer) (dvTypedefResizeInitializers(Typedef, numInitializer), memcpy(dvTypedefGetInitializers(Typedef), valuePtr, \ 1165 numInitializer*sizeof(char))) 1166 #define dvTypedefSetiInitializer(Typedef, x, value) ((dvTypedefs.Initializer)[ \ 1167 dvTypedefGetInitializerIndex(Typedef) + dvTypedefCheckInitializerIndex(Typedef, (x))] = (value)) 1168 #define dvTypedefGetModule(_Typedef) (dvTypedefs.Module[dvTypedef2ValidIndex(_Typedef)]) 1169 #define dvTypedefSetModule(_Typedef, value) ((dvTypedefs.Module)[dvTypedef2ValidIndex(_Typedef)] = (value)) 1170 #define dvTypedefGetNextModuleTypedef(_Typedef) (dvTypedefs.NextModuleTypedef[dvTypedef2ValidIndex(_Typedef)]) 1171 #define dvTypedefSetNextModuleTypedef(_Typedef, value) ((dvTypedefs.NextModuleTypedef)[dvTypedef2ValidIndex(_Typedef)] = (value)) 1172 #define dvTypedefGetPrevModuleTypedef(_Typedef) (dvTypedefs.PrevModuleTypedef[dvTypedef2ValidIndex(_Typedef)]) 1173 #define dvTypedefSetPrevModuleTypedef(_Typedef, value) ((dvTypedefs.PrevModuleTypedef)[dvTypedef2ValidIndex(_Typedef)] = (value)) 1174 #define dvTypedefGetNextTableModuleTypedef(_Typedef) (dvTypedefs.NextTableModuleTypedef[dvTypedef2ValidIndex(_Typedef)]) 1175 #define dvTypedefSetNextTableModuleTypedef(_Typedef, value) ((dvTypedefs.NextTableModuleTypedef)[dvTypedef2ValidIndex(_Typedef)] = (value)) 1176 #define dvTypedefSetConstructorCallback(func) (dvTypedefConstructorCallback = (func)) 1177 #define dvTypedefGetConstructorCallback() (dvTypedefConstructorCallback) 1178 #define dvFirstTypedef() (dvRootData.usedTypedef == 0? dvTypedefNull : dvIndex2Typedef(0)) 1179 #define dvLastTypedef() (dvRootData.usedTypedef == 0? dvTypedefNull : \ 1180 dvIndex2Typedef(dvRootData.usedTypedef - 1)) 1181 #define dvNextTypedef(Typedef) (dvTypedef2ValidIndex(Typedef) + 1 == dvRootData.usedTypedef? dvTypedefNull : \ 1182 (Typedef) + 1) 1183 #define dvPrevTypedef(Typedef) (dvTypedef2ValidIndex(Typedef) == 0? dvTypedefNull : (Typedef) - 1) 1184 #define dvForeachTypedef(var) \ 1185 for(var = dvIndex2Typedef(0); dvTypedef2Index(var) != dvRootData.usedTypedef; var++) 1186 #define dvEndTypedef 1187 #define dvTypedefFreeAll() (dvSetUsedTypedef(0), dvSetUsedTypedefInitializer(0)) 1188 #define dvTypedefAllocRaw() ( \ 1189 dvRootData.usedTypedef == dvRootData.allocatedTypedef && (dvTypedefAllocMore(), true), \ 1190 dvTemp_.Typedef = dvIndex2Typedef(dvRootData.usedTypedef), \ 1191 dvSetUsedTypedef(dvUsedTypedef() + 1), \ 1192 dvTemp_.Typedef) 1193 #define dvTypedefAlloc() ( \ 1194 dvRootData.usedTypedef == dvRootData.allocatedTypedef && (dvTypedefAllocMore(), true), \ 1195 dvTemp_.Typedef = dvIndex2Typedef(dvRootData.usedTypedef), \ 1196 dvSetUsedTypedef(dvUsedTypedef() + 1), \ 1197 dvTypedefSetSym(dvTemp_.Typedef, utSymNull), \ 1198 dvTypedefSetInitializerIndex(dvTemp_.Typedef, 0), \ 1199 dvTypedefSetNumInitializer(dvTemp_.Typedef, 0), \ 1200 dvTypedefSetNumInitializer(dvTemp_.Typedef, 0), \ 1201 dvTypedefSetModule(dvTemp_.Typedef, dvModuleNull), \ 1202 dvTypedefSetNextModuleTypedef(dvTemp_.Typedef, dvTypedefNull), \ 1203 dvTypedefSetPrevModuleTypedef(dvTemp_.Typedef, dvTypedefNull), \ 1204 dvTypedefSetNextTableModuleTypedef(dvTemp_.Typedef, dvTypedefNull), \ 1205 dvTypedefConstructorCallback != NULL && (dvTypedefConstructorCallback(dvTemp_.Typedef), true), \ 1206 dvTemp_.Typedef) 1207 1208 void dvTypedefAllocMore(void); 1209 void dvTypedefCopyProps(dvTypedef dvOldTypedef, dvTypedef dvNewTypedef); 1210 void dvTypedefAllocInitializers(dvTypedef Typedef, uint32 numInitializers); 1211 void dvTypedefResizeInitializers(dvTypedef Typedef, uint32 numInitializers); 1212 void dvTypedefFreeInitializers(dvTypedef Typedef); 1213 void dvCompactTypedefInitializers(void); 1214 1215 /*---------------------------------------------------------------------------------------- 1216 Fields for class Class. 1217 ----------------------------------------------------------------------------------------*/ 1218 struct dvClassFields { 1219 utSym *Sym; 1220 dvMemoryStyle *MemoryStyle; 1221 uint8 *ReferenceSize; 1222 uint8 *GenerateArrayClass; 1223 uint8 *GenerateAttributes; 1224 uint8 *Sparse; 1225 uint16 *NumFields; 1226 uint16 *Number; 1227 dvModule *Module; 1228 dvClass *NextModuleClass; 1229 dvClass *PrevModuleClass; 1230 dvClass *NextTableModuleClass; 1231 dvProperty *FirstProperty; 1232 dvProperty *LastProperty; 1233 uint32 *PropertyTableIndex; 1234 uint32 *NumPropertyTable; 1235 dvProperty *PropertyTable; 1236 uint32 *NumProperty; 1237 dvProperty *FreeListProperty; 1238 dvSparsegroup *FirstSparsegroup; 1239 dvSparsegroup *LastSparsegroup; 1240 uint32 *SparsegroupTableIndex; 1241 uint32 *NumSparsegroupTable; 1242 dvSparsegroup *SparsegroupTable; 1243 uint32 *NumSparsegroup; 1244 dvClass *BaseClass; 1245 dvClass *FirstDerivedClass; 1246 dvClass *NextClassDerivedClass; 1247 dvClass *LastDerivedClass; 1248 dvRelationship *FirstChildRelationship; 1249 dvRelationship *LastChildRelationship; 1250 dvRelationship *FirstParentRelationship; 1251 dvRelationship *LastParentRelationship; 1252 dvUnion *FirstUnion; 1253 dvUnion *LastUnion; 1254 }; 1255 extern struct dvClassFields dvClasss; 1256 1257 #define dvClassGetSym(_Class) (dvClasss.Sym[dvClass2ValidIndex(_Class)]) 1258 #define dvClassSetSym(_Class, value) ((dvClasss.Sym)[dvClass2ValidIndex(_Class)] = (value)) 1259 #define dvClassGetMemoryStyle(_Class) (dvClasss.MemoryStyle[dvClass2ValidIndex(_Class)]) 1260 #define dvClassSetMemoryStyle(_Class, value) ((dvClasss.MemoryStyle)[dvClass2ValidIndex(_Class)] = (value)) 1261 #define dvClassGetReferenceSize(_Class) (dvClasss.ReferenceSize[dvClass2ValidIndex(_Class)]) 1262 #define dvClassSetReferenceSize(_Class, value) ((dvClasss.ReferenceSize)[dvClass2ValidIndex(_Class)] = (value)) 1263 #define dvClassGenerateArrayClass(_Class) (((dvClasss.GenerateArrayClass)[dvClass2ValidIndex(_Class) >> 3] >> \ 1264 (dvClass2ValidIndex(_Class) & 7)) & 1) 1265 #define dvClassSetGenerateArrayClass(_Class, value) ((dvClasss.GenerateArrayClass)[dvClass2ValidIndex(_Class) >> 3] = \ 1266 (uint8)(((dvClasss.GenerateArrayClass)[dvClass2ValidIndex(_Class) >> 3] & ~(1 << (dvClass2ValidIndex(_Class) & 7))) | \ 1267 (((value) != 0) << (dvClass2ValidIndex(_Class) & 7)))) 1268 #define dvClassGenerateAttributes(_Class) (((dvClasss.GenerateAttributes)[dvClass2ValidIndex(_Class) >> 3] >> \ 1269 (dvClass2ValidIndex(_Class) & 7)) & 1) 1270 #define dvClassSetGenerateAttributes(_Class, value) ((dvClasss.GenerateAttributes)[dvClass2ValidIndex(_Class) >> 3] = \ 1271 (uint8)(((dvClasss.GenerateAttributes)[dvClass2ValidIndex(_Class) >> 3] & ~(1 << (dvClass2ValidIndex(_Class) & 7))) | \ 1272 (((value) != 0) << (dvClass2ValidIndex(_Class) & 7)))) 1273 #define dvClassSparse(_Class) (((dvClasss.Sparse)[dvClass2ValidIndex(_Class) >> 3] >> \ 1274 (dvClass2ValidIndex(_Class) & 7)) & 1) 1275 #define dvClassSetSparse(_Class, value) ((dvClasss.Sparse)[dvClass2ValidIndex(_Class) >> 3] = \ 1276 (uint8)(((dvClasss.Sparse)[dvClass2ValidIndex(_Class) >> 3] & ~(1 << (dvClass2ValidIndex(_Class) & 7))) | \ 1277 (((value) != 0) << (dvClass2ValidIndex(_Class) & 7)))) 1278 #define dvClassGetNumFields(_Class) (dvClasss.NumFields[dvClass2ValidIndex(_Class)]) 1279 #define dvClassSetNumFields(_Class, value) ((dvClasss.NumFields)[dvClass2ValidIndex(_Class)] = (value)) 1280 #define dvClassGetNumber(_Class) (dvClasss.Number[dvClass2ValidIndex(_Class)]) 1281 #define dvClassSetNumber(_Class, value) ((dvClasss.Number)[dvClass2ValidIndex(_Class)] = (value)) 1282 #define dvClassGetModule(_Class) (dvClasss.Module[dvClass2ValidIndex(_Class)]) 1283 #define dvClassSetModule(_Class, value) ((dvClasss.Module)[dvClass2ValidIndex(_Class)] = (value)) 1284 #define dvClassGetNextModuleClass(_Class) (dvClasss.NextModuleClass[dvClass2ValidIndex(_Class)]) 1285 #define dvClassSetNextModuleClass(_Class, value) ((dvClasss.NextModuleClass)[dvClass2ValidIndex(_Class)] = (value)) 1286 #define dvClassGetPrevModuleClass(_Class) (dvClasss.PrevModuleClass[dvClass2ValidIndex(_Class)]) 1287 #define dvClassSetPrevModuleClass(_Class, value) ((dvClasss.PrevModuleClass)[dvClass2ValidIndex(_Class)] = (value)) 1288 #define dvClassGetNextTableModuleClass(_Class) (dvClasss.NextTableModuleClass[dvClass2ValidIndex(_Class)]) 1289 #define dvClassSetNextTableModuleClass(_Class, value) ((dvClasss.NextTableModuleClass)[dvClass2ValidIndex(_Class)] = (value)) 1290 #define dvClassGetFirstProperty(_Class) (dvClasss.FirstProperty[dvClass2ValidIndex(_Class)]) 1291 #define dvClassSetFirstProperty(_Class, value) ((dvClasss.FirstProperty)[dvClass2ValidIndex(_Class)] = (value)) 1292 #define dvClassGetLastProperty(_Class) (dvClasss.LastProperty[dvClass2ValidIndex(_Class)]) 1293 #define dvClassSetLastProperty(_Class, value) ((dvClasss.LastProperty)[dvClass2ValidIndex(_Class)] = (value)) 1294 #define dvClassGetPropertyTableIndex(_Class) (dvClasss.PropertyTableIndex[dvClass2ValidIndex(_Class)]) 1295 #define dvClassSetPropertyTableIndex(_Class, value) ((dvClasss.PropertyTableIndex)[dvClass2ValidIndex(_Class)] = (value)) 1296 #define dvClassGetNumPropertyTable(_Class) (dvClasss.NumPropertyTable[dvClass2ValidIndex(_Class)]) 1297 #define dvClassSetNumPropertyTable(_Class, value) ((dvClasss.NumPropertyTable)[dvClass2ValidIndex(_Class)] = (value)) 1298 #if defined(DD_DEBUG) 1299 #define dvClassCheckPropertyTableIndex(Class, x) ((uint32)(x) < dvClassGetNumPropertyTable(Class)? (x) : \ 1300 (utAssert(false),(x))) 1301 #else 1302 #define dvClassCheckPropertyTableIndex(Class, x) (x) 1303 #endif 1304 #define dvClassGetiPropertyTable(_Class, x) ((dvClasss.PropertyTable)[ \ 1305 dvClassGetPropertyTableIndex(_Class) + dvClassCheckPropertyTableIndex(_Class, (x))]) 1306 #define dvClassGetPropertyTable(Class) (dvClasss.PropertyTable + dvClassGetPropertyTableIndex(Class)) 1307 #define dvClassGetPropertyTables dvClassGetPropertyTable 1308 #define dvClassSetPropertyTable(Class, valuePtr, numPropertyTable) (dvClassResizePropertyTables(Class, numPropertyTable), memcpy(dvClassGetPropertyTables(Class), valuePtr, \ 1309 numPropertyTable*sizeof(dvProperty))) 1310 #define dvClassSetiPropertyTable(Class, x, value) ((dvClasss.PropertyTable)[ \ 1311 dvClassGetPropertyTableIndex(Class) + dvClassCheckPropertyTableIndex(Class, (x))] = (value)) 1312 #define dvClassGetNumProperty(_Class) (dvClasss.NumProperty[dvClass2ValidIndex(_Class)]) 1313 #define dvClassSetNumProperty(_Class, value) ((dvClasss.NumProperty)[dvClass2ValidIndex(_Class)] = (value)) 1314 #define dvClassGetFreeListProperty(_Class) (dvClasss.FreeListProperty[dvClass2ValidIndex(_Class)]) 1315 #define dvClassSetFreeListProperty(_Class, value) ((dvClasss.FreeListProperty)[dvClass2ValidIndex(_Class)] = (value)) 1316 #define dvClassGetFirstSparsegroup(_Class) (dvClasss.FirstSparsegroup[dvClass2ValidIndex(_Class)]) 1317 #define dvClassSetFirstSparsegroup(_Class, value) ((dvClasss.FirstSparsegroup)[dvClass2ValidIndex(_Class)] = (value)) 1318 #define dvClassGetLastSparsegroup(_Class) (dvClasss.LastSparsegroup[dvClass2ValidIndex(_Class)]) 1319 #define dvClassSetLastSparsegroup(_Class, value) ((dvClasss.LastSparsegroup)[dvClass2ValidIndex(_Class)] = (value)) 1320 #define dvClassGetSparsegroupTableIndex(_Class) (dvClasss.SparsegroupTableIndex[dvClass2ValidIndex(_Class)]) 1321 #define dvClassSetSparsegroupTableIndex(_Class, value) ((dvClasss.SparsegroupTableIndex)[dvClass2ValidIndex(_Class)] = (value)) 1322 #define dvClassGetNumSparsegroupTable(_Class) (dvClasss.NumSparsegroupTable[dvClass2ValidIndex(_Class)]) 1323 #define dvClassSetNumSparsegroupTable(_Class, value) ((dvClasss.NumSparsegroupTable)[dvClass2ValidIndex(_Class)] = (value)) 1324 #if defined(DD_DEBUG) 1325 #define dvClassCheckSparsegroupTableIndex(Class, x) ((uint32)(x) < dvClassGetNumSparsegroupTable(Class)? (x) : \ 1326 (utAssert(false),(x))) 1327 #else 1328 #define dvClassCheckSparsegroupTableIndex(Class, x) (x) 1329 #endif 1330 #define dvClassGetiSparsegroupTable(_Class, x) ((dvClasss.SparsegroupTable)[ \ 1331 dvClassGetSparsegroupTableIndex(_Class) + dvClassCheckSparsegroupTableIndex(_Class, (x))]) 1332 #define dvClassGetSparsegroupTable(Class) (dvClasss.SparsegroupTable + dvClassGetSparsegroupTableIndex(Class)) 1333 #define dvClassGetSparsegroupTables dvClassGetSparsegroupTable 1334 #define dvClassSetSparsegroupTable(Class, valuePtr, numSparsegroupTable) (dvClassResizeSparsegroupTables(Class, numSparsegroupTable), memcpy(dvClassGetSparsegroupTables(Class), valuePtr, \ 1335 numSparsegroupTable*sizeof(dvSparsegroup))) 1336 #define dvClassSetiSparsegroupTable(Class, x, value) ((dvClasss.SparsegroupTable)[ \ 1337 dvClassGetSparsegroupTableIndex(Class) + dvClassCheckSparsegroupTableIndex(Class, (x))] = (value)) 1338 #define dvClassGetNumSparsegroup(_Class) (dvClasss.NumSparsegroup[dvClass2ValidIndex(_Class)]) 1339 #define dvClassSetNumSparsegroup(_Class, value) ((dvClasss.NumSparsegroup)[dvClass2ValidIndex(_Class)] = (value)) 1340 #define dvClassGetBaseClass(_Class) (dvClasss.BaseClass[dvClass2ValidIndex(_Class)]) 1341 #define dvClassSetBaseClass(_Class, value) ((dvClasss.BaseClass)[dvClass2ValidIndex(_Class)] = (value)) 1342 #define dvClassGetFirstDerivedClass(_Class) (dvClasss.FirstDerivedClass[dvClass2ValidIndex(_Class)]) 1343 #define dvClassSetFirstDerivedClass(_Class, value) ((dvClasss.FirstDerivedClass)[dvClass2ValidIndex(_Class)] = (value)) 1344 #define dvClassGetNextClassDerivedClass(_Class) (dvClasss.NextClassDerivedClass[dvClass2ValidIndex(_Class)]) 1345 #define dvClassSetNextClassDerivedClass(_Class, value) ((dvClasss.NextClassDerivedClass)[dvClass2ValidIndex(_Class)] = (value)) 1346 #define dvClassGetLastDerivedClass(_Class) (dvClasss.LastDerivedClass[dvClass2ValidIndex(_Class)]) 1347 #define dvClassSetLastDerivedClass(_Class, value) ((dvClasss.LastDerivedClass)[dvClass2ValidIndex(_Class)] = (value)) 1348 #define dvClassGetFirstChildRelationship(_Class) (dvClasss.FirstChildRelationship[dvClass2ValidIndex(_Class)]) 1349 #define dvClassSetFirstChildRelationship(_Class, value) ((dvClasss.FirstChildRelationship)[dvClass2ValidIndex(_Class)] = (value)) 1350 #define dvClassGetLastChildRelationship(_Class) (dvClasss.LastChildRelationship[dvClass2ValidIndex(_Class)]) 1351 #define dvClassSetLastChildRelationship(_Class, value) ((dvClasss.LastChildRelationship)[dvClass2ValidIndex(_Class)] = (value)) 1352 #define dvClassGetFirstParentRelationship(_Class) (dvClasss.FirstParentRelationship[dvClass2ValidIndex(_Class)]) 1353 #define dvClassSetFirstParentRelationship(_Class, value) ((dvClasss.FirstParentRelationship)[dvClass2ValidIndex(_Class)] = (value)) 1354 #define dvClassGetLastParentRelationship(_Class) (dvClasss.LastParentRelationship[dvClass2ValidIndex(_Class)]) 1355 #define dvClassSetLastParentRelationship(_Class, value) ((dvClasss.LastParentRelationship)[dvClass2ValidIndex(_Class)] = (value)) 1356 #define dvClassGetFirstUnion(_Class) (dvClasss.FirstUnion[dvClass2ValidIndex(_Class)]) 1357 #define dvClassSetFirstUnion(_Class, value) ((dvClasss.FirstUnion)[dvClass2ValidIndex(_Class)] = (value)) 1358 #define dvClassGetLastUnion(_Class) (dvClasss.LastUnion[dvClass2ValidIndex(_Class)]) 1359 #define dvClassSetLastUnion(_Class, value) ((dvClasss.LastUnion)[dvClass2ValidIndex(_Class)] = (value)) 1360 dvProperty dvClassFindProperty(dvClass Class, utSym Sym); 1361 void dvClassRenameProperty(dvClass Class, dvProperty _Property, utSym sym); 1362 #define dvPropertyGetName(Property) utSymGetName(dvPropertyGetSym(Property)) 1363 #define dvForeachClassProperty(pVar, cVar) \ 1364 for(cVar = dvClassGetFirstProperty(pVar); cVar != dvPropertyNull; \ 1365 cVar = dvPropertyGetNextClassProperty(cVar)) 1366 #define dvEndClassProperty 1367 #define dvSafeForeachClassProperty(pVar, cVar) { \ 1368 dvProperty _nextProperty; \ 1369 for(cVar = dvClassGetFirstProperty(pVar); cVar != dvPropertyNull; cVar = _nextProperty) { \ 1370 _nextProperty = dvPropertyGetNextClassProperty(cVar); 1371 #define dvEndSafeClassProperty }} 1372 dvSparsegroup dvClassFindSparsegroup(dvClass Class, utSym Sym); 1373 void dvClassRenameSparsegroup(dvClass Class, dvSparsegroup _Sparsegroup, utSym sym); 1374 #define dvSparsegroupGetName(Sparsegroup) utSymGetName(dvSparsegroupGetSym(Sparsegroup)) 1375 #define dvForeachClassSparsegroup(pVar, cVar) \ 1376 for(cVar = dvClassGetFirstSparsegroup(pVar); cVar != dvSparsegroupNull; \ 1377 cVar = dvSparsegroupGetNextClassSparsegroup(cVar)) 1378 #define dvEndClassSparsegroup 1379 #define dvSafeForeachClassSparsegroup(pVar, cVar) { \ 1380 dvSparsegroup _nextSparsegroup; \ 1381 for(cVar = dvClassGetFirstSparsegroup(pVar); cVar != dvSparsegroupNull; cVar = _nextSparsegroup) { \ 1382 _nextSparsegroup = dvSparsegroupGetNextClassSparsegroup(cVar); 1383 #define dvEndSafeClassSparsegroup }} 1384 #define dvForeachClassDerivedClass(pVar, cVar) \ 1385 for(cVar = dvClassGetFirstDerivedClass(pVar); cVar != dvClassNull; \ 1386 cVar = dvClassGetNextClassDerivedClass(cVar)) 1387 #define dvEndClassDerivedClass 1388 #define dvSafeForeachClassDerivedClass(pVar, cVar) { \ 1389 dvClass _nextClass; \ 1390 for(cVar = dvClassGetFirstDerivedClass(pVar); cVar != dvClassNull; cVar = _nextClass) { \ 1391 _nextClass = dvClassGetNextClassDerivedClass(cVar); 1392 #define dvEndSafeClassDerivedClass }} 1393 #define dvForeachClassChildRelationship(pVar, cVar) \ 1394 for(cVar = dvClassGetFirstChildRelationship(pVar); cVar != dvRelationshipNull; \ 1395 cVar = dvRelationshipGetNextClassChildRelationship(cVar)) 1396 #define dvEndClassChildRelationship 1397 #define dvSafeForeachClassChildRelationship(pVar, cVar) { \ 1398 dvRelationship _nextRelationship; \ 1399 for(cVar = dvClassGetFirstChildRelationship(pVar); cVar != dvRelationshipNull; cVar = _nextRelationship) { \ 1400 _nextRelationship = dvRelationshipGetNextClassChildRelationship(cVar); 1401 #define dvEndSafeClassChildRelationship }} 1402 #define dvForeachClassParentRelationship(pVar, cVar) \ 1403 for(cVar = dvClassGetFirstParentRelationship(pVar); cVar != dvRelationshipNull; \ 1404 cVar = dvRelationshipGetNextClassParentRelationship(cVar)) 1405 #define dvEndClassParentRelationship 1406 #define dvSafeForeachClassParentRelationship(pVar, cVar) { \ 1407 dvRelationship _nextRelationship; \ 1408 for(cVar = dvClassGetFirstParentRelationship(pVar); cVar != dvRelationshipNull; cVar = _nextRelationship) { \ 1409 _nextRelationship = dvRelationshipGetNextClassParentRelationship(cVar); 1410 #define dvEndSafeClassParentRelationship }} 1411 #define dvForeachClassUnion(pVar, cVar) \ 1412 for(cVar = dvClassGetFirstUnion(pVar); cVar != dvUnionNull; \ 1413 cVar = dvUnionGetNextClassUnion(cVar)) 1414 #define dvEndClassUnion 1415 #define dvSafeForeachClassUnion(pVar, cVar) { \ 1416 dvUnion _nextUnion; \ 1417 for(cVar = dvClassGetFirstUnion(pVar); cVar != dvUnionNull; cVar = _nextUnion) { \ 1418 _nextUnion = dvUnionGetNextClassUnion(cVar); 1419 #define dvEndSafeClassUnion }} 1420 #define dvClassSetConstructorCallback(func) (dvClassConstructorCallback = (func)) 1421 #define dvClassGetConstructorCallback() (dvClassConstructorCallback) 1422 #define dvFirstClass() (dvRootData.usedClass == 0? dvClassNull : dvIndex2Class(0)) 1423 #define dvLastClass() (dvRootData.usedClass == 0? dvClassNull : \ 1424 dvIndex2Class(dvRootData.usedClass - 1)) 1425 #define dvNextClass(Class) (dvClass2ValidIndex(Class) + 1 == dvRootData.usedClass? dvClassNull : \ 1426 (Class) + 1) 1427 #define dvPrevClass(Class) (dvClass2ValidIndex(Class) == 0? dvClassNull : (Class) - 1) 1428 #define dvForeachClass(var) \ 1429 for(var = dvIndex2Class(0); dvClass2Index(var) != dvRootData.usedClass; var++) 1430 #define dvEndClass 1431 #define dvClassFreeAll() (dvSetUsedClass(0), dvSetUsedClassPropertyTable(0), dvSetUsedClassSparsegroupTable(0)) 1432 #define dvClassAllocRaw() ( \ 1433 dvRootData.usedClass == dvRootData.allocatedClass && (dvClassAllocMore(), true), \ 1434 dvTemp_.Class = dvIndex2Class(dvRootData.usedClass), \ 1435 dvSetUsedClass(dvUsedClass() + 1), \ 1436 dvTemp_.Class) 1437 #define dvClassAlloc() ( \ 1438 dvRootData.usedClass == dvRootData.allocatedClass && (dvClassAllocMore(), true), \ 1439 dvTemp_.Class = dvIndex2Class(dvRootData.usedClass), \ 1440 dvSetUsedClass(dvUsedClass() + 1), \ 1441 dvClassSetSym(dvTemp_.Class, utSymNull), \ 1442 dvClassSetMemoryStyle(dvTemp_.Class, 0), \ 1443 dvClassSetReferenceSize(dvTemp_.Class, 0), \ 1444 dvClassSetGenerateArrayClass(dvTemp_.Class, 0), \ 1445 dvClassSetGenerateAttributes(dvTemp_.Class, 0), \ 1446 dvClassSetSparse(dvTemp_.Class, 0), \ 1447 dvClassSetNumFields(dvTemp_.Class, 0), \ 1448 dvClassSetNumber(dvTemp_.Class, 0), \ 1449 dvClassSetModule(dvTemp_.Class, dvModuleNull), \ 1450 dvClassSetNextModuleClass(dvTemp_.Class, dvClassNull), \ 1451 dvClassSetPrevModuleClass(dvTemp_.Class, dvClassNull), \ 1452 dvClassSetNextTableModuleClass(dvTemp_.Class, dvClassNull), \ 1453 dvClassSetFirstProperty(dvTemp_.Class, dvPropertyNull), \ 1454 dvClassSetLastProperty(dvTemp_.Class, dvPropertyNull), \ 1455 dvClassSetPropertyTableIndex(dvTemp_.Class, 0), \ 1456 dvClassSetNumPropertyTable(dvTemp_.Class, 0), \ 1457 dvClassSetNumPropertyTable(dvTemp_.Class, 0), \ 1458 dvClassSetNumProperty(dvTemp_.Class, 0), \ 1459 dvClassSetFreeListProperty(dvTemp_.Class, dvPropertyNull), \ 1460 dvClassSetFirstSparsegroup(dvTemp_.Class, dvSparsegroupNull), \ 1461 dvClassSetLastSparsegroup(dvTemp_.Class, dvSparsegroupNull), \ 1462 dvClassSetSparsegroupTableIndex(dvTemp_.Class, 0), \ 1463 dvClassSetNumSparsegroupTable(dvTemp_.Class, 0), \ 1464 dvClassSetNumSparsegroupTable(dvTemp_.Class, 0), \ 1465 dvClassSetNumSparsegroup(dvTemp_.Class, 0), \ 1466 dvClassSetBaseClass(dvTemp_.Class, dvClassNull), \ 1467 dvClassSetFirstDerivedClass(dvTemp_.Class, dvClassNull), \ 1468 dvClassSetNextClassDerivedClass(dvTemp_.Class, dvClassNull), \ 1469 dvClassSetLastDerivedClass(dvTemp_.Class, dvClassNull), \ 1470 dvClassSetFirstChildRelationship(dvTemp_.Class, dvRelationshipNull), \ 1471 dvClassSetLastChildRelationship(dvTemp_.Class, dvRelationshipNull), \ 1472 dvClassSetFirstParentRelationship(dvTemp_.Class, dvRelationshipNull), \ 1473 dvClassSetLastParentRelationship(dvTemp_.Class, dvRelationshipNull), \ 1474 dvClassSetFirstUnion(dvTemp_.Class, dvUnionNull), \ 1475 dvClassSetLastUnion(dvTemp_.Class, dvUnionNull), \ 1476 dvClassConstructorCallback != NULL && (dvClassConstructorCallback(dvTemp_.Class), true), \ 1477 dvTemp_.Class) 1478 1479 void dvClassAllocMore(void); 1480 void dvClassCopyProps(dvClass dvOldClass, dvClass dvNewClass); 1481 void dvClassSetBitfield(dvClass _Class, uint32 bitfield); 1482 uint32 dvClassGetBitfield(dvClass _Class); 1483 void dvClassAllocPropertyTables(dvClass Class, uint32 numPropertyTables); 1484 void dvClassResizePropertyTables(dvClass Class, uint32 numPropertyTables); 1485 void dvClassFreePropertyTables(dvClass Class); 1486 void dvCompactClassPropertyTables(void); 1487 void dvClassAllocSparsegroupTables(dvClass Class, uint32 numSparsegroupTables); 1488 void dvClassResizeSparsegroupTables(dvClass Class, uint32 numSparsegroupTables); 1489 void dvClassFreeSparsegroupTables(dvClass Class); 1490 void dvCompactClassSparsegroupTables(void); 1491 void dvClassInsertProperty(dvClass Class, dvProperty _Property); 1492 void dvClassRemoveProperty(dvClass Class, dvProperty _Property); 1493 void dvClassInsertAfterProperty(dvClass Class, dvProperty prevProperty, dvProperty _Property); 1494 void dvClassAppendProperty(dvClass Class, dvProperty _Property); 1495 void dvClassInsertSparsegroup(dvClass Class, dvSparsegroup _Sparsegroup); 1496 void dvClassRemoveSparsegroup(dvClass Class, dvSparsegroup _Sparsegroup); 1497 void dvClassInsertAfterSparsegroup(dvClass Class, dvSparsegroup prevSparsegroup, dvSparsegroup _Sparsegroup); 1498 void dvClassAppendSparsegroup(dvClass Class, dvSparsegroup _Sparsegroup); 1499 void dvClassInsertDerivedClass(dvClass Class, dvClass _Class); 1500 void dvClassRemoveDerivedClass(dvClass Class, dvClass _Class); 1501 void dvClassInsertAfterDerivedClass(dvClass Class, dvClass prevClass, dvClass _Class); 1502 void dvClassAppendDerivedClass(dvClass Class, dvClass _Class); 1503 void dvClassInsertChildRelationship(dvClass Class, dvRelationship _Relationship); 1504 void dvClassRemoveChildRelationship(dvClass Class, dvRelationship _Relationship); 1505 void dvClassInsertAfterChildRelationship(dvClass Class, dvRelationship prevRelationship, dvRelationship _Relationship); 1506 void dvClassAppendChildRelationship(dvClass Class, dvRelationship _Relationship); 1507 void dvClassInsertParentRelationship(dvClass Class, dvRelationship _Relationship); 1508 void dvClassRemoveParentRelationship(dvClass Class, dvRelationship _Relationship); 1509 void dvClassInsertAfterParentRelationship(dvClass Class, dvRelationship prevRelationship, dvRelationship _Relationship); 1510 void dvClassAppendParentRelationship(dvClass Class, dvRelationship _Relationship); 1511 void dvClassInsertUnion(dvClass Class, dvUnion _Union); 1512 void dvClassRemoveUnion(dvClass Class, dvUnion _Union); 1513 void dvClassInsertAfterUnion(dvClass Class, dvUnion prevUnion, dvUnion _Union); 1514 void dvClassAppendUnion(dvClass Class, dvUnion _Union); 1515 1516 /*---------------------------------------------------------------------------------------- 1517 Unions for class Property. 1518 ----------------------------------------------------------------------------------------*/ 1519 typedef union { 1520 dvEnum EnumProp; 1521 dvTypedef TypedefProp; 1522 dvClass ClassProp; 1523 utSym TypeSym; 1524 uint8 Width; 1525 } dvPropertyUnion1; 1526 1527 /*---------------------------------------------------------------------------------------- 1528 Fields for class Property. 1529 ----------------------------------------------------------------------------------------*/ 1530 struct dvPropertyFields { 1531 utSym *Sym; 1532 dvPropertyType *Type; 1533 uint8 *Array; 1534 uint8 *Cascade; 1535 uint8 *Sparse; 1536 uint8 *Expanded; 1537 uint32 *FieldNumber; 1538 dvProperty *FirstElementProp; 1539 dvProperty *NumElementsProp; 1540 uint8 *Hidden; 1541 uint32 *InitializerIndex; 1542 uint32 *NumInitializer; 1543 char *Initializer; 1544 uint8 *FixedSize; 1545 uint32 *IndexIndex; 1546 uint32 *NumIndex; 1547 char *Index; 1548 uint32 *Line; 1549 dvClass *Class; 1550 dvProperty *NextClassProperty; 1551 dvProperty *PrevClassProperty; 1552 dvProperty *NextTableClassProperty; 1553 dvCase *FirstCase; 1554 dvCase *LastCase; 1555 dvKey *FirstKey; 1556 dvKey *LastKey; 1557 dvSparsegroup *Sparsegroup; 1558 dvProperty *NextSparsegroupProperty; 1559 dvRelationship *Relationship; 1560 dvProperty *NextRelationshipProperty; 1561 dvUnion *Union; 1562 dvProperty *NextUnionProperty; 1563 dvPropertyUnion1 *union1; 1564 }; 1565 extern struct dvPropertyFields dvPropertys; 1566 1567 #define dvPropertyGetSym(_Property) (dvPropertys.Sym[dvProperty2ValidIndex(_Property)]) 1568 #define dvPropertySetSym(_Property, value) ((dvPropertys.Sym)[dvProperty2ValidIndex(_Property)] = (value)) 1569 #define dvPropertyGetType(_Property) (dvPropertys.Type[dvProperty2ValidIndex(_Property)]) 1570 #define dvPropertySetType(_Property, value) ((dvPropertys.Type)[dvProperty2ValidIndex(_Property)] = (value)) 1571 #define dvPropertyArray(_Property) (((dvPropertys.Array)[dvProperty2ValidIndex(_Property) >> 3] >> \ 1572 (dvProperty2ValidIndex(_Property) & 7)) & 1) 1573 #define dvPropertySetArray(_Property, value) ((dvPropertys.Array)[dvProperty2ValidIndex(_Property) >> 3] = \ 1574 (uint8)(((dvPropertys.Array)[dvProperty2ValidIndex(_Property) >> 3] & ~(1 << (dvProperty2ValidIndex(_Property) & 7))) | \ 1575 (((value) != 0) << (dvProperty2ValidIndex(_Property) & 7)))) 1576 #define dvPropertyCascade(_Property) (((dvPropertys.Cascade)[dvProperty2ValidIndex(_Property) >> 3] >> \ 1577 (dvProperty2ValidIndex(_Property) & 7)) & 1) 1578 #define dvPropertySetCascade(_Property, value) ((dvPropertys.Cascade)[dvProperty2ValidIndex(_Property) >> 3] = \ 1579 (uint8)(((dvPropertys.Cascade)[dvProperty2ValidIndex(_Property) >> 3] & ~(1 << (dvProperty2ValidIndex(_Property) & 7))) | \ 1580 (((value) != 0) << (dvProperty2ValidIndex(_Property) & 7)))) 1581 #define dvPropertySparse(_Property) (((dvPropertys.Sparse)[dvProperty2ValidIndex(_Property) >> 3] >> \ 1582 (dvProperty2ValidIndex(_Property) & 7)) & 1) 1583 #define dvPropertySetSparse(_Property, value) ((dvPropertys.Sparse)[dvProperty2ValidIndex(_Property) >> 3] = \ 1584 (uint8)(((dvPropertys.Sparse)[dvProperty2ValidIndex(_Property) >> 3] & ~(1 << (dvProperty2ValidIndex(_Property) & 7))) | \ 1585 (((value) != 0) << (dvProperty2ValidIndex(_Property) & 7)))) 1586 #define dvPropertyExpanded(_Property) (((dvPropertys.Expanded)[dvProperty2ValidIndex(_Property) >> 3] >> \ 1587 (dvProperty2ValidIndex(_Property) & 7)) & 1) 1588 #define dvPropertySetExpanded(_Property, value) ((dvPropertys.Expanded)[dvProperty2ValidIndex(_Property) >> 3] = \ 1589 (uint8)(((dvPropertys.Expanded)[dvProperty2ValidIndex(_Property) >> 3] & ~(1 << (dvProperty2ValidIndex(_Property) & 7))) | \ 1590 (((value) != 0) << (dvProperty2ValidIndex(_Property) & 7)))) 1591 #define dvPropertyGetFieldNumber(_Property) (dvPropertys.FieldNumber[dvProperty2ValidIndex(_Property)]) 1592 #define dvPropertySetFieldNumber(_Property, value) ((dvPropertys.FieldNumber)[dvProperty2ValidIndex(_Property)] = (value)) 1593 #define dvPropertyGetFirstElementProp(_Property) (dvPropertys.FirstElementProp[dvProperty2ValidIndex(_Property)]) 1594 #define dvPropertySetFirstElementProp(_Property, value) ((dvPropertys.FirstElementProp)[dvProperty2ValidIndex(_Property)] = (value)) 1595 #define dvPropertyGetNumElementsProp(_Property) (dvPropertys.NumElementsProp[dvProperty2ValidIndex(_Property)]) 1596 #define dvPropertySetNumElementsProp(_Property, value) ((dvPropertys.NumElementsProp)[dvProperty2ValidIndex(_Property)] = (value)) 1597 #define dvPropertyHidden(_Property) (((dvPropertys.Hidden)[dvProperty2ValidIndex(_Property) >> 3] >> \ 1598 (dvProperty2ValidIndex(_Property) & 7)) & 1) 1599 #define dvPropertySetHidden(_Property, value) ((dvPropertys.Hidden)[dvProperty2ValidIndex(_Property) >> 3] = \ 1600 (uint8)(((dvPropertys.Hidden)[dvProperty2ValidIndex(_Property) >> 3] & ~(1 << (dvProperty2ValidIndex(_Property) & 7))) | \ 1601 (((value) != 0) << (dvProperty2ValidIndex(_Property) & 7)))) 1602 #define dvPropertyGetInitializerIndex(_Property) (dvPropertys.InitializerIndex[dvProperty2ValidIndex(_Property)]) 1603 #define dvPropertySetInitializerIndex(_Property, value) ((dvPropertys.InitializerIndex)[dvProperty2ValidIndex(_Property)] = (value)) 1604 #define dvPropertyGetNumInitializer(_Property) (dvPropertys.NumInitializer[dvProperty2ValidIndex(_Property)]) 1605 #define dvPropertySetNumInitializer(_Property, value) ((dvPropertys.NumInitializer)[dvProperty2ValidIndex(_Property)] = (value)) 1606 #if defined(DD_DEBUG) 1607 #define dvPropertyCheckInitializerIndex(Property, x) ((uint32)(x) < dvPropertyGetNumInitializer(Property)? (x) : \ 1608 (utAssert(false),(x))) 1609 #else 1610 #define dvPropertyCheckInitializerIndex(Property, x) (x) 1611 #endif 1612 #define dvPropertyGetiInitializer(_Property, x) ((dvPropertys.Initializer)[ \ 1613 dvPropertyGetInitializerIndex(_Property) + dvPropertyCheckInitializerIndex(_Property, (x))]) 1614 #define dvPropertyGetInitializer(Property) (dvPropertys.Initializer + dvPropertyGetInitializerIndex(Property)) 1615 #define dvPropertyGetInitializers dvPropertyGetInitializer 1616 #define dvPropertySetInitializer(Property, valuePtr, numInitializer) (dvPropertyResizeInitializers(Property, numInitializer), memcpy(dvPropertyGetInitializers(Property), valuePtr, \ 1617 numInitializer*sizeof(char))) 1618 #define dvPropertySetiInitializer(Property, x, value) ((dvPropertys.Initializer)[ \ 1619 dvPropertyGetInitializerIndex(Property) + dvPropertyCheckInitializerIndex(Property, (x))] = (value)) 1620 #define dvPropertyFixedSize(_Property) (((dvPropertys.FixedSize)[dvProperty2ValidIndex(_Property) >> 3] >> \ 1621 (dvProperty2ValidIndex(_Property) & 7)) & 1) 1622 #define dvPropertySetFixedSize(_Property, value) ((dvPropertys.FixedSize)[dvProperty2ValidIndex(_Property) >> 3] = \ 1623 (uint8)(((dvPropertys.FixedSize)[dvProperty2ValidIndex(_Property) >> 3] & ~(1 << (dvProperty2ValidIndex(_Property) & 7))) | \ 1624 (((value) != 0) << (dvProperty2ValidIndex(_Property) & 7)))) 1625 #define dvPropertyGetIndexIndex(_Property) (dvPropertys.IndexIndex[dvProperty2ValidIndex(_Property)]) 1626 #define dvPropertySetIndexIndex(_Property, value) ((dvPropertys.IndexIndex)[dvProperty2ValidIndex(_Property)] = (value)) 1627 #define dvPropertyGetNumIndex(_Property) (dvPropertys.NumIndex[dvProperty2ValidIndex(_Property)]) 1628 #define dvPropertySetNumIndex(_Property, value) ((dvPropertys.NumIndex)[dvProperty2ValidIndex(_Property)] = (value)) 1629 #if defined(DD_DEBUG) 1630 #define dvPropertyCheckIndexIndex(Property, x) ((uint32)(x) < dvPropertyGetNumIndex(Property)? (x) : \ 1631 (utAssert(false),(x))) 1632 #else 1633 #define dvPropertyCheckIndexIndex(Property, x) (x) 1634 #endif 1635 #define dvPropertyGetiIndex(_Property, x) ((dvPropertys.Index)[ \ 1636 dvPropertyGetIndexIndex(_Property) + dvPropertyCheckIndexIndex(_Property, (x))]) 1637 #define dvPropertyGetIndex(Property) (dvPropertys.Index + dvPropertyGetIndexIndex(Property)) 1638 #define dvPropertyGetIndexs dvPropertyGetIndex 1639 #define dvPropertySetIndex(Property, valuePtr, numIndex) (dvPropertyResizeIndexs(Property, numIndex), memcpy(dvPropertyGetIndexs(Property), valuePtr, \ 1640 numIndex*sizeof(char))) 1641 #define dvPropertySetiIndex(Property, x, value) ((dvPropertys.Index)[ \ 1642 dvPropertyGetIndexIndex(Property) + dvPropertyCheckIndexIndex(Property, (x))] = (value)) 1643 #define dvPropertyGetEnumProp(_Property) (dvPropertys.union1[dvProperty2ValidIndex(_Property)].EnumProp) 1644 #define dvPropertySetEnumProp(_Property, value) \ 1645 (dvPropertys.union1[dvProperty2ValidIndex(_Property)].EnumProp = (value)) 1646 #define dvPropertyGetTypedefProp(_Property) (dvPropertys.union1[dvProperty2ValidIndex(_Property)].TypedefProp) 1647 #define dvPropertySetTypedefProp(_Property, value) \ 1648 (dvPropertys.union1[dvProperty2ValidIndex(_Property)].TypedefProp = (value)) 1649 #define dvPropertyGetClassProp(_Property) (dvPropertys.union1[dvProperty2ValidIndex(_Property)].ClassProp) 1650 #define dvPropertySetClassProp(_Property, value) \ 1651 (dvPropertys.union1[dvProperty2ValidIndex(_Property)].ClassProp = (value)) 1652 #define dvPropertyGetTypeSym(_Property) (dvPropertys.union1[dvProperty2ValidIndex(_Property)].TypeSym) 1653 #define dvPropertySetTypeSym(_Property, value) \ 1654 (dvPropertys.union1[dvProperty2ValidIndex(_Property)].TypeSym = (value)) 1655 #define dvPropertyGetWidth(_Property) (dvPropertys.union1[dvProperty2ValidIndex(_Property)].Width) 1656 #define dvPropertySetWidth(_Property, value) \ 1657 (dvPropertys.union1[dvProperty2ValidIndex(_Property)].Width = (value)) 1658 #define dvPropertyGetLine(_Property) (dvPropertys.Line[dvProperty2ValidIndex(_Property)]) 1659 #define dvPropertySetLine(_Property, value) ((dvPropertys.Line)[dvProperty2ValidIndex(_Property)] = (value)) 1660 #define dvPropertyGetClass(_Property) (dvPropertys.Class[dvProperty2ValidIndex(_Property)]) 1661 #define dvPropertySetClass(_Property, value) ((dvPropertys.Class)[dvProperty2ValidIndex(_Property)] = (value)) 1662 #define dvPropertyGetNextClassProperty(_Property) (dvPropertys.NextClassProperty[dvProperty2ValidIndex(_Property)]) 1663 #define dvPropertySetNextClassProperty(_Property, value) ((dvPropertys.NextClassProperty)[dvProperty2ValidIndex(_Property)] = (value)) 1664 #define dvPropertyGetPrevClassProperty(_Property) (dvPropertys.PrevClassProperty[dvProperty2ValidIndex(_Property)]) 1665 #define dvPropertySetPrevClassProperty(_Property, value) ((dvPropertys.PrevClassProperty)[dvProperty2ValidIndex(_Property)] = (value)) 1666 #define dvPropertyGetNextTableClassProperty(_Property) (dvPropertys.NextTableClassProperty[dvProperty2ValidIndex(_Property)]) 1667 #define dvPropertySetNextTableClassProperty(_Property, value) ((dvPropertys.NextTableClassProperty)[dvProperty2ValidIndex(_Property)] = (value)) 1668 #define dvPropertyGetFirstCase(_Property) (dvPropertys.FirstCase[dvProperty2ValidIndex(_Property)]) 1669 #define dvPropertySetFirstCase(_Property, value) ((dvPropertys.FirstCase)[dvProperty2ValidIndex(_Property)] = (value)) 1670 #define dvPropertyGetLastCase(_Property) (dvPropertys.LastCase[dvProperty2ValidIndex(_Property)]) 1671 #define dvPropertySetLastCase(_Property, value) ((dvPropertys.LastCase)[dvProperty2ValidIndex(_Property)] = (value)) 1672 #define dvPropertyGetFirstKey(_Property) (dvPropertys.FirstKey[dvProperty2ValidIndex(_Property)]) 1673 #define dvPropertySetFirstKey(_Property, value) ((dvPropertys.FirstKey)[dvProperty2ValidIndex(_Property)] = (value)) 1674 #define dvPropertyGetLastKey(_Property) (dvPropertys.LastKey[dvProperty2ValidIndex(_Property)]) 1675 #define dvPropertySetLastKey(_Property, value) ((dvPropertys.LastKey)[dvProperty2ValidIndex(_Property)] = (value)) 1676 #define dvPropertyGetSparsegroup(_Property) (dvPropertys.Sparsegroup[dvProperty2ValidIndex(_Property)]) 1677 #define dvPropertySetSparsegroup(_Property, value) ((dvPropertys.Sparsegroup)[dvProperty2ValidIndex(_Property)] = (value)) 1678 #define dvPropertyGetNextSparsegroupProperty(_Property) (dvPropertys.NextSparsegroupProperty[dvProperty2ValidIndex(_Property)]) 1679 #define dvPropertySetNextSparsegroupProperty(_Property, value) ((dvPropertys.NextSparsegroupProperty)[dvProperty2ValidIndex(_Property)] = (value)) 1680 #define dvPropertyGetRelationship(_Property) (dvPropertys.Relationship[dvProperty2ValidIndex(_Property)]) 1681 #define dvPropertySetRelationship(_Property, value) ((dvPropertys.Relationship)[dvProperty2ValidIndex(_Property)] = (value)) 1682 #define dvPropertyGetNextRelationshipProperty(_Property) (dvPropertys.NextRelationshipProperty[dvProperty2ValidIndex(_Property)]) 1683 #define dvPropertySetNextRelationshipProperty(_Property, value) ((dvPropertys.NextRelationshipProperty)[dvProperty2ValidIndex(_Property)] = (value)) 1684 #define dvPropertyGetUnion(_Property) (dvPropertys.Union[dvProperty2ValidIndex(_Property)]) 1685 #define dvPropertySetUnion(_Property, value) ((dvPropertys.Union)[dvProperty2ValidIndex(_Property)] = (value)) 1686 #define dvPropertyGetNextUnionProperty(_Property) (dvPropertys.NextUnionProperty[dvProperty2ValidIndex(_Property)]) 1687 #define dvPropertySetNextUnionProperty(_Property, value) ((dvPropertys.NextUnionProperty)[dvProperty2ValidIndex(_Property)] = (value)) 1688 #define dvForeachPropertyCase(pVar, cVar) \ 1689 for(cVar = dvPropertyGetFirstCase(pVar); cVar != dvCaseNull; \ 1690 cVar = dvCaseGetNextPropertyCase(cVar)) 1691 #define dvEndPropertyCase 1692 #define dvSafeForeachPropertyCase(pVar, cVar) { \ 1693 dvCase _nextCase; \ 1694 for(cVar = dvPropertyGetFirstCase(pVar); cVar != dvCaseNull; cVar = _nextCase) { \ 1695 _nextCase = dvCaseGetNextPropertyCase(cVar); 1696 #define dvEndSafePropertyCase }} 1697 #define dvForeachPropertyKey(pVar, cVar) \ 1698 for(cVar = dvPropertyGetFirstKey(pVar); cVar != dvKeyNull; \ 1699 cVar = dvKeyGetNextPropertyKey(cVar)) 1700 #define dvEndPropertyKey 1701 #define dvSafeForeachPropertyKey(pVar, cVar) { \ 1702 dvKey _nextKey; \ 1703 for(cVar = dvPropertyGetFirstKey(pVar); cVar != dvKeyNull; cVar = _nextKey) { \ 1704 _nextKey = dvKeyGetNextPropertyKey(cVar); 1705 #define dvEndSafePropertyKey }} 1706 #define dvPropertySetConstructorCallback(func) (dvPropertyConstructorCallback = (func)) 1707 #define dvPropertyGetConstructorCallback() (dvPropertyConstructorCallback) 1708 #define dvFirstProperty() (dvRootData.usedProperty == 0? dvPropertyNull : dvIndex2Property(0)) 1709 #define dvLastProperty() (dvRootData.usedProperty == 0? dvPropertyNull : \ 1710 dvIndex2Property(dvRootData.usedProperty - 1)) 1711 #define dvNextProperty(Property) (dvProperty2ValidIndex(Property) + 1 == dvRootData.usedProperty? dvPropertyNull : \ 1712 (Property) + 1) 1713 #define dvPrevProperty(Property) (dvProperty2ValidIndex(Property) == 0? dvPropertyNull : (Property) - 1) 1714 #define dvForeachProperty(var) \ 1715 for(var = dvIndex2Property(0); dvProperty2Index(var) != dvRootData.usedProperty; var++) 1716 #define dvEndProperty 1717 #define dvPropertyFreeAll() (dvSetUsedProperty(0), dvSetUsedPropertyInitializer(0), dvSetUsedPropertyIndex(0)) 1718 #define dvPropertyAllocRaw() ( \ 1719 dvRootData.usedProperty == dvRootData.allocatedProperty && (dvPropertyAllocMore(), true), \ 1720 dvTemp_.Property = dvIndex2Property(dvRootData.usedProperty), \ 1721 dvSetUsedProperty(dvUsedProperty() + 1), \ 1722 dvTemp_.Property) 1723 #define dvPropertyAlloc() ( \ 1724 dvRootData.usedProperty == dvRootData.allocatedProperty && (dvPropertyAllocMore(), true), \ 1725 dvTemp_.Property = dvIndex2Property(dvRootData.usedProperty), \ 1726 dvSetUsedProperty(dvUsedProperty() + 1), \ 1727 dvPropertySetSym(dvTemp_.Property, utSymNull), \ 1728 dvPropertySetType(dvTemp_.Property, 0), \ 1729 dvPropertySetArray(dvTemp_.Property, 0), \ 1730 dvPropertySetCascade(dvTemp_.Property, 0), \ 1731 dvPropertySetSparse(dvTemp_.Property, 0), \ 1732 dvPropertySetExpanded(dvTemp_.Property, 0), \ 1733 dvPropertySetFieldNumber(dvTemp_.Property, 0), \ 1734 dvPropertySetFirstElementProp(dvTemp_.Property, dvPropertyNull), \ 1735 dvPropertySetNumElementsProp(dvTemp_.Property, dvPropertyNull), \ 1736 dvPropertySetHidden(dvTemp_.Property, 0), \ 1737 dvPropertySetInitializerIndex(dvTemp_.Property, 0), \ 1738 dvPropertySetNumInitializer(dvTemp_.Property, 0), \ 1739 dvPropertySetNumInitializer(dvTemp_.Property, 0), \ 1740 dvPropertySetFixedSize(dvTemp_.Property, 0), \ 1741 dvPropertySetIndexIndex(dvTemp_.Property, 0), \ 1742 dvPropertySetNumIndex(dvTemp_.Property, 0), \ 1743 dvPropertySetNumIndex(dvTemp_.Property, 0), \ 1744 dvPropertySetEnumProp(dvTemp_.Property, dvEnumNull), \ 1745 dvPropertySetLine(dvTemp_.Property, 0), \ 1746 dvPropertySetClass(dvTemp_.Property, dvClassNull), \ 1747 dvPropertySetNextClassProperty(dvTemp_.Property, dvPropertyNull), \ 1748 dvPropertySetPrevClassProperty(dvTemp_.Property, dvPropertyNull), \ 1749 dvPropertySetNextTableClassProperty(dvTemp_.Property, dvPropertyNull), \ 1750 dvPropertySetFirstCase(dvTemp_.Property, dvCaseNull), \ 1751 dvPropertySetLastCase(dvTemp_.Property, dvCaseNull), \ 1752 dvPropertySetFirstKey(dvTemp_.Property, dvKeyNull), \ 1753 dvPropertySetLastKey(dvTemp_.Property, dvKeyNull), \ 1754 dvPropertySetSparsegroup(dvTemp_.Property, dvSparsegroupNull), \ 1755 dvPropertySetNextSparsegroupProperty(dvTemp_.Property, dvPropertyNull), \ 1756 dvPropertySetRelationship(dvTemp_.Property, dvRelationshipNull), \ 1757 dvPropertySetNextRelationshipProperty(dvTemp_.Property, dvPropertyNull), \ 1758 dvPropertySetUnion(dvTemp_.Property, dvUnionNull), \ 1759 dvPropertySetNextUnionProperty(dvTemp_.Property, dvPropertyNull), \ 1760 dvPropertyConstructorCallback != NULL && (dvPropertyConstructorCallback(dvTemp_.Property), true), \ 1761 dvTemp_.Property) 1762 1763 void dvPropertyAllocMore(void); 1764 void dvPropertyCopyProps(dvProperty dvOldProperty, dvProperty dvNewProperty); 1765 void dvPropertySetBitfield(dvProperty _Property, uint32 bitfield); 1766 uint32 dvPropertyGetBitfield(dvProperty _Property); 1767 void dvPropertyAllocInitializers(dvProperty Property, uint32 numInitializers); 1768 void dvPropertyResizeInitializers(dvProperty Property, uint32 numInitializers); 1769 void dvPropertyFreeInitializers(dvProperty Property); 1770 void dvCompactPropertyInitializers(void); 1771 void dvPropertyAllocIndexs(dvProperty Property, uint32 numIndexs); 1772 void dvPropertyResizeIndexs(dvProperty Property, uint32 numIndexs); 1773 void dvPropertyFreeIndexs(dvProperty Property); 1774 void dvCompactPropertyIndexs(void); 1775 void dvPropertyInsertCase(dvProperty Property, dvCase _Case); 1776 void dvPropertyRemoveCase(dvProperty Property, dvCase _Case); 1777 void dvPropertyInsertAfterCase(dvProperty Property, dvCase prevCase, dvCase _Case); 1778 void dvPropertyAppendCase(dvProperty Property, dvCase _Case); 1779 void dvPropertyInsertKey(dvProperty Property, dvKey _Key); 1780 void dvPropertyRemoveKey(dvProperty Property, dvKey _Key); 1781 void dvPropertyInsertAfterKey(dvProperty Property, dvKey prevKey, dvKey _Key); 1782 void dvPropertyAppendKey(dvProperty Property, dvKey _Key); 1783 1784 /*---------------------------------------------------------------------------------------- 1785 Fields for class Sparsegroup. 1786 ----------------------------------------------------------------------------------------*/ 1787 struct dvSparsegroupFields { 1788 utSym *Sym; 1789 dvClass *Class; 1790 dvSparsegroup *NextClassSparsegroup; 1791 dvSparsegroup *PrevClassSparsegroup; 1792 dvSparsegroup *NextTableClassSparsegroup; 1793 dvProperty *FirstProperty; 1794 dvProperty *LastProperty; 1795 dvRelationship *Relationship; 1796 }; 1797 extern struct dvSparsegroupFields dvSparsegroups; 1798 1799 #define dvSparsegroupGetSym(_Sparsegroup) (dvSparsegroups.Sym[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1800 #define dvSparsegroupSetSym(_Sparsegroup, value) ((dvSparsegroups.Sym)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1801 #define dvSparsegroupGetClass(_Sparsegroup) (dvSparsegroups.Class[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1802 #define dvSparsegroupSetClass(_Sparsegroup, value) ((dvSparsegroups.Class)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1803 #define dvSparsegroupGetNextClassSparsegroup(_Sparsegroup) (dvSparsegroups.NextClassSparsegroup[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1804 #define dvSparsegroupSetNextClassSparsegroup(_Sparsegroup, value) ((dvSparsegroups.NextClassSparsegroup)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1805 #define dvSparsegroupGetPrevClassSparsegroup(_Sparsegroup) (dvSparsegroups.PrevClassSparsegroup[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1806 #define dvSparsegroupSetPrevClassSparsegroup(_Sparsegroup, value) ((dvSparsegroups.PrevClassSparsegroup)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1807 #define dvSparsegroupGetNextTableClassSparsegroup(_Sparsegroup) (dvSparsegroups.NextTableClassSparsegroup[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1808 #define dvSparsegroupSetNextTableClassSparsegroup(_Sparsegroup, value) ((dvSparsegroups.NextTableClassSparsegroup)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1809 #define dvSparsegroupGetFirstProperty(_Sparsegroup) (dvSparsegroups.FirstProperty[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1810 #define dvSparsegroupSetFirstProperty(_Sparsegroup, value) ((dvSparsegroups.FirstProperty)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1811 #define dvSparsegroupGetLastProperty(_Sparsegroup) (dvSparsegroups.LastProperty[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1812 #define dvSparsegroupSetLastProperty(_Sparsegroup, value) ((dvSparsegroups.LastProperty)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1813 #define dvSparsegroupGetRelationship(_Sparsegroup) (dvSparsegroups.Relationship[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1814 #define dvSparsegroupSetRelationship(_Sparsegroup, value) ((dvSparsegroups.Relationship)[dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1815 #define dvForeachSparsegroupProperty(pVar, cVar) \ 1816 for(cVar = dvSparsegroupGetFirstProperty(pVar); cVar != dvPropertyNull; \ 1817 cVar = dvPropertyGetNextSparsegroupProperty(cVar)) 1818 #define dvEndSparsegroupProperty 1819 #define dvSafeForeachSparsegroupProperty(pVar, cVar) { \ 1820 dvProperty _nextProperty; \ 1821 for(cVar = dvSparsegroupGetFirstProperty(pVar); cVar != dvPropertyNull; cVar = _nextProperty) { \ 1822 _nextProperty = dvPropertyGetNextSparsegroupProperty(cVar); 1823 #define dvEndSafeSparsegroupProperty }} 1824 #define dvSparsegroupSetConstructorCallback(func) (dvSparsegroupConstructorCallback = (func)) 1825 #define dvSparsegroupGetConstructorCallback() (dvSparsegroupConstructorCallback) 1826 #define dvSparsegroupSetDestructorCallback(func) (dvSparsegroupDestructorCallback = (func)) 1827 #define dvSparsegroupGetDestructorCallback() (dvSparsegroupDestructorCallback) 1828 #define dvSparsegroupNextFree(_Sparsegroup) (((dvSparsegroup *)(void *)(dvSparsegroups.Class))[dvSparsegroup2ValidIndex(_Sparsegroup)]) 1829 #define dvSparsegroupSetNextFree(_Sparsegroup, value) (((dvSparsegroup *)(void *)(dvSparsegroups.Class)) \ 1830 [dvSparsegroup2ValidIndex(_Sparsegroup)] = (value)) 1831 #define dvSparsegroupAllocRaw() ( \ 1832 dvRootData.firstFreeSparsegroup != dvSparsegroupNull? \ 1833 (dvTemp_.Sparsegroup = dvRootData.firstFreeSparsegroup, \ 1834 dvSetFirstFreeSparsegroup(dvSparsegroupNextFree(dvTemp_.Sparsegroup)), true) \ 1835 : (dvRootData.usedSparsegroup == dvRootData.allocatedSparsegroup && (dvSparsegroupAllocMore(), true), \ 1836 dvTemp_.Sparsegroup = dvIndex2Sparsegroup(dvRootData.usedSparsegroup), \ 1837 dvSetUsedSparsegroup(dvUsedSparsegroup() + 1)), \ 1838 dvTemp_.Sparsegroup) 1839 #define dvSparsegroupAlloc() ( \ 1840 dvRootData.firstFreeSparsegroup != dvSparsegroupNull? \ 1841 (dvTemp_.Sparsegroup = dvRootData.firstFreeSparsegroup, \ 1842 dvSetFirstFreeSparsegroup(dvSparsegroupNextFree(dvTemp_.Sparsegroup)), true) \ 1843 : (dvRootData.usedSparsegroup == dvRootData.allocatedSparsegroup && (dvSparsegroupAllocMore(), true), \ 1844 dvTemp_.Sparsegroup = dvIndex2Sparsegroup(dvRootData.usedSparsegroup), \ 1845 dvSetUsedSparsegroup(dvUsedSparsegroup() + 1)), \ 1846 dvSparsegroupSetSym(dvTemp_.Sparsegroup, utSymNull), \ 1847 dvSparsegroupSetClass(dvTemp_.Sparsegroup, dvClassNull), \ 1848 dvSparsegroupSetNextClassSparsegroup(dvTemp_.Sparsegroup, dvSparsegroupNull), \ 1849 dvSparsegroupSetPrevClassSparsegroup(dvTemp_.Sparsegroup, dvSparsegroupNull), \ 1850 dvSparsegroupSetNextTableClassSparsegroup(dvTemp_.Sparsegroup, dvSparsegroupNull), \ 1851 dvSparsegroupSetFirstProperty(dvTemp_.Sparsegroup, dvPropertyNull), \ 1852 dvSparsegroupSetLastProperty(dvTemp_.Sparsegroup, dvPropertyNull), \ 1853 dvSparsegroupSetRelationship(dvTemp_.Sparsegroup, dvRelationshipNull), \ 1854 dvSparsegroupConstructorCallback != NULL && (dvSparsegroupConstructorCallback(dvTemp_.Sparsegroup), true), \ 1855 dvTemp_.Sparsegroup) 1856 1857 #define dvSparsegroupFree(Sparsegroup) (dvSparsegroupSetNextFree(Sparsegroup, dvRootData.firstFreeSparsegroup), \ 1858 dvSetFirstFreeSparsegroup(Sparsegroup)) 1859 void dvSparsegroupDestroy(dvSparsegroup Sparsegroup); 1860 void dvSparsegroupAllocMore(void); 1861 void dvSparsegroupCopyProps(dvSparsegroup dvOldSparsegroup, dvSparsegroup dvNewSparsegroup); 1862 void dvSparsegroupInsertProperty(dvSparsegroup Sparsegroup, dvProperty _Property); 1863 void dvSparsegroupRemoveProperty(dvSparsegroup Sparsegroup, dvProperty _Property); 1864 void dvSparsegroupInsertAfterProperty(dvSparsegroup Sparsegroup, dvProperty prevProperty, dvProperty _Property); 1865 void dvSparsegroupAppendProperty(dvSparsegroup Sparsegroup, dvProperty _Property); 1866 1867 /*---------------------------------------------------------------------------------------- 1868 Fields for class Relationship. 1869 ----------------------------------------------------------------------------------------*/ 1870 struct dvRelationshipFields { 1871 dvRelationshipType *Type; 1872 utSym *ParentLabelSym; 1873 utSym *ChildLabelSym; 1874 uint8 *Mandatory; 1875 uint8 *Cascade; 1876 uint8 *AccessChild; 1877 uint8 *AccessParent; 1878 uint8 *SharedParent; 1879 uint8 *Sparse; 1880 uint8 *Expanded; 1881 dvSchema *Schema; 1882 dvRelationship *NextSchemaRelationship; 1883 dvClass *ParentClass; 1884 dvRelationship *NextClassChildRelationship; 1885 dvClass *ChildClass; 1886 dvRelationship *NextClassParentRelationship; 1887 dvProperty *FirstProperty; 1888 dvProperty *LastProperty; 1889 dvKey *FirstKey; 1890 dvKey *LastKey; 1891 dvSparsegroup *ParentSparsegroup; 1892 dvSparsegroup *ChildSparsegroup; 1893 }; 1894 extern struct dvRelationshipFields dvRelationships; 1895 1896 #define dvRelationshipGetType(_Relationship) (dvRelationships.Type[dvRelationship2ValidIndex(_Relationship)]) 1897 #define dvRelationshipSetType(_Relationship, value) ((dvRelationships.Type)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1898 #define dvRelationshipGetParentLabelSym(_Relationship) (dvRelationships.ParentLabelSym[dvRelationship2ValidIndex(_Relationship)]) 1899 #define dvRelationshipSetParentLabelSym(_Relationship, value) ((dvRelationships.ParentLabelSym)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1900 #define dvRelationshipGetChildLabelSym(_Relationship) (dvRelationships.ChildLabelSym[dvRelationship2ValidIndex(_Relationship)]) 1901 #define dvRelationshipSetChildLabelSym(_Relationship, value) ((dvRelationships.ChildLabelSym)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1902 #define dvRelationshipMandatory(_Relationship) (((dvRelationships.Mandatory)[dvRelationship2ValidIndex(_Relationship) >> 3] >> \ 1903 (dvRelationship2ValidIndex(_Relationship) & 7)) & 1) 1904 #define dvRelationshipSetMandatory(_Relationship, value) ((dvRelationships.Mandatory)[dvRelationship2ValidIndex(_Relationship) >> 3] = \ 1905 (uint8)(((dvRelationships.Mandatory)[dvRelationship2ValidIndex(_Relationship) >> 3] & ~(1 << (dvRelationship2ValidIndex(_Relationship) & 7))) | \ 1906 (((value) != 0) << (dvRelationship2ValidIndex(_Relationship) & 7)))) 1907 #define dvRelationshipCascade(_Relationship) (((dvRelationships.Cascade)[dvRelationship2ValidIndex(_Relationship) >> 3] >> \ 1908 (dvRelationship2ValidIndex(_Relationship) & 7)) & 1) 1909 #define dvRelationshipSetCascade(_Relationship, value) ((dvRelationships.Cascade)[dvRelationship2ValidIndex(_Relationship) >> 3] = \ 1910 (uint8)(((dvRelationships.Cascade)[dvRelationship2ValidIndex(_Relationship) >> 3] & ~(1 << (dvRelationship2ValidIndex(_Relationship) & 7))) | \ 1911 (((value) != 0) << (dvRelationship2ValidIndex(_Relationship) & 7)))) 1912 #define dvRelationshipAccessChild(_Relationship) (((dvRelationships.AccessChild)[dvRelationship2ValidIndex(_Relationship) >> 3] >> \ 1913 (dvRelationship2ValidIndex(_Relationship) & 7)) & 1) 1914 #define dvRelationshipSetAccessChild(_Relationship, value) ((dvRelationships.AccessChild)[dvRelationship2ValidIndex(_Relationship) >> 3] = \ 1915 (uint8)(((dvRelationships.AccessChild)[dvRelationship2ValidIndex(_Relationship) >> 3] & ~(1 << (dvRelationship2ValidIndex(_Relationship) & 7))) | \ 1916 (((value) != 0) << (dvRelationship2ValidIndex(_Relationship) & 7)))) 1917 #define dvRelationshipAccessParent(_Relationship) (((dvRelationships.AccessParent)[dvRelationship2ValidIndex(_Relationship) >> 3] >> \ 1918 (dvRelationship2ValidIndex(_Relationship) & 7)) & 1) 1919 #define dvRelationshipSetAccessParent(_Relationship, value) ((dvRelationships.AccessParent)[dvRelationship2ValidIndex(_Relationship) >> 3] = \ 1920 (uint8)(((dvRelationships.AccessParent)[dvRelationship2ValidIndex(_Relationship) >> 3] & ~(1 << (dvRelationship2ValidIndex(_Relationship) & 7))) | \ 1921 (((value) != 0) << (dvRelationship2ValidIndex(_Relationship) & 7)))) 1922 #define dvRelationshipSharedParent(_Relationship) (((dvRelationships.SharedParent)[dvRelationship2ValidIndex(_Relationship) >> 3] >> \ 1923 (dvRelationship2ValidIndex(_Relationship) & 7)) & 1) 1924 #define dvRelationshipSetSharedParent(_Relationship, value) ((dvRelationships.SharedParent)[dvRelationship2ValidIndex(_Relationship) >> 3] = \ 1925 (uint8)(((dvRelationships.SharedParent)[dvRelationship2ValidIndex(_Relationship) >> 3] & ~(1 << (dvRelationship2ValidIndex(_Relationship) & 7))) | \ 1926 (((value) != 0) << (dvRelationship2ValidIndex(_Relationship) & 7)))) 1927 #define dvRelationshipSparse(_Relationship) (((dvRelationships.Sparse)[dvRelationship2ValidIndex(_Relationship) >> 3] >> \ 1928 (dvRelationship2ValidIndex(_Relationship) & 7)) & 1) 1929 #define dvRelationshipSetSparse(_Relationship, value) ((dvRelationships.Sparse)[dvRelationship2ValidIndex(_Relationship) >> 3] = \ 1930 (uint8)(((dvRelationships.Sparse)[dvRelationship2ValidIndex(_Relationship) >> 3] & ~(1 << (dvRelationship2ValidIndex(_Relationship) & 7))) | \ 1931 (((value) != 0) << (dvRelationship2ValidIndex(_Relationship) & 7)))) 1932 #define dvRelationshipExpanded(_Relationship) (((dvRelationships.Expanded)[dvRelationship2ValidIndex(_Relationship) >> 3] >> \ 1933 (dvRelationship2ValidIndex(_Relationship) & 7)) & 1) 1934 #define dvRelationshipSetExpanded(_Relationship, value) ((dvRelationships.Expanded)[dvRelationship2ValidIndex(_Relationship) >> 3] = \ 1935 (uint8)(((dvRelationships.Expanded)[dvRelationship2ValidIndex(_Relationship) >> 3] & ~(1 << (dvRelationship2ValidIndex(_Relationship) & 7))) | \ 1936 (((value) != 0) << (dvRelationship2ValidIndex(_Relationship) & 7)))) 1937 #define dvRelationshipGetSchema(_Relationship) (dvRelationships.Schema[dvRelationship2ValidIndex(_Relationship)]) 1938 #define dvRelationshipSetSchema(_Relationship, value) ((dvRelationships.Schema)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1939 #define dvRelationshipGetNextSchemaRelationship(_Relationship) (dvRelationships.NextSchemaRelationship[dvRelationship2ValidIndex(_Relationship)]) 1940 #define dvRelationshipSetNextSchemaRelationship(_Relationship, value) ((dvRelationships.NextSchemaRelationship)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1941 #define dvRelationshipGetParentClass(_Relationship) (dvRelationships.ParentClass[dvRelationship2ValidIndex(_Relationship)]) 1942 #define dvRelationshipSetParentClass(_Relationship, value) ((dvRelationships.ParentClass)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1943 #define dvRelationshipGetNextClassChildRelationship(_Relationship) (dvRelationships.NextClassChildRelationship[dvRelationship2ValidIndex(_Relationship)]) 1944 #define dvRelationshipSetNextClassChildRelationship(_Relationship, value) ((dvRelationships.NextClassChildRelationship)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1945 #define dvRelationshipGetChildClass(_Relationship) (dvRelationships.ChildClass[dvRelationship2ValidIndex(_Relationship)]) 1946 #define dvRelationshipSetChildClass(_Relationship, value) ((dvRelationships.ChildClass)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1947 #define dvRelationshipGetNextClassParentRelationship(_Relationship) (dvRelationships.NextClassParentRelationship[dvRelationship2ValidIndex(_Relationship)]) 1948 #define dvRelationshipSetNextClassParentRelationship(_Relationship, value) ((dvRelationships.NextClassParentRelationship)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1949 #define dvRelationshipGetFirstProperty(_Relationship) (dvRelationships.FirstProperty[dvRelationship2ValidIndex(_Relationship)]) 1950 #define dvRelationshipSetFirstProperty(_Relationship, value) ((dvRelationships.FirstProperty)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1951 #define dvRelationshipGetLastProperty(_Relationship) (dvRelationships.LastProperty[dvRelationship2ValidIndex(_Relationship)]) 1952 #define dvRelationshipSetLastProperty(_Relationship, value) ((dvRelationships.LastProperty)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1953 #define dvRelationshipGetFirstKey(_Relationship) (dvRelationships.FirstKey[dvRelationship2ValidIndex(_Relationship)]) 1954 #define dvRelationshipSetFirstKey(_Relationship, value) ((dvRelationships.FirstKey)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1955 #define dvRelationshipGetLastKey(_Relationship) (dvRelationships.LastKey[dvRelationship2ValidIndex(_Relationship)]) 1956 #define dvRelationshipSetLastKey(_Relationship, value) ((dvRelationships.LastKey)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1957 #define dvRelationshipGetParentSparsegroup(_Relationship) (dvRelationships.ParentSparsegroup[dvRelationship2ValidIndex(_Relationship)]) 1958 #define dvRelationshipSetParentSparsegroup(_Relationship, value) ((dvRelationships.ParentSparsegroup)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1959 #define dvRelationshipGetChildSparsegroup(_Relationship) (dvRelationships.ChildSparsegroup[dvRelationship2ValidIndex(_Relationship)]) 1960 #define dvRelationshipSetChildSparsegroup(_Relationship, value) ((dvRelationships.ChildSparsegroup)[dvRelationship2ValidIndex(_Relationship)] = (value)) 1961 #define dvForeachRelationshipProperty(pVar, cVar) \ 1962 for(cVar = dvRelationshipGetFirstProperty(pVar); cVar != dvPropertyNull; \ 1963 cVar = dvPropertyGetNextRelationshipProperty(cVar)) 1964 #define dvEndRelationshipProperty 1965 #define dvSafeForeachRelationshipProperty(pVar, cVar) { \ 1966 dvProperty _nextProperty; \ 1967 for(cVar = dvRelationshipGetFirstProperty(pVar); cVar != dvPropertyNull; cVar = _nextProperty) { \ 1968 _nextProperty = dvPropertyGetNextRelationshipProperty(cVar); 1969 #define dvEndSafeRelationshipProperty }} 1970 #define dvForeachRelationshipKey(pVar, cVar) \ 1971 for(cVar = dvRelationshipGetFirstKey(pVar); cVar != dvKeyNull; \ 1972 cVar = dvKeyGetNextRelationshipKey(cVar)) 1973 #define dvEndRelationshipKey 1974 #define dvSafeForeachRelationshipKey(pVar, cVar) { \ 1975 dvKey _nextKey; \ 1976 for(cVar = dvRelationshipGetFirstKey(pVar); cVar != dvKeyNull; cVar = _nextKey) { \ 1977 _nextKey = dvKeyGetNextRelationshipKey(cVar); 1978 #define dvEndSafeRelationshipKey }} 1979 #define dvRelationshipSetConstructorCallback(func) (dvRelationshipConstructorCallback = (func)) 1980 #define dvRelationshipGetConstructorCallback() (dvRelationshipConstructorCallback) 1981 #define dvFirstRelationship() (dvRootData.usedRelationship == 0? dvRelationshipNull : dvIndex2Relationship(0)) 1982 #define dvLastRelationship() (dvRootData.usedRelationship == 0? dvRelationshipNull : \ 1983 dvIndex2Relationship(dvRootData.usedRelationship - 1)) 1984 #define dvNextRelationship(Relationship) (dvRelationship2ValidIndex(Relationship) + 1 == dvRootData.usedRelationship? dvRelationshipNull : \ 1985 (Relationship) + 1) 1986 #define dvPrevRelationship(Relationship) (dvRelationship2ValidIndex(Relationship) == 0? dvRelationshipNull : (Relationship) - 1) 1987 #define dvForeachRelationship(var) \ 1988 for(var = dvIndex2Relationship(0); dvRelationship2Index(var) != dvRootData.usedRelationship; var++) 1989 #define dvEndRelationship 1990 #define dvRelationshipFreeAll() (dvSetUsedRelationship(0)) 1991 #define dvRelationshipAllocRaw() ( \ 1992 dvRootData.usedRelationship == dvRootData.allocatedRelationship && (dvRelationshipAllocMore(), true), \ 1993 dvTemp_.Relationship = dvIndex2Relationship(dvRootData.usedRelationship), \ 1994 dvSetUsedRelationship(dvUsedRelationship() + 1), \ 1995 dvTemp_.Relationship) 1996 #define dvRelationshipAlloc() ( \ 1997 dvRootData.usedRelationship == dvRootData.allocatedRelationship && (dvRelationshipAllocMore(), true), \ 1998 dvTemp_.Relationship = dvIndex2Relationship(dvRootData.usedRelationship), \ 1999 dvSetUsedRelationship(dvUsedRelationship() + 1), \ 2000 dvRelationshipSetType(dvTemp_.Relationship, 0), \ 2001 dvRelationshipSetParentLabelSym(dvTemp_.Relationship, utSymNull), \ 2002 dvRelationshipSetChildLabelSym(dvTemp_.Relationship, utSymNull), \ 2003 dvRelationshipSetMandatory(dvTemp_.Relationship, 0), \ 2004 dvRelationshipSetCascade(dvTemp_.Relationship, 0), \ 2005 dvRelationshipSetAccessChild(dvTemp_.Relationship, 0), \ 2006 dvRelationshipSetAccessParent(dvTemp_.Relationship, 0), \ 2007 dvRelationshipSetSharedParent(dvTemp_.Relationship, 0), \ 2008 dvRelationshipSetSparse(dvTemp_.Relationship, 0), \ 2009 dvRelationshipSetExpanded(dvTemp_.Relationship, 0), \ 2010 dvRelationshipSetSchema(dvTemp_.Relationship, dvSchemaNull), \ 2011 dvRelationshipSetNextSchemaRelationship(dvTemp_.Relationship, dvRelationshipNull), \ 2012 dvRelationshipSetParentClass(dvTemp_.Relationship, dvClassNull), \ 2013 dvRelationshipSetNextClassChildRelationship(dvTemp_.Relationship, dvRelationshipNull), \ 2014 dvRelationshipSetChildClass(dvTemp_.Relationship, dvClassNull), \ 2015 dvRelationshipSetNextClassParentRelationship(dvTemp_.Relationship, dvRelationshipNull), \ 2016 dvRelationshipSetFirstProperty(dvTemp_.Relationship, dvPropertyNull), \ 2017 dvRelationshipSetLastProperty(dvTemp_.Relationship, dvPropertyNull), \ 2018 dvRelationshipSetFirstKey(dvTemp_.Relationship, dvKeyNull), \ 2019 dvRelationshipSetLastKey(dvTemp_.Relationship, dvKeyNull), \ 2020 dvRelationshipSetParentSparsegroup(dvTemp_.Relationship, dvSparsegroupNull), \ 2021 dvRelationshipSetChildSparsegroup(dvTemp_.Relationship, dvSparsegroupNull), \ 2022 dvRelationshipConstructorCallback != NULL && (dvRelationshipConstructorCallback(dvTemp_.Relationship), true), \ 2023 dvTemp_.Relationship) 2024 2025 void dvRelationshipAllocMore(void); 2026 void dvRelationshipCopyProps(dvRelationship dvOldRelationship, dvRelationship dvNewRelationship); 2027 void dvRelationshipSetBitfield(dvRelationship _Relationship, uint32 bitfield); 2028 uint32 dvRelationshipGetBitfield(dvRelationship _Relationship); 2029 void dvRelationshipInsertProperty(dvRelationship Relationship, dvProperty _Property); 2030 void dvRelationshipRemoveProperty(dvRelationship Relationship, dvProperty _Property); 2031 void dvRelationshipInsertAfterProperty(dvRelationship Relationship, dvProperty prevProperty, dvProperty _Property); 2032 void dvRelationshipAppendProperty(dvRelationship Relationship, dvProperty _Property); 2033 void dvRelationshipInsertKey(dvRelationship Relationship, dvKey _Key); 2034 void dvRelationshipRemoveKey(dvRelationship Relationship, dvKey _Key); 2035 void dvRelationshipInsertAfterKey(dvRelationship Relationship, dvKey prevKey, dvKey _Key); 2036 void dvRelationshipAppendKey(dvRelationship Relationship, dvKey _Key); 2037 2038 /*---------------------------------------------------------------------------------------- 2039 Fields for class Key. 2040 ----------------------------------------------------------------------------------------*/ 2041 struct dvKeyFields { 2042 utSym *PropertySym; 2043 uint32 *LineNum; 2044 dvProperty *Property; 2045 dvKey *NextPropertyKey; 2046 dvRelationship *Relationship; 2047 dvKey *NextRelationshipKey; 2048 }; 2049 extern struct dvKeyFields dvKeys; 2050 2051 #define dvKeyGetPropertySym(_Key) (dvKeys.PropertySym[dvKey2ValidIndex(_Key)]) 2052 #define dvKeySetPropertySym(_Key, value) ((dvKeys.PropertySym)[dvKey2ValidIndex(_Key)] = (value)) 2053 #define dvKeyGetLineNum(_Key) (dvKeys.LineNum[dvKey2ValidIndex(_Key)]) 2054 #define dvKeySetLineNum(_Key, value) ((dvKeys.LineNum)[dvKey2ValidIndex(_Key)] = (value)) 2055 #define dvKeyGetProperty(_Key) (dvKeys.Property[dvKey2ValidIndex(_Key)]) 2056 #define dvKeySetProperty(_Key, value) ((dvKeys.Property)[dvKey2ValidIndex(_Key)] = (value)) 2057 #define dvKeyGetNextPropertyKey(_Key) (dvKeys.NextPropertyKey[dvKey2ValidIndex(_Key)]) 2058 #define dvKeySetNextPropertyKey(_Key, value) ((dvKeys.NextPropertyKey)[dvKey2ValidIndex(_Key)] = (value)) 2059 #define dvKeyGetRelationship(_Key) (dvKeys.Relationship[dvKey2ValidIndex(_Key)]) 2060 #define dvKeySetRelationship(_Key, value) ((dvKeys.Relationship)[dvKey2ValidIndex(_Key)] = (value)) 2061 #define dvKeyGetNextRelationshipKey(_Key) (dvKeys.NextRelationshipKey[dvKey2ValidIndex(_Key)]) 2062 #define dvKeySetNextRelationshipKey(_Key, value) ((dvKeys.NextRelationshipKey)[dvKey2ValidIndex(_Key)] = (value)) 2063 #define dvKeySetConstructorCallback(func) (dvKeyConstructorCallback = (func)) 2064 #define dvKeyGetConstructorCallback() (dvKeyConstructorCallback) 2065 #define dvKeySetDestructorCallback(func) (dvKeyDestructorCallback = (func)) 2066 #define dvKeyGetDestructorCallback() (dvKeyDestructorCallback) 2067 #define dvKeyNextFree(_Key) (((dvKey *)(void *)(dvKeys.Property))[dvKey2ValidIndex(_Key)]) 2068 #define dvKeySetNextFree(_Key, value) (((dvKey *)(void *)(dvKeys.Property)) \ 2069 [dvKey2ValidIndex(_Key)] = (value)) 2070 #define dvKeyAllocRaw() ( \ 2071 dvRootData.firstFreeKey != dvKeyNull? \ 2072 (dvTemp_.Key = dvRootData.firstFreeKey, \ 2073 dvSetFirstFreeKey(dvKeyNextFree(dvTemp_.Key)), true) \ 2074 : (dvRootData.usedKey == dvRootData.allocatedKey && (dvKeyAllocMore(), true), \ 2075 dvTemp_.Key = dvIndex2Key(dvRootData.usedKey), \ 2076 dvSetUsedKey(dvUsedKey() + 1)), \ 2077 dvTemp_.Key) 2078 #define dvKeyAlloc() ( \ 2079 dvRootData.firstFreeKey != dvKeyNull? \ 2080 (dvTemp_.Key = dvRootData.firstFreeKey, \ 2081 dvSetFirstFreeKey(dvKeyNextFree(dvTemp_.Key)), true) \ 2082 : (dvRootData.usedKey == dvRootData.allocatedKey && (dvKeyAllocMore(), true), \ 2083 dvTemp_.Key = dvIndex2Key(dvRootData.usedKey), \ 2084 dvSetUsedKey(dvUsedKey() + 1)), \ 2085 dvKeySetPropertySym(dvTemp_.Key, utSymNull), \ 2086 dvKeySetLineNum(dvTemp_.Key, 0), \ 2087 dvKeySetProperty(dvTemp_.Key, dvPropertyNull), \ 2088 dvKeySetNextPropertyKey(dvTemp_.Key, dvKeyNull), \ 2089 dvKeySetRelationship(dvTemp_.Key, dvRelationshipNull), \ 2090 dvKeySetNextRelationshipKey(dvTemp_.Key, dvKeyNull), \ 2091 dvKeyConstructorCallback != NULL && (dvKeyConstructorCallback(dvTemp_.Key), true), \ 2092 dvTemp_.Key) 2093 2094 #define dvKeyFree(Key) (dvKeySetNextFree(Key, dvRootData.firstFreeKey), \ 2095 dvSetFirstFreeKey(Key)) 2096 void dvKeyDestroy(dvKey Key); 2097 void dvKeyAllocMore(void); 2098 void dvKeyCopyProps(dvKey dvOldKey, dvKey dvNewKey); 2099 2100 /*---------------------------------------------------------------------------------------- 2101 Fields for class Union. 2102 ----------------------------------------------------------------------------------------*/ 2103 struct dvUnionFields { 2104 utSym *PropertySym; 2105 dvProperty *TypeProperty; 2106 uint32 *Line; 2107 uint16 *Number; 2108 uint32 *FieldNumber; 2109 uint16 *NumCases; 2110 dvClass *Class; 2111 dvUnion *NextClassUnion; 2112 dvProperty *FirstProperty; 2113 dvProperty *LastProperty; 2114 }; 2115 extern struct dvUnionFields dvUnions; 2116 2117 #define dvUnionGetPropertySym(_Union) (dvUnions.PropertySym[dvUnion2ValidIndex(_Union)]) 2118 #define dvUnionSetPropertySym(_Union, value) ((dvUnions.PropertySym)[dvUnion2ValidIndex(_Union)] = (value)) 2119 #define dvUnionGetTypeProperty(_Union) (dvUnions.TypeProperty[dvUnion2ValidIndex(_Union)]) 2120 #define dvUnionSetTypeProperty(_Union, value) ((dvUnions.TypeProperty)[dvUnion2ValidIndex(_Union)] = (value)) 2121 #define dvUnionGetLine(_Union) (dvUnions.Line[dvUnion2ValidIndex(_Union)]) 2122 #define dvUnionSetLine(_Union, value) ((dvUnions.Line)[dvUnion2ValidIndex(_Union)] = (value)) 2123 #define dvUnionGetNumber(_Union) (dvUnions.Number[dvUnion2ValidIndex(_Union)]) 2124 #define dvUnionSetNumber(_Union, value) ((dvUnions.Number)[dvUnion2ValidIndex(_Union)] = (value)) 2125 #define dvUnionGetFieldNumber(_Union) (dvUnions.FieldNumber[dvUnion2ValidIndex(_Union)]) 2126 #define dvUnionSetFieldNumber(_Union, value) ((dvUnions.FieldNumber)[dvUnion2ValidIndex(_Union)] = (value)) 2127 #define dvUnionGetNumCases(_Union) (dvUnions.NumCases[dvUnion2ValidIndex(_Union)]) 2128 #define dvUnionSetNumCases(_Union, value) ((dvUnions.NumCases)[dvUnion2ValidIndex(_Union)] = (value)) 2129 #define dvUnionGetClass(_Union) (dvUnions.Class[dvUnion2ValidIndex(_Union)]) 2130 #define dvUnionSetClass(_Union, value) ((dvUnions.Class)[dvUnion2ValidIndex(_Union)] = (value)) 2131 #define dvUnionGetNextClassUnion(_Union) (dvUnions.NextClassUnion[dvUnion2ValidIndex(_Union)]) 2132 #define dvUnionSetNextClassUnion(_Union, value) ((dvUnions.NextClassUnion)[dvUnion2ValidIndex(_Union)] = (value)) 2133 #define dvUnionGetFirstProperty(_Union) (dvUnions.FirstProperty[dvUnion2ValidIndex(_Union)]) 2134 #define dvUnionSetFirstProperty(_Union, value) ((dvUnions.FirstProperty)[dvUnion2ValidIndex(_Union)] = (value)) 2135 #define dvUnionGetLastProperty(_Union) (dvUnions.LastProperty[dvUnion2ValidIndex(_Union)]) 2136 #define dvUnionSetLastProperty(_Union, value) ((dvUnions.LastProperty)[dvUnion2ValidIndex(_Union)] = (value)) 2137 #define dvForeachUnionProperty(pVar, cVar) \ 2138 for(cVar = dvUnionGetFirstProperty(pVar); cVar != dvPropertyNull; \ 2139 cVar = dvPropertyGetNextUnionProperty(cVar)) 2140 #define dvEndUnionProperty 2141 #define dvSafeForeachUnionProperty(pVar, cVar) { \ 2142 dvProperty _nextProperty; \ 2143 for(cVar = dvUnionGetFirstProperty(pVar); cVar != dvPropertyNull; cVar = _nextProperty) { \ 2144 _nextProperty = dvPropertyGetNextUnionProperty(cVar); 2145 #define dvEndSafeUnionProperty }} 2146 #define dvUnionSetConstructorCallback(func) (dvUnionConstructorCallback = (func)) 2147 #define dvUnionGetConstructorCallback() (dvUnionConstructorCallback) 2148 #define dvUnionSetDestructorCallback(func) (dvUnionDestructorCallback = (func)) 2149 #define dvUnionGetDestructorCallback() (dvUnionDestructorCallback) 2150 #define dvUnionNextFree(_Union) (((dvUnion *)(void *)(dvUnions.TypeProperty))[dvUnion2ValidIndex(_Union)]) 2151 #define dvUnionSetNextFree(_Union, value) (((dvUnion *)(void *)(dvUnions.TypeProperty)) \ 2152 [dvUnion2ValidIndex(_Union)] = (value)) 2153 #define dvUnionAllocRaw() ( \ 2154 dvRootData.firstFreeUnion != dvUnionNull? \ 2155 (dvTemp_.Union = dvRootData.firstFreeUnion, \ 2156 dvSetFirstFreeUnion(dvUnionNextFree(dvTemp_.Union)), true) \ 2157 : (dvRootData.usedUnion == dvRootData.allocatedUnion && (dvUnionAllocMore(), true), \ 2158 dvTemp_.Union = dvIndex2Union(dvRootData.usedUnion), \ 2159 dvSetUsedUnion(dvUsedUnion() + 1)), \ 2160 dvTemp_.Union) 2161 #define dvUnionAlloc() ( \ 2162 dvRootData.firstFreeUnion != dvUnionNull? \ 2163 (dvTemp_.Union = dvRootData.firstFreeUnion, \ 2164 dvSetFirstFreeUnion(dvUnionNextFree(dvTemp_.Union)), true) \ 2165 : (dvRootData.usedUnion == dvRootData.allocatedUnion && (dvUnionAllocMore(), true), \ 2166 dvTemp_.Union = dvIndex2Union(dvRootData.usedUnion), \ 2167 dvSetUsedUnion(dvUsedUnion() + 1)), \ 2168 dvUnionSetPropertySym(dvTemp_.Union, utSymNull), \ 2169 dvUnionSetTypeProperty(dvTemp_.Union, dvPropertyNull), \ 2170 dvUnionSetLine(dvTemp_.Union, 0), \ 2171 dvUnionSetNumber(dvTemp_.Union, 0), \ 2172 dvUnionSetFieldNumber(dvTemp_.Union, 0), \ 2173 dvUnionSetNumCases(dvTemp_.Union, 0), \ 2174 dvUnionSetClass(dvTemp_.Union, dvClassNull), \ 2175 dvUnionSetNextClassUnion(dvTemp_.Union, dvUnionNull), \ 2176 dvUnionSetFirstProperty(dvTemp_.Union, dvPropertyNull), \ 2177 dvUnionSetLastProperty(dvTemp_.Union, dvPropertyNull), \ 2178 dvUnionConstructorCallback != NULL && (dvUnionConstructorCallback(dvTemp_.Union), true), \ 2179 dvTemp_.Union) 2180 2181 #define dvUnionFree(Union) (dvUnionSetNextFree(Union, dvRootData.firstFreeUnion), \ 2182 dvSetFirstFreeUnion(Union)) 2183 void dvUnionDestroy(dvUnion Union); 2184 void dvUnionAllocMore(void); 2185 void dvUnionCopyProps(dvUnion dvOldUnion, dvUnion dvNewUnion); 2186 void dvUnionInsertProperty(dvUnion Union, dvProperty _Property); 2187 void dvUnionRemoveProperty(dvUnion Union, dvProperty _Property); 2188 void dvUnionInsertAfterProperty(dvUnion Union, dvProperty prevProperty, dvProperty _Property); 2189 void dvUnionAppendProperty(dvUnion Union, dvProperty _Property); 2190 2191 /*---------------------------------------------------------------------------------------- 2192 Fields for class Case. 2193 ----------------------------------------------------------------------------------------*/ 2194 struct dvCaseFields { 2195 utSym *EntrySym; 2196 dvEntry *Entry; 2197 dvCase *NextEntryCase; 2198 dvProperty *Property; 2199 dvCase *NextPropertyCase; 2200 }; 2201 extern struct dvCaseFields dvCases; 2202 2203 #define dvCaseGetEntrySym(_Case) (dvCases.EntrySym[dvCase2ValidIndex(_Case)]) 2204 #define dvCaseSetEntrySym(_Case, value) ((dvCases.EntrySym)[dvCase2ValidIndex(_Case)] = (value)) 2205 #define dvCaseGetEntry(_Case) (dvCases.Entry[dvCase2ValidIndex(_Case)]) 2206 #define dvCaseSetEntry(_Case, value) ((dvCases.Entry)[dvCase2ValidIndex(_Case)] = (value)) 2207 #define dvCaseGetNextEntryCase(_Case) (dvCases.NextEntryCase[dvCase2ValidIndex(_Case)]) 2208 #define dvCaseSetNextEntryCase(_Case, value) ((dvCases.NextEntryCase)[dvCase2ValidIndex(_Case)] = (value)) 2209 #define dvCaseGetProperty(_Case) (dvCases.Property[dvCase2ValidIndex(_Case)]) 2210 #define dvCaseSetProperty(_Case, value) ((dvCases.Property)[dvCase2ValidIndex(_Case)] = (value)) 2211 #define dvCaseGetNextPropertyCase(_Case) (dvCases.NextPropertyCase[dvCase2ValidIndex(_Case)]) 2212 #define dvCaseSetNextPropertyCase(_Case, value) ((dvCases.NextPropertyCase)[dvCase2ValidIndex(_Case)] = (value)) 2213 #define dvCaseSetConstructorCallback(func) (dvCaseConstructorCallback = (func)) 2214 #define dvCaseGetConstructorCallback() (dvCaseConstructorCallback) 2215 #define dvCaseSetDestructorCallback(func) (dvCaseDestructorCallback = (func)) 2216 #define dvCaseGetDestructorCallback() (dvCaseDestructorCallback) 2217 #define dvCaseNextFree(_Case) (((dvCase *)(void *)(dvCases.Entry))[dvCase2ValidIndex(_Case)]) 2218 #define dvCaseSetNextFree(_Case, value) (((dvCase *)(void *)(dvCases.Entry)) \ 2219 [dvCase2ValidIndex(_Case)] = (value)) 2220 #define dvCaseAllocRaw() ( \ 2221 dvRootData.firstFreeCase != dvCaseNull? \ 2222 (dvTemp_.Case = dvRootData.firstFreeCase, \ 2223 dvSetFirstFreeCase(dvCaseNextFree(dvTemp_.Case)), true) \ 2224 : (dvRootData.usedCase == dvRootData.allocatedCase && (dvCaseAllocMore(), true), \ 2225 dvTemp_.Case = dvIndex2Case(dvRootData.usedCase), \ 2226 dvSetUsedCase(dvUsedCase() + 1)), \ 2227 dvTemp_.Case) 2228 #define dvCaseAlloc() ( \ 2229 dvRootData.firstFreeCase != dvCaseNull? \ 2230 (dvTemp_.Case = dvRootData.firstFreeCase, \ 2231 dvSetFirstFreeCase(dvCaseNextFree(dvTemp_.Case)), true) \ 2232 : (dvRootData.usedCase == dvRootData.allocatedCase && (dvCaseAllocMore(), true), \ 2233 dvTemp_.Case = dvIndex2Case(dvRootData.usedCase), \ 2234 dvSetUsedCase(dvUsedCase() + 1)), \ 2235 dvCaseSetEntrySym(dvTemp_.Case, utSymNull), \ 2236 dvCaseSetEntry(dvTemp_.Case, dvEntryNull), \ 2237 dvCaseSetNextEntryCase(dvTemp_.Case, dvCaseNull), \ 2238 dvCaseSetProperty(dvTemp_.Case, dvPropertyNull), \ 2239 dvCaseSetNextPropertyCase(dvTemp_.Case, dvCaseNull), \ 2240 dvCaseConstructorCallback != NULL && (dvCaseConstructorCallback(dvTemp_.Case), true), \ 2241 dvTemp_.Case) 2242 2243 #define dvCaseFree(Case) (dvCaseSetNextFree(Case, dvRootData.firstFreeCase), \ 2244 dvSetFirstFreeCase(Case)) 2245 void dvCaseDestroy(dvCase Case); 2246 void dvCaseAllocMore(void); 2247 void dvCaseCopyProps(dvCase dvOldCase, dvCase dvNewCase); 2248 2249 /*---------------------------------------------------------------------------------------- 2250 Temp Union structure - Macro temp variables, use only one 2251 ----------------------------------------------------------------------------------------*/ 2252 union dvTempType_ { 2253 dvRoot Root; 2254 dvModpath Modpath; 2255 dvModule Module; 2256 dvLink Link; 2257 dvSchema Schema; 2258 dvEnum Enum; 2259 dvEntry Entry; 2260 dvTypedef Typedef; 2261 dvClass Class; 2262 dvProperty Property; 2263 dvSparsegroup Sparsegroup; 2264 dvRelationship Relationship; 2265 dvKey Key; 2266 dvUnion Union; 2267 dvCase Case; 2268 }; 2269 2270 extern union dvTempType_ dvTemp_; 2271 2272 /*---------------------------------------------------------------------------------------- 2273 Constructor/Destructor hooks. 2274 ----------------------------------------------------------------------------------------*/ 2275 extern void(*dvRootConstructorCallback)(dvRoot); 2276 extern void(*dvModpathConstructorCallback)(dvModpath); 2277 extern void(*dvModuleConstructorCallback)(dvModule); 2278 extern void(*dvLinkConstructorCallback)(dvLink); 2279 extern void(*dvSchemaConstructorCallback)(dvSchema); 2280 extern void(*dvEnumConstructorCallback)(dvEnum); 2281 extern void(*dvEntryConstructorCallback)(dvEntry); 2282 extern void(*dvTypedefConstructorCallback)(dvTypedef); 2283 extern void(*dvClassConstructorCallback)(dvClass); 2284 extern void(*dvPropertyConstructorCallback)(dvProperty); 2285 extern void(*dvSparsegroupConstructorCallback)(dvSparsegroup); 2286 extern void(*dvSparsegroupDestructorCallback)(dvSparsegroup); 2287 extern void(*dvRelationshipConstructorCallback)(dvRelationship); 2288 extern void(*dvKeyConstructorCallback)(dvKey); 2289 extern void(*dvKeyDestructorCallback)(dvKey); 2290 extern void(*dvUnionConstructorCallback)(dvUnion); 2291 extern void(*dvUnionDestructorCallback)(dvUnion); 2292 extern void(*dvCaseConstructorCallback)(dvCase); 2293 extern void(*dvCaseDestructorCallback)(dvCase); 2294 2295 /*---------------------------------------------------------------------------------------- 2296 Root structure 2297 ----------------------------------------------------------------------------------------*/ 2298 struct dvRootType_ { 2299 uint32 hash; /* This depends only on the structure of the database */ 2300 uint32 usedRoot, allocatedRoot; 2301 uint32 usedRootModpathTable, allocatedRootModpathTable, freeRootModpathTable; 2302 uint32 usedRootModuleTable, allocatedRootModuleTable, freeRootModuleTable; 2303 uint32 usedModpath, allocatedModpath; 2304 uint32 usedModule, allocatedModule; 2305 uint32 usedModuleClassTable, allocatedModuleClassTable, freeModuleClassTable; 2306 uint32 usedModuleEnumTable, allocatedModuleEnumTable, freeModuleEnumTable; 2307 uint32 usedModuleTypedefTable, allocatedModuleTypedefTable, freeModuleTypedefTable; 2308 uint32 usedModuleSchemaTable, allocatedModuleSchemaTable, freeModuleSchemaTable; 2309 uint32 usedLink, allocatedLink; 2310 uint32 usedSchema, allocatedSchema; 2311 uint32 usedEnum, allocatedEnum; 2312 uint32 usedEnumEntryTable, allocatedEnumEntryTable, freeEnumEntryTable; 2313 uint32 usedEntry, allocatedEntry; 2314 uint32 usedTypedef, allocatedTypedef; 2315 uint32 usedTypedefInitializer, allocatedTypedefInitializer, freeTypedefInitializer; 2316 uint32 usedClass, allocatedClass; 2317 uint32 usedClassPropertyTable, allocatedClassPropertyTable, freeClassPropertyTable; 2318 uint32 usedClassSparsegroupTable, allocatedClassSparsegroupTable, freeClassSparsegroupTable; 2319 uint32 usedProperty, allocatedProperty; 2320 uint32 usedPropertyInitializer, allocatedPropertyInitializer, freePropertyInitializer; 2321 uint32 usedPropertyIndex, allocatedPropertyIndex, freePropertyIndex; 2322 dvSparsegroup firstFreeSparsegroup; 2323 uint32 usedSparsegroup, allocatedSparsegroup; 2324 uint32 usedRelationship, allocatedRelationship; 2325 dvKey firstFreeKey; 2326 uint32 usedKey, allocatedKey; 2327 dvUnion firstFreeUnion; 2328 uint32 usedUnion, allocatedUnion; 2329 dvCase firstFreeCase; 2330 uint32 usedCase, allocatedCase; 2331 }; 2332 extern struct dvRootType_ dvRootData; 2333 2334 #define dvHash() (dvRootData.hash) 2335 #define dvUsedRoot() dvRootData.usedRoot 2336 #define dvAllocatedRoot() dvRootData.allocatedRoot 2337 #define dvSetUsedRoot(value) (dvRootData.usedRoot = (value)) 2338 #define dvSetAllocatedRoot(value) (dvRootData.allocatedRoot = (value)) 2339 #define dvUsedRootModpathTable() dvRootData.usedRootModpathTable 2340 #define dvAllocatedRootModpathTable() dvRootData.allocatedRootModpathTable 2341 #define dvFreeRootModpathTable() dvRootData.freeRootModpathTable 2342 #define dvSetUsedRootModpathTable(value) (dvRootData.usedRootModpathTable = (value)) 2343 #define dvSetAllocatedRootModpathTable(value) (dvRootData.allocatedRootModpathTable = (value)) 2344 #define dvSetFreeRootModpathTable(value) (dvRootData.freeRootModpathTable = (value)) 2345 #define dvUsedRootModuleTable() dvRootData.usedRootModuleTable 2346 #define dvAllocatedRootModuleTable() dvRootData.allocatedRootModuleTable 2347 #define dvFreeRootModuleTable() dvRootData.freeRootModuleTable 2348 #define dvSetUsedRootModuleTable(value) (dvRootData.usedRootModuleTable = (value)) 2349 #define dvSetAllocatedRootModuleTable(value) (dvRootData.allocatedRootModuleTable = (value)) 2350 #define dvSetFreeRootModuleTable(value) (dvRootData.freeRootModuleTable = (value)) 2351 #define dvUsedModpath() dvRootData.usedModpath 2352 #define dvAllocatedModpath() dvRootData.allocatedModpath 2353 #define dvSetUsedModpath(value) (dvRootData.usedModpath = (value)) 2354 #define dvSetAllocatedModpath(value) (dvRootData.allocatedModpath = (value)) 2355 #define dvUsedModule() dvRootData.usedModule 2356 #define dvAllocatedModule() dvRootData.allocatedModule 2357 #define dvSetUsedModule(value) (dvRootData.usedModule = (value)) 2358 #define dvSetAllocatedModule(value) (dvRootData.allocatedModule = (value)) 2359 #define dvUsedModuleClassTable() dvRootData.usedModuleClassTable 2360 #define dvAllocatedModuleClassTable() dvRootData.allocatedModuleClassTable 2361 #define dvFreeModuleClassTable() dvRootData.freeModuleClassTable 2362 #define dvSetUsedModuleClassTable(value) (dvRootData.usedModuleClassTable = (value)) 2363 #define dvSetAllocatedModuleClassTable(value) (dvRootData.allocatedModuleClassTable = (value)) 2364 #define dvSetFreeModuleClassTable(value) (dvRootData.freeModuleClassTable = (value)) 2365 #define dvUsedModuleEnumTable() dvRootData.usedModuleEnumTable 2366 #define dvAllocatedModuleEnumTable() dvRootData.allocatedModuleEnumTable 2367 #define dvFreeModuleEnumTable() dvRootData.freeModuleEnumTable 2368 #define dvSetUsedModuleEnumTable(value) (dvRootData.usedModuleEnumTable = (value)) 2369 #define dvSetAllocatedModuleEnumTable(value) (dvRootData.allocatedModuleEnumTable = (value)) 2370 #define dvSetFreeModuleEnumTable(value) (dvRootData.freeModuleEnumTable = (value)) 2371 #define dvUsedModuleTypedefTable() dvRootData.usedModuleTypedefTable 2372 #define dvAllocatedModuleTypedefTable() dvRootData.allocatedModuleTypedefTable 2373 #define dvFreeModuleTypedefTable() dvRootData.freeModuleTypedefTable 2374 #define dvSetUsedModuleTypedefTable(value) (dvRootData.usedModuleTypedefTable = (value)) 2375 #define dvSetAllocatedModuleTypedefTable(value) (dvRootData.allocatedModuleTypedefTable = (value)) 2376 #define dvSetFreeModuleTypedefTable(value) (dvRootData.freeModuleTypedefTable = (value)) 2377 #define dvUsedModuleSchemaTable() dvRootData.usedModuleSchemaTable 2378 #define dvAllocatedModuleSchemaTable() dvRootData.allocatedModuleSchemaTable 2379 #define dvFreeModuleSchemaTable() dvRootData.freeModuleSchemaTable 2380 #define dvSetUsedModuleSchemaTable(value) (dvRootData.usedModuleSchemaTable = (value)) 2381 #define dvSetAllocatedModuleSchemaTable(value) (dvRootData.allocatedModuleSchemaTable = (value)) 2382 #define dvSetFreeModuleSchemaTable(value) (dvRootData.freeModuleSchemaTable = (value)) 2383 #define dvUsedLink() dvRootData.usedLink 2384 #define dvAllocatedLink() dvRootData.allocatedLink 2385 #define dvSetUsedLink(value) (dvRootData.usedLink = (value)) 2386 #define dvSetAllocatedLink(value) (dvRootData.allocatedLink = (value)) 2387 #define dvUsedSchema() dvRootData.usedSchema 2388 #define dvAllocatedSchema() dvRootData.allocatedSchema 2389 #define dvSetUsedSchema(value) (dvRootData.usedSchema = (value)) 2390 #define dvSetAllocatedSchema(value) (dvRootData.allocatedSchema = (value)) 2391 #define dvUsedEnum() dvRootData.usedEnum 2392 #define dvAllocatedEnum() dvRootData.allocatedEnum 2393 #define dvSetUsedEnum(value) (dvRootData.usedEnum = (value)) 2394 #define dvSetAllocatedEnum(value) (dvRootData.allocatedEnum = (value)) 2395 #define dvUsedEnumEntryTable() dvRootData.usedEnumEntryTable 2396 #define dvAllocatedEnumEntryTable() dvRootData.allocatedEnumEntryTable 2397 #define dvFreeEnumEntryTable() dvRootData.freeEnumEntryTable 2398 #define dvSetUsedEnumEntryTable(value) (dvRootData.usedEnumEntryTable = (value)) 2399 #define dvSetAllocatedEnumEntryTable(value) (dvRootData.allocatedEnumEntryTable = (value)) 2400 #define dvSetFreeEnumEntryTable(value) (dvRootData.freeEnumEntryTable = (value)) 2401 #define dvUsedEntry() dvRootData.usedEntry 2402 #define dvAllocatedEntry() dvRootData.allocatedEntry 2403 #define dvSetUsedEntry(value) (dvRootData.usedEntry = (value)) 2404 #define dvSetAllocatedEntry(value) (dvRootData.allocatedEntry = (value)) 2405 #define dvUsedTypedef() dvRootData.usedTypedef 2406 #define dvAllocatedTypedef() dvRootData.allocatedTypedef 2407 #define dvSetUsedTypedef(value) (dvRootData.usedTypedef = (value)) 2408 #define dvSetAllocatedTypedef(value) (dvRootData.allocatedTypedef = (value)) 2409 #define dvUsedTypedefInitializer() dvRootData.usedTypedefInitializer 2410 #define dvAllocatedTypedefInitializer() dvRootData.allocatedTypedefInitializer 2411 #define dvFreeTypedefInitializer() dvRootData.freeTypedefInitializer 2412 #define dvSetUsedTypedefInitializer(value) (dvRootData.usedTypedefInitializer = (value)) 2413 #define dvSetAllocatedTypedefInitializer(value) (dvRootData.allocatedTypedefInitializer = (value)) 2414 #define dvSetFreeTypedefInitializer(value) (dvRootData.freeTypedefInitializer = (value)) 2415 #define dvUsedClass() dvRootData.usedClass 2416 #define dvAllocatedClass() dvRootData.allocatedClass 2417 #define dvSetUsedClass(value) (dvRootData.usedClass = (value)) 2418 #define dvSetAllocatedClass(value) (dvRootData.allocatedClass = (value)) 2419 #define dvUsedClassPropertyTable() dvRootData.usedClassPropertyTable 2420 #define dvAllocatedClassPropertyTable() dvRootData.allocatedClassPropertyTable 2421 #define dvFreeClassPropertyTable() dvRootData.freeClassPropertyTable 2422 #define dvSetUsedClassPropertyTable(value) (dvRootData.usedClassPropertyTable = (value)) 2423 #define dvSetAllocatedClassPropertyTable(value) (dvRootData.allocatedClassPropertyTable = (value)) 2424 #define dvSetFreeClassPropertyTable(value) (dvRootData.freeClassPropertyTable = (value)) 2425 #define dvUsedClassSparsegroupTable() dvRootData.usedClassSparsegroupTable 2426 #define dvAllocatedClassSparsegroupTable() dvRootData.allocatedClassSparsegroupTable 2427 #define dvFreeClassSparsegroupTable() dvRootData.freeClassSparsegroupTable 2428 #define dvSetUsedClassSparsegroupTable(value) (dvRootData.usedClassSparsegroupTable = (value)) 2429 #define dvSetAllocatedClassSparsegroupTable(value) (dvRootData.allocatedClassSparsegroupTable = (value)) 2430 #define dvSetFreeClassSparsegroupTable(value) (dvRootData.freeClassSparsegroupTable = (value)) 2431 #define dvUsedProperty() dvRootData.usedProperty 2432 #define dvAllocatedProperty() dvRootData.allocatedProperty 2433 #define dvSetUsedProperty(value) (dvRootData.usedProperty = (value)) 2434 #define dvSetAllocatedProperty(value) (dvRootData.allocatedProperty = (value)) 2435 #define dvUsedPropertyInitializer() dvRootData.usedPropertyInitializer 2436 #define dvAllocatedPropertyInitializer() dvRootData.allocatedPropertyInitializer 2437 #define dvFreePropertyInitializer() dvRootData.freePropertyInitializer 2438 #define dvSetUsedPropertyInitializer(value) (dvRootData.usedPropertyInitializer = (value)) 2439 #define dvSetAllocatedPropertyInitializer(value) (dvRootData.allocatedPropertyInitializer = (value)) 2440 #define dvSetFreePropertyInitializer(value) (dvRootData.freePropertyInitializer = (value)) 2441 #define dvUsedPropertyIndex() dvRootData.usedPropertyIndex 2442 #define dvAllocatedPropertyIndex() dvRootData.allocatedPropertyIndex 2443 #define dvFreePropertyIndex() dvRootData.freePropertyIndex 2444 #define dvSetUsedPropertyIndex(value) (dvRootData.usedPropertyIndex = (value)) 2445 #define dvSetAllocatedPropertyIndex(value) (dvRootData.allocatedPropertyIndex = (value)) 2446 #define dvSetFreePropertyIndex(value) (dvRootData.freePropertyIndex = (value)) 2447 #define dvFirstFreeSparsegroup() dvRootData.firstFreeSparsegroup 2448 #define dvSetFirstFreeSparsegroup(value) (dvRootData.firstFreeSparsegroup = (value)) 2449 #define dvUsedSparsegroup() dvRootData.usedSparsegroup 2450 #define dvAllocatedSparsegroup() dvRootData.allocatedSparsegroup 2451 #define dvSetUsedSparsegroup(value) (dvRootData.usedSparsegroup = (value)) 2452 #define dvSetAllocatedSparsegroup(value) (dvRootData.allocatedSparsegroup = (value)) 2453 #define dvUsedRelationship() dvRootData.usedRelationship 2454 #define dvAllocatedRelationship() dvRootData.allocatedRelationship 2455 #define dvSetUsedRelationship(value) (dvRootData.usedRelationship = (value)) 2456 #define dvSetAllocatedRelationship(value) (dvRootData.allocatedRelationship = (value)) 2457 #define dvFirstFreeKey() dvRootData.firstFreeKey 2458 #define dvSetFirstFreeKey(value) (dvRootData.firstFreeKey = (value)) 2459 #define dvUsedKey() dvRootData.usedKey 2460 #define dvAllocatedKey() dvRootData.allocatedKey 2461 #define dvSetUsedKey(value) (dvRootData.usedKey = (value)) 2462 #define dvSetAllocatedKey(value) (dvRootData.allocatedKey = (value)) 2463 #define dvFirstFreeUnion() dvRootData.firstFreeUnion 2464 #define dvSetFirstFreeUnion(value) (dvRootData.firstFreeUnion = (value)) 2465 #define dvUsedUnion() dvRootData.usedUnion 2466 #define dvAllocatedUnion() dvRootData.allocatedUnion 2467 #define dvSetUsedUnion(value) (dvRootData.usedUnion = (value)) 2468 #define dvSetAllocatedUnion(value) (dvRootData.allocatedUnion = (value)) 2469 #define dvFirstFreeCase() dvRootData.firstFreeCase 2470 #define dvSetFirstFreeCase(value) (dvRootData.firstFreeCase = (value)) 2471 #define dvUsedCase() dvRootData.usedCase 2472 #define dvAllocatedCase() dvRootData.allocatedCase 2473 #define dvSetUsedCase(value) (dvRootData.usedCase = (value)) 2474 #define dvSetAllocatedCase(value) (dvRootData.allocatedCase = (value)) 2475 2476 extern uint8 dvModuleID; 2477 void dvDatabaseStart(void); 2478 void dvDatabaseStop(void); 2479 #if defined __cplusplus 2480 } 2481 #endif 2482 2483 #endif 2484