1 /*----------------------------------------------------------------------------------------
2 Database dv
3 ----------------------------------------------------------------------------------------*/
4
5 #include "dvdatabase.h"
6
7 union dvTempType_ dvTemp_;
8 struct dvRootType_ dvRootData;
9 uint8 dvModuleID;
10 struct dvRootFields dvRoots;
11 struct dvModpathFields dvModpaths;
12 struct dvModuleFields dvModules;
13 struct dvLinkFields dvLinks;
14 struct dvSchemaFields dvSchemas;
15 struct dvEnumFields dvEnums;
16 struct dvEntryFields dvEntrys;
17 struct dvTypedefFields dvTypedefs;
18 struct dvClassFields dvClasss;
19 struct dvPropertyFields dvPropertys;
20 struct dvSparsegroupFields dvSparsegroups;
21 struct dvRelationshipFields dvRelationships;
22 struct dvKeyFields dvKeys;
23 struct dvUnionFields dvUnions;
24 struct dvCaseFields dvCases;
25
26 /*----------------------------------------------------------------------------------------
27 Constructor/Destructor hooks.
28 ----------------------------------------------------------------------------------------*/
29 void(*dvRootConstructorCallback)(dvRoot);
30 void(*dvModpathConstructorCallback)(dvModpath);
31 void(*dvModuleConstructorCallback)(dvModule);
32 void(*dvLinkConstructorCallback)(dvLink);
33 void(*dvSchemaConstructorCallback)(dvSchema);
34 void(*dvEnumConstructorCallback)(dvEnum);
35 void(*dvEntryConstructorCallback)(dvEntry);
36 void(*dvTypedefConstructorCallback)(dvTypedef);
37 void(*dvClassConstructorCallback)(dvClass);
38 void(*dvPropertyConstructorCallback)(dvProperty);
39 void(*dvSparsegroupConstructorCallback)(dvSparsegroup);
40 void(*dvSparsegroupDestructorCallback)(dvSparsegroup);
41 void(*dvRelationshipConstructorCallback)(dvRelationship);
42 void(*dvKeyConstructorCallback)(dvKey);
43 void(*dvKeyDestructorCallback)(dvKey);
44 void(*dvUnionConstructorCallback)(dvUnion);
45 void(*dvUnionDestructorCallback)(dvUnion);
46 void(*dvCaseConstructorCallback)(dvCase);
47 void(*dvCaseDestructorCallback)(dvCase);
48
49 /*----------------------------------------------------------------------------------------
50 Default constructor wrapper for the database manager.
51 ----------------------------------------------------------------------------------------*/
allocRoot(void)52 static uint64 allocRoot(void)
53 {
54 dvRoot Root = dvRootAlloc();
55
56 return dvRoot2Index(Root);
57 }
58
59 /*----------------------------------------------------------------------------------------
60 Allocate the field arrays of Root.
61 ----------------------------------------------------------------------------------------*/
allocRoots(void)62 static void allocRoots(void)
63 {
64 dvSetAllocatedRoot(2);
65 dvSetUsedRoot(0);
66 dvRoots.FirstModpath = utNewA(dvModpath, (dvAllocatedRoot()));
67 dvRoots.LastModpath = utNewA(dvModpath, (dvAllocatedRoot()));
68 dvRoots.ModpathTableIndex = utNewA(uint32, (dvAllocatedRoot()));
69 dvRoots.NumModpathTable = utNewA(uint32, (dvAllocatedRoot()));
70 dvSetUsedRootModpathTable(0);
71 dvSetAllocatedRootModpathTable(2);
72 dvSetFreeRootModpathTable(0);
73 dvRoots.ModpathTable = utNewA(dvModpath, dvAllocatedRootModpathTable());
74 dvRoots.NumModpath = utNewA(uint32, (dvAllocatedRoot()));
75 dvRoots.FirstModule = utNewA(dvModule, (dvAllocatedRoot()));
76 dvRoots.LastModule = utNewA(dvModule, (dvAllocatedRoot()));
77 dvRoots.ModuleTableIndex = utNewA(uint32, (dvAllocatedRoot()));
78 dvRoots.NumModuleTable = utNewA(uint32, (dvAllocatedRoot()));
79 dvSetUsedRootModuleTable(0);
80 dvSetAllocatedRootModuleTable(2);
81 dvSetFreeRootModuleTable(0);
82 dvRoots.ModuleTable = utNewA(dvModule, dvAllocatedRootModuleTable());
83 dvRoots.NumModule = utNewA(uint32, (dvAllocatedRoot()));
84 }
85
86 /*----------------------------------------------------------------------------------------
87 Realloc the arrays of properties for class Root.
88 ----------------------------------------------------------------------------------------*/
reallocRoots(uint32 newSize)89 static void reallocRoots(
90 uint32 newSize)
91 {
92 utResizeArray(dvRoots.FirstModpath, (newSize));
93 utResizeArray(dvRoots.LastModpath, (newSize));
94 utResizeArray(dvRoots.ModpathTableIndex, (newSize));
95 utResizeArray(dvRoots.NumModpathTable, (newSize));
96 utResizeArray(dvRoots.NumModpath, (newSize));
97 utResizeArray(dvRoots.FirstModule, (newSize));
98 utResizeArray(dvRoots.LastModule, (newSize));
99 utResizeArray(dvRoots.ModuleTableIndex, (newSize));
100 utResizeArray(dvRoots.NumModuleTable, (newSize));
101 utResizeArray(dvRoots.NumModule, (newSize));
102 dvSetAllocatedRoot(newSize);
103 }
104
105 /*----------------------------------------------------------------------------------------
106 Allocate more Roots.
107 ----------------------------------------------------------------------------------------*/
dvRootAllocMore(void)108 void dvRootAllocMore(void)
109 {
110 reallocRoots((uint32)(dvAllocatedRoot() + (dvAllocatedRoot() >> 1)));
111 }
112
113 /*----------------------------------------------------------------------------------------
114 Compact the Root.ModpathTable heap to free memory.
115 ----------------------------------------------------------------------------------------*/
dvCompactRootModpathTables(void)116 void dvCompactRootModpathTables(void)
117 {
118 uint32 elementSize = sizeof(dvModpath);
119 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
120 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
121 dvModpath *toPtr = dvRoots.ModpathTable;
122 dvModpath *fromPtr = toPtr;
123 dvRoot Root;
124 uint32 size;
125
126 while(fromPtr < dvRoots.ModpathTable + dvUsedRootModpathTable()) {
127 Root = *(dvRoot *)(void *)fromPtr;
128 if(Root != dvRootNull) {
129 /* Need to move it to toPtr */
130 size = utMax(dvRootGetNumModpathTable(Root) + usedHeaderSize, freeHeaderSize);
131 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
132 dvRootSetModpathTableIndex(Root, toPtr - dvRoots.ModpathTable + usedHeaderSize);
133 toPtr += size;
134 } else {
135 /* Just skip it */
136 size = *(uint32 *)(void *)(((dvRoot *)(void *)fromPtr) + 1);
137 }
138 fromPtr += size;
139 }
140 dvSetUsedRootModpathTable(toPtr - dvRoots.ModpathTable);
141 dvSetFreeRootModpathTable(0);
142 }
143
144 /*----------------------------------------------------------------------------------------
145 Allocate more memory for the Root.ModpathTable heap.
146 ----------------------------------------------------------------------------------------*/
allocMoreRootModpathTables(uint32 spaceNeeded)147 static void allocMoreRootModpathTables(
148 uint32 spaceNeeded)
149 {
150 uint32 freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();
151
152 if((dvFreeRootModpathTable() << 2) > dvUsedRootModpathTable()) {
153 dvCompactRootModpathTables();
154 freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();
155 }
156 if(freeSpace < spaceNeeded) {
157 dvSetAllocatedRootModpathTable(dvAllocatedRootModpathTable() + spaceNeeded - freeSpace +
158 (dvAllocatedRootModpathTable() >> 1));
159 utResizeArray(dvRoots.ModpathTable, dvAllocatedRootModpathTable());
160 }
161 }
162
163 /*----------------------------------------------------------------------------------------
164 Allocate memory for a new Root.ModpathTable array.
165 ----------------------------------------------------------------------------------------*/
dvRootAllocModpathTables(dvRoot Root,uint32 numModpathTables)166 void dvRootAllocModpathTables(
167 dvRoot Root,
168 uint32 numModpathTables)
169 {
170 uint32 freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();
171 uint32 elementSize = sizeof(dvModpath);
172 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
173 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
174 uint32 spaceNeeded = utMax(numModpathTables + usedHeaderSize, freeHeaderSize);
175
176 #if defined(DD_DEBUG)
177 utAssert(dvRootGetNumModpathTable(Root) == 0);
178 #endif
179 if(numModpathTables == 0) {
180 return;
181 }
182 if(freeSpace < spaceNeeded) {
183 allocMoreRootModpathTables(spaceNeeded);
184 }
185 dvRootSetModpathTableIndex(Root, dvUsedRootModpathTable() + usedHeaderSize);
186 dvRootSetNumModpathTable(Root, numModpathTables);
187 *(dvRoot *)(void *)(dvRoots.ModpathTable + dvUsedRootModpathTable()) = Root;
188 {
189 uint32 xRoot;
190 for(xRoot = (uint32)(dvRootGetModpathTableIndex(Root)); xRoot < dvRootGetModpathTableIndex(Root) + numModpathTables; xRoot++) {
191 dvRoots.ModpathTable[xRoot] = dvModpathNull;
192 }
193 }
194 dvSetUsedRootModpathTable(dvUsedRootModpathTable() + spaceNeeded);
195 }
196
197 /*----------------------------------------------------------------------------------------
198 Wrapper around dvRootGetModpathTables for the database manager.
199 ----------------------------------------------------------------------------------------*/
getRootModpathTables(uint64 objectNumber,uint32 * numValues)200 static void *getRootModpathTables(
201 uint64 objectNumber,
202 uint32 *numValues)
203 {
204 dvRoot Root = dvIndex2Root((uint32)objectNumber);
205
206 *numValues = dvRootGetNumModpathTable(Root);
207 return dvRootGetModpathTables(Root);
208 }
209
210 /*----------------------------------------------------------------------------------------
211 Wrapper around dvRootAllocModpathTables for the database manager.
212 ----------------------------------------------------------------------------------------*/
allocRootModpathTables(uint64 objectNumber,uint32 numValues)213 static void *allocRootModpathTables(
214 uint64 objectNumber,
215 uint32 numValues)
216 {
217 dvRoot Root = dvIndex2Root((uint32)objectNumber);
218
219 dvRootSetModpathTableIndex(Root, 0);
220 dvRootSetNumModpathTable(Root, 0);
221 if(numValues == 0) {
222 return NULL;
223 }
224 dvRootAllocModpathTables(Root, numValues);
225 return dvRootGetModpathTables(Root);
226 }
227
228 /*----------------------------------------------------------------------------------------
229 Free memory used by the Root.ModpathTable array.
230 ----------------------------------------------------------------------------------------*/
dvRootFreeModpathTables(dvRoot Root)231 void dvRootFreeModpathTables(
232 dvRoot Root)
233 {
234 uint32 elementSize = sizeof(dvModpath);
235 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
236 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
237 uint32 size = utMax(dvRootGetNumModpathTable(Root) + usedHeaderSize, freeHeaderSize);
238 dvModpath *dataPtr = dvRootGetModpathTables(Root) - usedHeaderSize;
239
240 if(dvRootGetNumModpathTable(Root) == 0) {
241 return;
242 }
243 *(dvRoot *)(void *)(dataPtr) = dvRootNull;
244 *(uint32 *)(void *)(((dvRoot *)(void *)dataPtr) + 1) = size;
245 dvRootSetNumModpathTable(Root, 0);
246 dvSetFreeRootModpathTable(dvFreeRootModpathTable() + size);
247 }
248
249 /*----------------------------------------------------------------------------------------
250 Resize the Root.ModpathTable array.
251 ----------------------------------------------------------------------------------------*/
dvRootResizeModpathTables(dvRoot Root,uint32 numModpathTables)252 void dvRootResizeModpathTables(
253 dvRoot Root,
254 uint32 numModpathTables)
255 {
256 uint32 freeSpace;
257 uint32 elementSize = sizeof(dvModpath);
258 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
259 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
260 uint32 newSize = utMax(numModpathTables + usedHeaderSize, freeHeaderSize);
261 uint32 oldSize = utMax(dvRootGetNumModpathTable(Root) + usedHeaderSize, freeHeaderSize);
262 dvModpath *dataPtr;
263
264 if(numModpathTables == 0) {
265 if(dvRootGetNumModpathTable(Root) != 0) {
266 dvRootFreeModpathTables(Root);
267 }
268 return;
269 }
270 if(dvRootGetNumModpathTable(Root) == 0) {
271 dvRootAllocModpathTables(Root, numModpathTables);
272 return;
273 }
274 freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();
275 if(freeSpace < newSize) {
276 allocMoreRootModpathTables(newSize);
277 }
278 dataPtr = dvRootGetModpathTables(Root) - usedHeaderSize;
279 memcpy((void *)(dvRoots.ModpathTable + dvUsedRootModpathTable()), dataPtr,
280 elementSize*utMin(oldSize, newSize));
281 if(newSize > oldSize) {
282 {
283 uint32 xRoot;
284 for(xRoot = (uint32)(dvUsedRootModpathTable() + oldSize); xRoot < dvUsedRootModpathTable() + oldSize + newSize - oldSize; xRoot++) {
285 dvRoots.ModpathTable[xRoot] = dvModpathNull;
286 }
287 }
288 }
289 *(dvRoot *)(void *)dataPtr = dvRootNull;
290 *(uint32 *)(void *)(((dvRoot *)(void *)dataPtr) + 1) = oldSize;
291 dvSetFreeRootModpathTable(dvFreeRootModpathTable() + oldSize);
292 dvRootSetModpathTableIndex(Root, dvUsedRootModpathTable() + usedHeaderSize);
293 dvRootSetNumModpathTable(Root, numModpathTables);
294 dvSetUsedRootModpathTable(dvUsedRootModpathTable() + newSize);
295 }
296
297 /*----------------------------------------------------------------------------------------
298 Compact the Root.ModuleTable heap to free memory.
299 ----------------------------------------------------------------------------------------*/
dvCompactRootModuleTables(void)300 void dvCompactRootModuleTables(void)
301 {
302 uint32 elementSize = sizeof(dvModule);
303 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
304 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
305 dvModule *toPtr = dvRoots.ModuleTable;
306 dvModule *fromPtr = toPtr;
307 dvRoot Root;
308 uint32 size;
309
310 while(fromPtr < dvRoots.ModuleTable + dvUsedRootModuleTable()) {
311 Root = *(dvRoot *)(void *)fromPtr;
312 if(Root != dvRootNull) {
313 /* Need to move it to toPtr */
314 size = utMax(dvRootGetNumModuleTable(Root) + usedHeaderSize, freeHeaderSize);
315 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
316 dvRootSetModuleTableIndex(Root, toPtr - dvRoots.ModuleTable + usedHeaderSize);
317 toPtr += size;
318 } else {
319 /* Just skip it */
320 size = *(uint32 *)(void *)(((dvRoot *)(void *)fromPtr) + 1);
321 }
322 fromPtr += size;
323 }
324 dvSetUsedRootModuleTable(toPtr - dvRoots.ModuleTable);
325 dvSetFreeRootModuleTable(0);
326 }
327
328 /*----------------------------------------------------------------------------------------
329 Allocate more memory for the Root.ModuleTable heap.
330 ----------------------------------------------------------------------------------------*/
allocMoreRootModuleTables(uint32 spaceNeeded)331 static void allocMoreRootModuleTables(
332 uint32 spaceNeeded)
333 {
334 uint32 freeSpace = dvAllocatedRootModuleTable() - dvUsedRootModuleTable();
335
336 if((dvFreeRootModuleTable() << 2) > dvUsedRootModuleTable()) {
337 dvCompactRootModuleTables();
338 freeSpace = dvAllocatedRootModuleTable() - dvUsedRootModuleTable();
339 }
340 if(freeSpace < spaceNeeded) {
341 dvSetAllocatedRootModuleTable(dvAllocatedRootModuleTable() + spaceNeeded - freeSpace +
342 (dvAllocatedRootModuleTable() >> 1));
343 utResizeArray(dvRoots.ModuleTable, dvAllocatedRootModuleTable());
344 }
345 }
346
347 /*----------------------------------------------------------------------------------------
348 Allocate memory for a new Root.ModuleTable array.
349 ----------------------------------------------------------------------------------------*/
dvRootAllocModuleTables(dvRoot Root,uint32 numModuleTables)350 void dvRootAllocModuleTables(
351 dvRoot Root,
352 uint32 numModuleTables)
353 {
354 uint32 freeSpace = dvAllocatedRootModuleTable() - dvUsedRootModuleTable();
355 uint32 elementSize = sizeof(dvModule);
356 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
357 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
358 uint32 spaceNeeded = utMax(numModuleTables + usedHeaderSize, freeHeaderSize);
359
360 #if defined(DD_DEBUG)
361 utAssert(dvRootGetNumModuleTable(Root) == 0);
362 #endif
363 if(numModuleTables == 0) {
364 return;
365 }
366 if(freeSpace < spaceNeeded) {
367 allocMoreRootModuleTables(spaceNeeded);
368 }
369 dvRootSetModuleTableIndex(Root, dvUsedRootModuleTable() + usedHeaderSize);
370 dvRootSetNumModuleTable(Root, numModuleTables);
371 *(dvRoot *)(void *)(dvRoots.ModuleTable + dvUsedRootModuleTable()) = Root;
372 {
373 uint32 xRoot;
374 for(xRoot = (uint32)(dvRootGetModuleTableIndex(Root)); xRoot < dvRootGetModuleTableIndex(Root) + numModuleTables; xRoot++) {
375 dvRoots.ModuleTable[xRoot] = dvModuleNull;
376 }
377 }
378 dvSetUsedRootModuleTable(dvUsedRootModuleTable() + spaceNeeded);
379 }
380
381 /*----------------------------------------------------------------------------------------
382 Wrapper around dvRootGetModuleTables for the database manager.
383 ----------------------------------------------------------------------------------------*/
getRootModuleTables(uint64 objectNumber,uint32 * numValues)384 static void *getRootModuleTables(
385 uint64 objectNumber,
386 uint32 *numValues)
387 {
388 dvRoot Root = dvIndex2Root((uint32)objectNumber);
389
390 *numValues = dvRootGetNumModuleTable(Root);
391 return dvRootGetModuleTables(Root);
392 }
393
394 /*----------------------------------------------------------------------------------------
395 Wrapper around dvRootAllocModuleTables for the database manager.
396 ----------------------------------------------------------------------------------------*/
allocRootModuleTables(uint64 objectNumber,uint32 numValues)397 static void *allocRootModuleTables(
398 uint64 objectNumber,
399 uint32 numValues)
400 {
401 dvRoot Root = dvIndex2Root((uint32)objectNumber);
402
403 dvRootSetModuleTableIndex(Root, 0);
404 dvRootSetNumModuleTable(Root, 0);
405 if(numValues == 0) {
406 return NULL;
407 }
408 dvRootAllocModuleTables(Root, numValues);
409 return dvRootGetModuleTables(Root);
410 }
411
412 /*----------------------------------------------------------------------------------------
413 Free memory used by the Root.ModuleTable array.
414 ----------------------------------------------------------------------------------------*/
dvRootFreeModuleTables(dvRoot Root)415 void dvRootFreeModuleTables(
416 dvRoot Root)
417 {
418 uint32 elementSize = sizeof(dvModule);
419 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
420 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
421 uint32 size = utMax(dvRootGetNumModuleTable(Root) + usedHeaderSize, freeHeaderSize);
422 dvModule *dataPtr = dvRootGetModuleTables(Root) - usedHeaderSize;
423
424 if(dvRootGetNumModuleTable(Root) == 0) {
425 return;
426 }
427 *(dvRoot *)(void *)(dataPtr) = dvRootNull;
428 *(uint32 *)(void *)(((dvRoot *)(void *)dataPtr) + 1) = size;
429 dvRootSetNumModuleTable(Root, 0);
430 dvSetFreeRootModuleTable(dvFreeRootModuleTable() + size);
431 }
432
433 /*----------------------------------------------------------------------------------------
434 Resize the Root.ModuleTable array.
435 ----------------------------------------------------------------------------------------*/
dvRootResizeModuleTables(dvRoot Root,uint32 numModuleTables)436 void dvRootResizeModuleTables(
437 dvRoot Root,
438 uint32 numModuleTables)
439 {
440 uint32 freeSpace;
441 uint32 elementSize = sizeof(dvModule);
442 uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
443 uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
444 uint32 newSize = utMax(numModuleTables + usedHeaderSize, freeHeaderSize);
445 uint32 oldSize = utMax(dvRootGetNumModuleTable(Root) + usedHeaderSize, freeHeaderSize);
446 dvModule *dataPtr;
447
448 if(numModuleTables == 0) {
449 if(dvRootGetNumModuleTable(Root) != 0) {
450 dvRootFreeModuleTables(Root);
451 }
452 return;
453 }
454 if(dvRootGetNumModuleTable(Root) == 0) {
455 dvRootAllocModuleTables(Root, numModuleTables);
456 return;
457 }
458 freeSpace = dvAllocatedRootModuleTable() - dvUsedRootModuleTable();
459 if(freeSpace < newSize) {
460 allocMoreRootModuleTables(newSize);
461 }
462 dataPtr = dvRootGetModuleTables(Root) - usedHeaderSize;
463 memcpy((void *)(dvRoots.ModuleTable + dvUsedRootModuleTable()), dataPtr,
464 elementSize*utMin(oldSize, newSize));
465 if(newSize > oldSize) {
466 {
467 uint32 xRoot;
468 for(xRoot = (uint32)(dvUsedRootModuleTable() + oldSize); xRoot < dvUsedRootModuleTable() + oldSize + newSize - oldSize; xRoot++) {
469 dvRoots.ModuleTable[xRoot] = dvModuleNull;
470 }
471 }
472 }
473 *(dvRoot *)(void *)dataPtr = dvRootNull;
474 *(uint32 *)(void *)(((dvRoot *)(void *)dataPtr) + 1) = oldSize;
475 dvSetFreeRootModuleTable(dvFreeRootModuleTable() + oldSize);
476 dvRootSetModuleTableIndex(Root, dvUsedRootModuleTable() + usedHeaderSize);
477 dvRootSetNumModuleTable(Root, numModuleTables);
478 dvSetUsedRootModuleTable(dvUsedRootModuleTable() + newSize);
479 }
480
481 /*----------------------------------------------------------------------------------------
482 Copy the properties of Root.
483 ----------------------------------------------------------------------------------------*/
dvRootCopyProps(dvRoot oldRoot,dvRoot newRoot)484 void dvRootCopyProps(
485 dvRoot oldRoot,
486 dvRoot newRoot)
487 {
488 }
489
490 static void addRootModpathToHashTable(dvRoot Root, dvModpath _Modpath);
491 /*----------------------------------------------------------------------------------------
492 Increase the size of the hash table.
493 ----------------------------------------------------------------------------------------*/
resizeRootModpathHashTable(dvRoot Root)494 static void resizeRootModpathHashTable(
495 dvRoot Root)
496 {
497 dvModpath _Modpath;
498 dvModpath *Modpaths;
499 uint32 numModpaths = dvRootGetNumModpathTable(Root) << 1;
500
501 if(numModpaths == 0) {
502 numModpaths = 2;
503 dvRootAllocModpathTables(Root, 2);
504 } else {
505 dvRootResizeModpathTables(Root, numModpaths);
506 }
507 Modpaths = dvRootGetModpathTables(Root);
508 /* Zero out the table */
509 while(numModpaths-- != 0) {
510 *Modpaths++ = dvModpathNull;
511 }
512 dvRootSetNumModpath(Root, 0);
513 dvForeachRootModpath(Root, _Modpath) {
514 if(dvModpathGetSym(_Modpath) != utSymNull) {
515 addRootModpathToHashTable(Root, _Modpath);
516 }
517 } dvEndRootModpath;
518 }
519
520 /*----------------------------------------------------------------------------------------
521 Add the Modpath to the Root. If the table is near full, build a new one twice
522 as big, delete the old one, and return the new one.
523 ----------------------------------------------------------------------------------------*/
addRootModpathToHashTable(dvRoot Root,dvModpath _Modpath)524 static void addRootModpathToHashTable(
525 dvRoot Root,
526 dvModpath _Modpath)
527 {
528 dvModpath nextModpath;
529 uint32 index;
530
531 if(dvRootGetNumModpath(Root) >= dvRootGetNumModpathTable(Root)) {
532 resizeRootModpathHashTable(Root);
533 return;
534 }
535 index = (dvRootGetNumModpathTable(Root) - 1) & utSymGetHashValue(dvModpathGetSym(_Modpath));
536 nextModpath = dvRootGetiModpathTable(Root, index);
537 dvModpathSetNextTableRootModpath(_Modpath, nextModpath);
538 dvRootSetiModpathTable(Root, index, _Modpath);
539 dvRootSetNumModpath(Root, dvRootGetNumModpath(Root) + 1);
540 }
541
542 /*----------------------------------------------------------------------------------------
543 Remove the Modpath from the hash table.
544 ----------------------------------------------------------------------------------------*/
removeRootModpathFromHashTable(dvRoot Root,dvModpath _Modpath)545 static void removeRootModpathFromHashTable(
546 dvRoot Root,
547 dvModpath _Modpath)
548 {
549 uint32 index = (dvRootGetNumModpathTable(Root) - 1) & utSymGetHashValue(dvModpathGetSym(_Modpath));
550 dvModpath prevModpath, nextModpath;
551
552 nextModpath = dvRootGetiModpathTable(Root, index);
553 if(nextModpath == _Modpath) {
554 dvRootSetiModpathTable(Root, index, dvModpathGetNextTableRootModpath(nextModpath));
555 } else {
556 do {
557 prevModpath = nextModpath;
558 nextModpath = dvModpathGetNextTableRootModpath(nextModpath);
559 } while(nextModpath != _Modpath);
560 dvModpathSetNextTableRootModpath(prevModpath, dvModpathGetNextTableRootModpath(_Modpath));
561 }
562 dvRootSetNumModpath(Root, dvRootGetNumModpath(Root) - 1);
563 dvModpathSetNextTableRootModpath(_Modpath, dvModpathNull);
564 }
565
566 /*----------------------------------------------------------------------------------------
567 Find the Modpath from the Root and its hash key.
568 ----------------------------------------------------------------------------------------*/
dvRootFindModpath(dvRoot Root,utSym Sym)569 dvModpath dvRootFindModpath(
570 dvRoot Root,
571 utSym Sym)
572 {
573 uint32 mask = dvRootGetNumModpathTable(Root) - 1;
574 dvModpath _Modpath;
575
576 if(mask + 1 != 0) {
577 _Modpath = dvRootGetiModpathTable(Root, utSymGetHashValue(Sym) & mask);
578 while(_Modpath != dvModpathNull) {
579 if(dvModpathGetSym(_Modpath) == Sym) {
580 return _Modpath;
581 }
582 _Modpath = dvModpathGetNextTableRootModpath(_Modpath);
583 }
584 }
585 return dvModpathNull;
586 }
587
588 /*----------------------------------------------------------------------------------------
589 Find the Modpath from the Root and its name.
590 ----------------------------------------------------------------------------------------*/
dvRootRenameModpath(dvRoot Root,dvModpath _Modpath,utSym sym)591 void dvRootRenameModpath(
592 dvRoot Root,
593 dvModpath _Modpath,
594 utSym sym)
595 {
596 if(dvModpathGetSym(_Modpath) != utSymNull) {
597 removeRootModpathFromHashTable(Root, _Modpath);
598 }
599 dvModpathSetSym(_Modpath, sym);
600 if(sym != utSymNull) {
601 addRootModpathToHashTable(Root, _Modpath);
602 }
603 }
604
605 /*----------------------------------------------------------------------------------------
606 Add the Modpath to the head of the list on the Root.
607 ----------------------------------------------------------------------------------------*/
dvRootInsertModpath(dvRoot Root,dvModpath _Modpath)608 void dvRootInsertModpath(
609 dvRoot Root,
610 dvModpath _Modpath)
611 {
612 #if defined(DD_DEBUG)
613 if(Root == dvRootNull) {
614 utExit("Non-existent Root");
615 }
616 if(_Modpath == dvModpathNull) {
617 utExit("Non-existent Modpath");
618 }
619 if(dvModpathGetRoot(_Modpath) != dvRootNull) {
620 utExit("Attempting to add Modpath to Root twice");
621 }
622 #endif
623 dvModpathSetNextRootModpath(_Modpath, dvRootGetFirstModpath(Root));
624 if(dvRootGetFirstModpath(Root) != dvModpathNull) {
625 dvModpathSetPrevRootModpath(dvRootGetFirstModpath(Root), _Modpath);
626 }
627 dvRootSetFirstModpath(Root, _Modpath);
628 dvModpathSetPrevRootModpath(_Modpath, dvModpathNull);
629 if(dvRootGetLastModpath(Root) == dvModpathNull) {
630 dvRootSetLastModpath(Root, _Modpath);
631 }
632 dvModpathSetRoot(_Modpath, Root);
633 if(dvModpathGetSym(_Modpath) != utSymNull) {
634 addRootModpathToHashTable(Root, _Modpath);
635 }
636 }
637
638 /*----------------------------------------------------------------------------------------
639 Add the Modpath to the end of the list on the Root.
640 ----------------------------------------------------------------------------------------*/
dvRootAppendModpath(dvRoot Root,dvModpath _Modpath)641 void dvRootAppendModpath(
642 dvRoot Root,
643 dvModpath _Modpath)
644 {
645 #if defined(DD_DEBUG)
646 if(Root == dvRootNull) {
647 utExit("Non-existent Root");
648 }
649 if(_Modpath == dvModpathNull) {
650 utExit("Non-existent Modpath");
651 }
652 if(dvModpathGetRoot(_Modpath) != dvRootNull) {
653 utExit("Attempting to add Modpath to Root twice");
654 }
655 #endif
656 dvModpathSetPrevRootModpath(_Modpath, dvRootGetLastModpath(Root));
657 if(dvRootGetLastModpath(Root) != dvModpathNull) {
658 dvModpathSetNextRootModpath(dvRootGetLastModpath(Root), _Modpath);
659 }
660 dvRootSetLastModpath(Root, _Modpath);
661 dvModpathSetNextRootModpath(_Modpath, dvModpathNull);
662 if(dvRootGetFirstModpath(Root) == dvModpathNull) {
663 dvRootSetFirstModpath(Root, _Modpath);
664 }
665 dvModpathSetRoot(_Modpath, Root);
666 if(dvModpathGetSym(_Modpath) != utSymNull) {
667 addRootModpathToHashTable(Root, _Modpath);
668 }
669 }
670
671 /*----------------------------------------------------------------------------------------
672 Insert the Modpath to the Root after the previous Modpath.
673 ----------------------------------------------------------------------------------------*/
dvRootInsertAfterModpath(dvRoot Root,dvModpath prevModpath,dvModpath _Modpath)674 void dvRootInsertAfterModpath(
675 dvRoot Root,
676 dvModpath prevModpath,
677 dvModpath _Modpath)
678 {
679 dvModpath nextModpath = dvModpathGetNextRootModpath(prevModpath);
680
681 #if defined(DD_DEBUG)
682 if(Root == dvRootNull) {
683 utExit("Non-existent Root");
684 }
685 if(_Modpath == dvModpathNull) {
686 utExit("Non-existent Modpath");
687 }
688 if(dvModpathGetRoot(_Modpath) != dvRootNull) {
689 utExit("Attempting to add Modpath to Root twice");
690 }
691 #endif
692 dvModpathSetNextRootModpath(_Modpath, nextModpath);
693 dvModpathSetNextRootModpath(prevModpath, _Modpath);
694 dvModpathSetPrevRootModpath(_Modpath, prevModpath);
695 if(nextModpath != dvModpathNull) {
696 dvModpathSetPrevRootModpath(nextModpath, _Modpath);
697 }
698 if(dvRootGetLastModpath(Root) == prevModpath) {
699 dvRootSetLastModpath(Root, _Modpath);
700 }
701 dvModpathSetRoot(_Modpath, Root);
702 if(dvModpathGetSym(_Modpath) != utSymNull) {
703 addRootModpathToHashTable(Root, _Modpath);
704 }
705 }
706
707 /*----------------------------------------------------------------------------------------
708 Remove the Modpath from the Root.
709 ----------------------------------------------------------------------------------------*/
dvRootRemoveModpath(dvRoot Root,dvModpath _Modpath)710 void dvRootRemoveModpath(
711 dvRoot Root,
712 dvModpath _Modpath)
713 {
714 dvModpath pModpath, nModpath;
715
716 #if defined(DD_DEBUG)
717 if(_Modpath == dvModpathNull) {
718 utExit("Non-existent Modpath");
719 }
720 if(dvModpathGetRoot(_Modpath) != dvRootNull && dvModpathGetRoot(_Modpath) != Root) {
721 utExit("Delete Modpath from non-owning Root");
722 }
723 #endif
724 nModpath = dvModpathGetNextRootModpath(_Modpath);
725 pModpath = dvModpathGetPrevRootModpath(_Modpath);
726 if(pModpath != dvModpathNull) {
727 dvModpathSetNextRootModpath(pModpath, nModpath);
728 } else if(dvRootGetFirstModpath(Root) == _Modpath) {
729 dvRootSetFirstModpath(Root, nModpath);
730 }
731 if(nModpath != dvModpathNull) {
732 dvModpathSetPrevRootModpath(nModpath, pModpath);
733 } else if(dvRootGetLastModpath(Root) == _Modpath) {
734 dvRootSetLastModpath(Root, pModpath);
735 }
736 dvModpathSetNextRootModpath(_Modpath, dvModpathNull);
737 dvModpathSetPrevRootModpath(_Modpath, dvModpathNull);
738 dvModpathSetRoot(_Modpath, dvRootNull);
739 if(dvModpathGetSym(_Modpath) != utSymNull) {
740 removeRootModpathFromHashTable(Root, _Modpath);
741 }
742 }
743
744 static void addRootModuleToHashTable(dvRoot Root, dvModule _Module);
745 /*----------------------------------------------------------------------------------------
746 Increase the size of the hash table.
747 ----------------------------------------------------------------------------------------*/
resizeRootModuleHashTable(dvRoot Root)748 static void resizeRootModuleHashTable(
749 dvRoot Root)
750 {
751 dvModule _Module;
752 dvModule *Modules;
753 uint32 numModules = dvRootGetNumModuleTable(Root) << 1;
754
755 if(numModules == 0) {
756 numModules = 2;
757 dvRootAllocModuleTables(Root, 2);
758 } else {
759 dvRootResizeModuleTables(Root, numModules);
760 }
761 Modules = dvRootGetModuleTables(Root);
762 /* Zero out the table */
763 while(numModules-- != 0) {
764 *Modules++ = dvModuleNull;
765 }
766 dvRootSetNumModule(Root, 0);
767 dvForeachRootModule(Root, _Module) {
768 if(dvModuleGetSym(_Module) != utSymNull) {
769 addRootModuleToHashTable(Root, _Module);
770 }
771 } dvEndRootModule;
772 }
773
774 /*----------------------------------------------------------------------------------------
775 Add the Module to the Root. If the table is near full, build a new one twice
776 as big, delete the old one, and return the new one.
777 ----------------------------------------------------------------------------------------*/
addRootModuleToHashTable(dvRoot Root,dvModule _Module)778 static void addRootModuleToHashTable(
779 dvRoot Root,
780 dvModule _Module)
781 {
782 dvModule nextModule;
783 uint32 index;
784
785 if(dvRootGetNumModule(Root) >= dvRootGetNumModuleTable(Root)) {
786 resizeRootModuleHashTable(Root);
787 return;
788 }
789 index = (dvRootGetNumModuleTable(Root) - 1) & utSymGetHashValue(dvModuleGetSym(_Module));
790 nextModule = dvRootGetiModuleTable(Root, index);
791 dvModuleSetNextTableRootModule(_Module, nextModule);
792 dvRootSetiModuleTable(Root, index, _Module);
793 dvRootSetNumModule(Root, dvRootGetNumModule(Root) + 1);
794 }
795
796 /*----------------------------------------------------------------------------------------
797 Remove the Module from the hash table.
798 ----------------------------------------------------------------------------------------*/
removeRootModuleFromHashTable(dvRoot Root,dvModule _Module)799 static void removeRootModuleFromHashTable(
800 dvRoot Root,
801 dvModule _Module)
802 {
803 uint32 index = (dvRootGetNumModuleTable(Root) - 1) & utSymGetHashValue(dvModuleGetSym(_Module));
804 dvModule prevModule, nextModule;
805
806 nextModule = dvRootGetiModuleTable(Root, index);
807 if(nextModule == _Module) {
808 dvRootSetiModuleTable(Root, index, dvModuleGetNextTableRootModule(nextModule));
809 } else {
810 do {
811 prevModule = nextModule;
812 nextModule = dvModuleGetNextTableRootModule(nextModule);
813 } while(nextModule != _Module);
814 dvModuleSetNextTableRootModule(prevModule, dvModuleGetNextTableRootModule(_Module));
815 }
816 dvRootSetNumModule(Root, dvRootGetNumModule(Root) - 1);
817 dvModuleSetNextTableRootModule(_Module, dvModuleNull);
818 }
819
820 /*----------------------------------------------------------------------------------------
821 Find the Module from the Root and its hash key.
822 ----------------------------------------------------------------------------------------*/
dvRootFindModule(dvRoot Root,utSym Sym)823 dvModule dvRootFindModule(
824 dvRoot Root,
825 utSym Sym)
826 {
827 uint32 mask = dvRootGetNumModuleTable(Root) - 1;
828 dvModule _Module;
829
830 if(mask + 1 != 0) {
831 _Module = dvRootGetiModuleTable(Root, utSymGetHashValue(Sym) & mask);
832 while(_Module != dvModuleNull) {
833 if(dvModuleGetSym(_Module) == Sym) {
834 return _Module;
835 }
836 _Module = dvModuleGetNextTableRootModule(_Module);
837 }
838 }
839 return dvModuleNull;
840 }
841
842 /*----------------------------------------------------------------------------------------
843 Find the Module from the Root and its name.
844 ----------------------------------------------------------------------------------------*/
dvRootRenameModule(dvRoot Root,dvModule _Module,utSym sym)845 void dvRootRenameModule(
846 dvRoot Root,
847 dvModule _Module,
848 utSym sym)
849 {
850 if(dvModuleGetSym(_Module) != utSymNull) {
851 removeRootModuleFromHashTable(Root, _Module);
852 }
853 dvModuleSetSym(_Module, sym);
854 if(sym != utSymNull) {
855 addRootModuleToHashTable(Root, _Module);
856 }
857 }
858
859 /*----------------------------------------------------------------------------------------
860 Add the Module to the head of the list on the Root.
861 ----------------------------------------------------------------------------------------*/
dvRootInsertModule(dvRoot Root,dvModule _Module)862 void dvRootInsertModule(
863 dvRoot Root,
864 dvModule _Module)
865 {
866 #if defined(DD_DEBUG)
867 if(Root == dvRootNull) {
868 utExit("Non-existent Root");
869 }
870 if(_Module == dvModuleNull) {
871 utExit("Non-existent Module");
872 }
873 #endif
874 dvModuleSetNextRootModule(_Module, dvRootGetFirstModule(Root));
875 if(dvRootGetFirstModule(Root) != dvModuleNull) {
876 dvModuleSetPrevRootModule(dvRootGetFirstModule(Root), _Module);
877 }
878 dvRootSetFirstModule(Root, _Module);
879 dvModuleSetPrevRootModule(_Module, dvModuleNull);
880 if(dvRootGetLastModule(Root) == dvModuleNull) {
881 dvRootSetLastModule(Root, _Module);
882 }
883 if(dvModuleGetSym(_Module) != utSymNull) {
884 addRootModuleToHashTable(Root, _Module);
885 }
886 }
887
888 /*----------------------------------------------------------------------------------------
889 Add the Module to the end of the list on the Root.
890 ----------------------------------------------------------------------------------------*/
dvRootAppendModule(dvRoot Root,dvModule _Module)891 void dvRootAppendModule(
892 dvRoot Root,
893 dvModule _Module)
894 {
895 #if defined(DD_DEBUG)
896 if(Root == dvRootNull) {
897 utExit("Non-existent Root");
898 }
899 if(_Module == dvModuleNull) {
900 utExit("Non-existent Module");
901 }
902 #endif
903 dvModuleSetPrevRootModule(_Module, dvRootGetLastModule(Root));
904 if(dvRootGetLastModule(Root) != dvModuleNull) {
905 dvModuleSetNextRootModule(dvRootGetLastModule(Root), _Module);
906 }
907 dvRootSetLastModule(Root, _Module);
908 dvModuleSetNextRootModule(_Module, dvModuleNull);
909 if(dvRootGetFirstModule(Root) == dvModuleNull) {
910 dvRootSetFirstModule(Root, _Module);
911 }
912 if(dvModuleGetSym(_Module) != utSymNull) {
913 addRootModuleToHashTable(Root, _Module);
914 }
915 }
916
917 /*----------------------------------------------------------------------------------------
918 Insert the Module to the Root after the previous Module.
919 ----------------------------------------------------------------------------------------*/
dvRootInsertAfterModule(dvRoot Root,dvModule prevModule,dvModule _Module)920 void dvRootInsertAfterModule(
921 dvRoot Root,
922 dvModule prevModule,
923 dvModule _Module)
924 {
925 dvModule nextModule = dvModuleGetNextRootModule(prevModule);
926
927 #if defined(DD_DEBUG)
928 if(Root == dvRootNull) {
929 utExit("Non-existent Root");
930 }
931 if(_Module == dvModuleNull) {
932 utExit("Non-existent Module");
933 }
934 #endif
935 dvModuleSetNextRootModule(_Module, nextModule);
936 dvModuleSetNextRootModule(prevModule, _Module);
937 dvModuleSetPrevRootModule(_Module, prevModule);
938 if(nextModule != dvModuleNull) {
939 dvModuleSetPrevRootModule(nextModule, _Module);
940 }
941 if(dvRootGetLastModule(Root) == prevModule) {
942 dvRootSetLastModule(Root, _Module);
943 }
944 if(dvModuleGetSym(_Module) != utSymNull) {
945 addRootModuleToHashTable(Root, _Module);
946 }
947 }
948
949 /*----------------------------------------------------------------------------------------
950 Remove the Module from the Root.
951 ----------------------------------------------------------------------------------------*/
dvRootRemoveModule(dvRoot Root,dvModule _Module)952 void dvRootRemoveModule(
953 dvRoot Root,
954 dvModule _Module)
955 {
956 dvModule pModule, nModule;
957
958 #if defined(DD_DEBUG)
959 if(_Module == dvModuleNull) {
960 utExit("Non-existent Module");
961 }
962 #endif
963 nModule = dvModuleGetNextRootModule(_Module);
964 pModule = dvModuleGetPrevRootModule(_Module);
965 if(pModule != dvModuleNull) {
966 dvModuleSetNextRootModule(pModule, nModule);
967 } else if(dvRootGetFirstModule(Root) == _Module) {
968 dvRootSetFirstModule(Root, nModule);
969 }
970 if(nModule != dvModuleNull) {
971 dvModuleSetPrevRootModule(nModule, pModule);
972 } else if(dvRootGetLastModule(Root) == _Module) {
973 dvRootSetLastModule(Root, pModule);
974 }
975 dvModuleSetNextRootModule(_Module, dvModuleNull);
976 dvModuleSetPrevRootModule(_Module, dvModuleNull);
977 if(dvModuleGetSym(_Module) != utSymNull) {
978 removeRootModuleFromHashTable(Root, _Module);
979 }
980 }
981
982 #if defined(DD_DEBUG)
983 /*----------------------------------------------------------------------------------------
984 Write out all the fields of an object.
985 ----------------------------------------------------------------------------------------*/
dvShowRoot(dvRoot Root)986 void dvShowRoot(
987 dvRoot Root)
988 {
989 utDatabaseShowObject("dv", "Root", dvRoot2Index(Root));
990 }
991 #endif
992
993 /*----------------------------------------------------------------------------------------
994 Default constructor wrapper for the database manager.
995 ----------------------------------------------------------------------------------------*/
allocModpath(void)996 static uint64 allocModpath(void)
997 {
998 dvModpath Modpath = dvModpathAlloc();
999
1000 return dvModpath2Index(Modpath);
1001 }
1002
1003 /*----------------------------------------------------------------------------------------
1004 Allocate the field arrays of Modpath.
1005 ----------------------------------------------------------------------------------------*/
allocModpaths(void)1006 static void allocModpaths(void)
1007 {
1008 dvSetAllocatedModpath(2);
1009 dvSetUsedModpath(0);
1010 dvModpaths.Sym = utNewA(utSym, (dvAllocatedModpath()));
1011 dvModpaths.Root = utNewA(dvRoot, (dvAllocatedModpath()));
1012 dvModpaths.NextRootModpath = utNewA(dvModpath, (dvAllocatedModpath()));
1013 dvModpaths.PrevRootModpath = utNewA(dvModpath, (dvAllocatedModpath()));
1014 dvModpaths.NextTableRootModpath = utNewA(dvModpath, (dvAllocatedModpath()));
1015 }
1016
1017 /*----------------------------------------------------------------------------------------
1018 Realloc the arrays of properties for class Modpath.
1019 ----------------------------------------------------------------------------------------*/
reallocModpaths(uint32 newSize)1020 static void reallocModpaths(
1021 uint32 newSize)
1022 {
1023 utResizeArray(dvModpaths.Sym, (newSize));
1024 utResizeArray(dvModpaths.Root, (newSize));
1025 utResizeArray(dvModpaths.NextRootModpath, (newSize));
1026 utResizeArray(dvModpaths.PrevRootModpath, (newSize));
1027 utResizeArray(dvModpaths.NextTableRootModpath, (newSize));
1028 dvSetAllocatedModpath(newSize);
1029 }
1030
1031 /*----------------------------------------------------------------------------------------
1032 Allocate more Modpaths.
1033 ----------------------------------------------------------------------------------------*/
dvModpathAllocMore(void)1034 void dvModpathAllocMore(void)
1035 {
1036 reallocModpaths((uint32)(dvAllocatedModpath() + (dvAllocatedModpath() >> 1)));
1037 }
1038
1039 /*----------------------------------------------------------------------------------------
1040 Copy the properties of Modpath.
1041 ----------------------------------------------------------------------------------------*/
dvModpathCopyProps(dvModpath oldModpath,dvModpath newModpath)1042 void dvModpathCopyProps(
1043 dvModpath oldModpath,
1044 dvModpath newModpath)
1045 {
1046 }
1047
1048 #if defined(DD_DEBUG)
1049 /*----------------------------------------------------------------------------------------
1050 Write out all the fields of an object.
1051 ----------------------------------------------------------------------------------------*/
dvShowModpath(dvModpath Modpath)1052 void dvShowModpath(
1053 dvModpath Modpath)
1054 {
1055 utDatabaseShowObject("dv", "Modpath", dvModpath2Index(Modpath));
1056 }
1057 #endif
1058
1059 /*----------------------------------------------------------------------------------------
1060 Default constructor wrapper for the database manager.
1061 ----------------------------------------------------------------------------------------*/
allocModule(void)1062 static uint64 allocModule(void)
1063 {
1064 dvModule Module = dvModuleAlloc();
1065
1066 return dvModule2Index(Module);
1067 }
1068
1069 /*----------------------------------------------------------------------------------------
1070 Allocate the field arrays of Module.
1071 ----------------------------------------------------------------------------------------*/
allocModules(void)1072 static void allocModules(void)
1073 {
1074 dvSetAllocatedModule(2);
1075 dvSetUsedModule(0);
1076 dvModules.Sym = utNewA(utSym, (dvAllocatedModule()));
1077 dvModules.PrefixSym = utNewA(utSym, (dvAllocatedModule()));
1078 dvModules.Persistent = utNewA(uint8, (dvAllocatedModule() + 7) >> 3);
1079 dvModules.UndoRedo = utNewA(uint8, (dvAllocatedModule() + 7) >> 3);
1080 dvModules.HasSparseData = utNewA(uint8, (dvAllocatedModule() + 7) >> 3);
1081 dvModules.NumFields = utNewA(uint16, (dvAllocatedModule()));
1082 dvModules.NumClasses = utNewA(uint32, (dvAllocatedModule()));
1083 dvModules.NumEnums = utNewA(uint32, (dvAllocatedModule()));
1084 dvModules.NextRootModule = utNewA(dvModule, (dvAllocatedModule()));
1085 dvModules.PrevRootModule = utNewA(dvModule, (dvAllocatedModule()));
1086 dvModules.NextTableRootModule = utNewA(dvModule, (dvAllocatedModule()));
1087 dvModules.FirstClass = utNewA(dvClass, (dvAllocatedModule()));
1088 dvModules.LastClass = utNewA(dvClass, (dvAllocatedModule()));
1089 dvModules.ClassTableIndex = utNewA(uint32, (dvAllocatedModule()));
1090 dvModules.NumClassTable = utNewA(uint32, (dvAllocatedModule()));
1091 dvSetUsedModuleClassTable(0);
1092 dvSetAllocatedModuleClassTable(2);
1093 dvSetFreeModuleClassTable(0);
1094 dvModules.ClassTable = utNewA(dvClass, dvAllocatedModuleClassTable());
1095 dvModules.NumClass = utNewA(uint32, (dvAllocatedModule()));
1096 dvModules.FirstEnum = utNewA(dvEnum, (dvAllocatedModule()));
1097 dvModules.LastEnum = utNewA(dvEnum, (dvAllocatedModule()));
1098 dvModules.EnumTableIndex = utNewA(uint32, (dvAllocatedModule()));
1099 dvModules.NumEnumTable = utNewA(uint32, (dvAllocatedModule()));
1100 dvSetUsedModuleEnumTable(0);
1101 dvSetAllocatedModuleEnumTable(2);
1102 dvSetFreeModuleEnumTable(0);
1103 dvModules.EnumTable = utNewA(dvEnum, dvAllocatedModuleEnumTable());
1104 dvModules.NumEnum = utNewA(uint32, (dvAllocatedModule()));
1105 dvModules.FirstTypedef = utNewA(dvTypedef, (dvAllocatedModule()));
1106 dvModules.LastTypedef = utNewA(dvTypedef, (dvAllocatedModule()));
1107 dvModules.TypedefTableIndex = utNewA(uint32, (dvAllocatedModule()));
1108 dvModules.NumTypedefTable = utNewA(uint32, (dvAllocatedModule()));
1109 dvSetUsedModuleTypedefTable(0);
1110 dvSetAllocatedModuleTypedefTable(2);
1111 dvSetFreeModuleTypedefTable(0);
1112 dvModules.TypedefTable = utNewA(dvTypedef, dvAllocatedModuleTypedefTable());
1113 dvModules.NumTypedef = utNewA(uint32, (dvAllocatedModule()));
1114 dvModules.FirstSchema = utNewA(dvSchema, (dvAllocatedModule()));
1115 dvModules.LastSchema = utNewA(dvSchema, (dvAllocatedModule()));
1116 dvModules.SchemaTableIndex = utNewA(uint32, (dvAllocatedModule()));
1117 dvModules.NumSchemaTable = utNewA(uint32, (dvAllocatedModule()));
1118 dvSetUsedModuleSchemaTable(0);
1119 dvSetAllocatedModuleSchemaTable(2);
1120 dvSetFreeModuleSchemaTable(0);
1121 dvModules.SchemaTable = utNewA(dvSchema, dvAllocatedModuleSchemaTable());
1122 dvModules.NumSchema = utNewA(uint32, (dvAllocatedModule()));
1123 dvModules.FirstImportLink = utNewA(dvLink, (dvAllocatedModule()));
1124 dvModules.LastImportLink = utNewA(dvLink, (dvAllocatedModule()));
1125 dvModules.FirstExportLink = utNewA(dvLink, (dvAllocatedModule()));
1126 dvModules.LastExportLink = utNewA(dvLink, (dvAllocatedModule()));
1127 }
1128
1129 /*----------------------------------------------------------------------------------------
1130 Realloc the arrays of properties for class Module.
1131 ----------------------------------------------------------------------------------------*/
reallocModules(uint32 newSize)1132 static void reallocModules(
1133 uint32 newSize)
1134 {
1135 utResizeArray(dvModules.Sym, (newSize));
1136 utResizeArray(dvModules.PrefixSym, (newSize));
1137 utResizeArray(dvModules.Persistent, (newSize + 7) >> 3);
1138 utResizeArray(dvModules.UndoRedo, (newSize + 7) >> 3);
1139 utResizeArray(dvModules.HasSparseData, (newSize + 7) >> 3);
1140 utResizeArray(dvModules.NumFields, (newSize));
1141 utResizeArray(dvModules.NumClasses, (newSize));
1142 utResizeArray(dvModules.NumEnums, (newSize));
1143 utResizeArray(dvModules.NextRootModule, (newSize));
1144 utResizeArray(dvModules.PrevRootModule, (newSize));
1145 utResizeArray(dvModules.NextTableRootModule, (newSize));
1146 utResizeArray(dvModules.FirstClass, (newSize));
1147 utResizeArray(dvModules.LastClass, (newSize));
1148 utResizeArray(dvModules.ClassTableIndex, (newSize));
1149 utResizeArray(dvModules.NumClassTable, (newSize));
1150 utResizeArray(dvModules.NumClass, (newSize));
1151 utResizeArray(dvModules.FirstEnum, (newSize));
1152 utResizeArray(dvModules.LastEnum, (newSize));
1153 utResizeArray(dvModules.EnumTableIndex, (newSize));
1154 utResizeArray(dvModules.NumEnumTable, (newSize));
1155 utResizeArray(dvModules.NumEnum, (newSize));
1156 utResizeArray(dvModules.FirstTypedef, (newSize));
1157 utResizeArray(dvModules.LastTypedef, (newSize));
1158 utResizeArray(dvModules.TypedefTableIndex, (newSize));
1159 utResizeArray(dvModules.NumTypedefTable, (newSize));
1160 utResizeArray(dvModules.NumTypedef, (newSize));
1161 utResizeArray(dvModules.FirstSchema, (newSize));
1162 utResizeArray(dvModules.LastSchema, (newSize));
1163 utResizeArray(dvModules.SchemaTableIndex, (newSize));
1164 utResizeArray(dvModules.NumSchemaTable, (newSize));
1165 utResizeArray(dvModules.NumSchema, (newSize));
1166 utResizeArray(dvModules.FirstImportLink, (newSize));
1167 utResizeArray(dvModules.LastImportLink, (newSize));
1168 utResizeArray(dvModules.FirstExportLink, (newSize));
1169 utResizeArray(dvModules.LastExportLink, (newSize));
1170 dvSetAllocatedModule(newSize);
1171 }
1172
1173 /*----------------------------------------------------------------------------------------
1174 Allocate more Modules.
1175 ----------------------------------------------------------------------------------------*/
dvModuleAllocMore(void)1176 void dvModuleAllocMore(void)
1177 {
1178 reallocModules((uint32)(dvAllocatedModule() + (dvAllocatedModule() >> 1)));
1179 }
1180
1181 /*----------------------------------------------------------------------------------------
1182 Compact the Module.ClassTable heap to free memory.
1183 ----------------------------------------------------------------------------------------*/
dvCompactModuleClassTables(void)1184 void dvCompactModuleClassTables(void)
1185 {
1186 uint32 elementSize = sizeof(dvClass);
1187 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1188 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1189 dvClass *toPtr = dvModules.ClassTable;
1190 dvClass *fromPtr = toPtr;
1191 dvModule Module;
1192 uint32 size;
1193
1194 while(fromPtr < dvModules.ClassTable + dvUsedModuleClassTable()) {
1195 Module = *(dvModule *)(void *)fromPtr;
1196 if(Module != dvModuleNull) {
1197 /* Need to move it to toPtr */
1198 size = utMax(dvModuleGetNumClassTable(Module) + usedHeaderSize, freeHeaderSize);
1199 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
1200 dvModuleSetClassTableIndex(Module, toPtr - dvModules.ClassTable + usedHeaderSize);
1201 toPtr += size;
1202 } else {
1203 /* Just skip it */
1204 size = *(uint32 *)(void *)(((dvModule *)(void *)fromPtr) + 1);
1205 }
1206 fromPtr += size;
1207 }
1208 dvSetUsedModuleClassTable(toPtr - dvModules.ClassTable);
1209 dvSetFreeModuleClassTable(0);
1210 }
1211
1212 /*----------------------------------------------------------------------------------------
1213 Allocate more memory for the Module.ClassTable heap.
1214 ----------------------------------------------------------------------------------------*/
allocMoreModuleClassTables(uint32 spaceNeeded)1215 static void allocMoreModuleClassTables(
1216 uint32 spaceNeeded)
1217 {
1218 uint32 freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();
1219
1220 if((dvFreeModuleClassTable() << 2) > dvUsedModuleClassTable()) {
1221 dvCompactModuleClassTables();
1222 freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();
1223 }
1224 if(freeSpace < spaceNeeded) {
1225 dvSetAllocatedModuleClassTable(dvAllocatedModuleClassTable() + spaceNeeded - freeSpace +
1226 (dvAllocatedModuleClassTable() >> 1));
1227 utResizeArray(dvModules.ClassTable, dvAllocatedModuleClassTable());
1228 }
1229 }
1230
1231 /*----------------------------------------------------------------------------------------
1232 Allocate memory for a new Module.ClassTable array.
1233 ----------------------------------------------------------------------------------------*/
dvModuleAllocClassTables(dvModule Module,uint32 numClassTables)1234 void dvModuleAllocClassTables(
1235 dvModule Module,
1236 uint32 numClassTables)
1237 {
1238 uint32 freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();
1239 uint32 elementSize = sizeof(dvClass);
1240 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1241 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1242 uint32 spaceNeeded = utMax(numClassTables + usedHeaderSize, freeHeaderSize);
1243
1244 #if defined(DD_DEBUG)
1245 utAssert(dvModuleGetNumClassTable(Module) == 0);
1246 #endif
1247 if(numClassTables == 0) {
1248 return;
1249 }
1250 if(freeSpace < spaceNeeded) {
1251 allocMoreModuleClassTables(spaceNeeded);
1252 }
1253 dvModuleSetClassTableIndex(Module, dvUsedModuleClassTable() + usedHeaderSize);
1254 dvModuleSetNumClassTable(Module, numClassTables);
1255 *(dvModule *)(void *)(dvModules.ClassTable + dvUsedModuleClassTable()) = Module;
1256 {
1257 uint32 xModule;
1258 for(xModule = (uint32)(dvModuleGetClassTableIndex(Module)); xModule < dvModuleGetClassTableIndex(Module) + numClassTables; xModule++) {
1259 dvModules.ClassTable[xModule] = dvClassNull;
1260 }
1261 }
1262 dvSetUsedModuleClassTable(dvUsedModuleClassTable() + spaceNeeded);
1263 }
1264
1265 /*----------------------------------------------------------------------------------------
1266 Wrapper around dvModuleGetClassTables for the database manager.
1267 ----------------------------------------------------------------------------------------*/
getModuleClassTables(uint64 objectNumber,uint32 * numValues)1268 static void *getModuleClassTables(
1269 uint64 objectNumber,
1270 uint32 *numValues)
1271 {
1272 dvModule Module = dvIndex2Module((uint32)objectNumber);
1273
1274 *numValues = dvModuleGetNumClassTable(Module);
1275 return dvModuleGetClassTables(Module);
1276 }
1277
1278 /*----------------------------------------------------------------------------------------
1279 Wrapper around dvModuleAllocClassTables for the database manager.
1280 ----------------------------------------------------------------------------------------*/
allocModuleClassTables(uint64 objectNumber,uint32 numValues)1281 static void *allocModuleClassTables(
1282 uint64 objectNumber,
1283 uint32 numValues)
1284 {
1285 dvModule Module = dvIndex2Module((uint32)objectNumber);
1286
1287 dvModuleSetClassTableIndex(Module, 0);
1288 dvModuleSetNumClassTable(Module, 0);
1289 if(numValues == 0) {
1290 return NULL;
1291 }
1292 dvModuleAllocClassTables(Module, numValues);
1293 return dvModuleGetClassTables(Module);
1294 }
1295
1296 /*----------------------------------------------------------------------------------------
1297 Free memory used by the Module.ClassTable array.
1298 ----------------------------------------------------------------------------------------*/
dvModuleFreeClassTables(dvModule Module)1299 void dvModuleFreeClassTables(
1300 dvModule Module)
1301 {
1302 uint32 elementSize = sizeof(dvClass);
1303 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1304 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1305 uint32 size = utMax(dvModuleGetNumClassTable(Module) + usedHeaderSize, freeHeaderSize);
1306 dvClass *dataPtr = dvModuleGetClassTables(Module) - usedHeaderSize;
1307
1308 if(dvModuleGetNumClassTable(Module) == 0) {
1309 return;
1310 }
1311 *(dvModule *)(void *)(dataPtr) = dvModuleNull;
1312 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = size;
1313 dvModuleSetNumClassTable(Module, 0);
1314 dvSetFreeModuleClassTable(dvFreeModuleClassTable() + size);
1315 }
1316
1317 /*----------------------------------------------------------------------------------------
1318 Resize the Module.ClassTable array.
1319 ----------------------------------------------------------------------------------------*/
dvModuleResizeClassTables(dvModule Module,uint32 numClassTables)1320 void dvModuleResizeClassTables(
1321 dvModule Module,
1322 uint32 numClassTables)
1323 {
1324 uint32 freeSpace;
1325 uint32 elementSize = sizeof(dvClass);
1326 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1327 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1328 uint32 newSize = utMax(numClassTables + usedHeaderSize, freeHeaderSize);
1329 uint32 oldSize = utMax(dvModuleGetNumClassTable(Module) + usedHeaderSize, freeHeaderSize);
1330 dvClass *dataPtr;
1331
1332 if(numClassTables == 0) {
1333 if(dvModuleGetNumClassTable(Module) != 0) {
1334 dvModuleFreeClassTables(Module);
1335 }
1336 return;
1337 }
1338 if(dvModuleGetNumClassTable(Module) == 0) {
1339 dvModuleAllocClassTables(Module, numClassTables);
1340 return;
1341 }
1342 freeSpace = dvAllocatedModuleClassTable() - dvUsedModuleClassTable();
1343 if(freeSpace < newSize) {
1344 allocMoreModuleClassTables(newSize);
1345 }
1346 dataPtr = dvModuleGetClassTables(Module) - usedHeaderSize;
1347 memcpy((void *)(dvModules.ClassTable + dvUsedModuleClassTable()), dataPtr,
1348 elementSize*utMin(oldSize, newSize));
1349 if(newSize > oldSize) {
1350 {
1351 uint32 xModule;
1352 for(xModule = (uint32)(dvUsedModuleClassTable() + oldSize); xModule < dvUsedModuleClassTable() + oldSize + newSize - oldSize; xModule++) {
1353 dvModules.ClassTable[xModule] = dvClassNull;
1354 }
1355 }
1356 }
1357 *(dvModule *)(void *)dataPtr = dvModuleNull;
1358 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = oldSize;
1359 dvSetFreeModuleClassTable(dvFreeModuleClassTable() + oldSize);
1360 dvModuleSetClassTableIndex(Module, dvUsedModuleClassTable() + usedHeaderSize);
1361 dvModuleSetNumClassTable(Module, numClassTables);
1362 dvSetUsedModuleClassTable(dvUsedModuleClassTable() + newSize);
1363 }
1364
1365 /*----------------------------------------------------------------------------------------
1366 Compact the Module.EnumTable heap to free memory.
1367 ----------------------------------------------------------------------------------------*/
dvCompactModuleEnumTables(void)1368 void dvCompactModuleEnumTables(void)
1369 {
1370 uint32 elementSize = sizeof(dvEnum);
1371 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1372 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1373 dvEnum *toPtr = dvModules.EnumTable;
1374 dvEnum *fromPtr = toPtr;
1375 dvModule Module;
1376 uint32 size;
1377
1378 while(fromPtr < dvModules.EnumTable + dvUsedModuleEnumTable()) {
1379 Module = *(dvModule *)(void *)fromPtr;
1380 if(Module != dvModuleNull) {
1381 /* Need to move it to toPtr */
1382 size = utMax(dvModuleGetNumEnumTable(Module) + usedHeaderSize, freeHeaderSize);
1383 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
1384 dvModuleSetEnumTableIndex(Module, toPtr - dvModules.EnumTable + usedHeaderSize);
1385 toPtr += size;
1386 } else {
1387 /* Just skip it */
1388 size = *(uint32 *)(void *)(((dvModule *)(void *)fromPtr) + 1);
1389 }
1390 fromPtr += size;
1391 }
1392 dvSetUsedModuleEnumTable(toPtr - dvModules.EnumTable);
1393 dvSetFreeModuleEnumTable(0);
1394 }
1395
1396 /*----------------------------------------------------------------------------------------
1397 Allocate more memory for the Module.EnumTable heap.
1398 ----------------------------------------------------------------------------------------*/
allocMoreModuleEnumTables(uint32 spaceNeeded)1399 static void allocMoreModuleEnumTables(
1400 uint32 spaceNeeded)
1401 {
1402 uint32 freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();
1403
1404 if((dvFreeModuleEnumTable() << 2) > dvUsedModuleEnumTable()) {
1405 dvCompactModuleEnumTables();
1406 freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();
1407 }
1408 if(freeSpace < spaceNeeded) {
1409 dvSetAllocatedModuleEnumTable(dvAllocatedModuleEnumTable() + spaceNeeded - freeSpace +
1410 (dvAllocatedModuleEnumTable() >> 1));
1411 utResizeArray(dvModules.EnumTable, dvAllocatedModuleEnumTable());
1412 }
1413 }
1414
1415 /*----------------------------------------------------------------------------------------
1416 Allocate memory for a new Module.EnumTable array.
1417 ----------------------------------------------------------------------------------------*/
dvModuleAllocEnumTables(dvModule Module,uint32 numEnumTables)1418 void dvModuleAllocEnumTables(
1419 dvModule Module,
1420 uint32 numEnumTables)
1421 {
1422 uint32 freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();
1423 uint32 elementSize = sizeof(dvEnum);
1424 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1425 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1426 uint32 spaceNeeded = utMax(numEnumTables + usedHeaderSize, freeHeaderSize);
1427
1428 #if defined(DD_DEBUG)
1429 utAssert(dvModuleGetNumEnumTable(Module) == 0);
1430 #endif
1431 if(numEnumTables == 0) {
1432 return;
1433 }
1434 if(freeSpace < spaceNeeded) {
1435 allocMoreModuleEnumTables(spaceNeeded);
1436 }
1437 dvModuleSetEnumTableIndex(Module, dvUsedModuleEnumTable() + usedHeaderSize);
1438 dvModuleSetNumEnumTable(Module, numEnumTables);
1439 *(dvModule *)(void *)(dvModules.EnumTable + dvUsedModuleEnumTable()) = Module;
1440 {
1441 uint32 xModule;
1442 for(xModule = (uint32)(dvModuleGetEnumTableIndex(Module)); xModule < dvModuleGetEnumTableIndex(Module) + numEnumTables; xModule++) {
1443 dvModules.EnumTable[xModule] = dvEnumNull;
1444 }
1445 }
1446 dvSetUsedModuleEnumTable(dvUsedModuleEnumTable() + spaceNeeded);
1447 }
1448
1449 /*----------------------------------------------------------------------------------------
1450 Wrapper around dvModuleGetEnumTables for the database manager.
1451 ----------------------------------------------------------------------------------------*/
getModuleEnumTables(uint64 objectNumber,uint32 * numValues)1452 static void *getModuleEnumTables(
1453 uint64 objectNumber,
1454 uint32 *numValues)
1455 {
1456 dvModule Module = dvIndex2Module((uint32)objectNumber);
1457
1458 *numValues = dvModuleGetNumEnumTable(Module);
1459 return dvModuleGetEnumTables(Module);
1460 }
1461
1462 /*----------------------------------------------------------------------------------------
1463 Wrapper around dvModuleAllocEnumTables for the database manager.
1464 ----------------------------------------------------------------------------------------*/
allocModuleEnumTables(uint64 objectNumber,uint32 numValues)1465 static void *allocModuleEnumTables(
1466 uint64 objectNumber,
1467 uint32 numValues)
1468 {
1469 dvModule Module = dvIndex2Module((uint32)objectNumber);
1470
1471 dvModuleSetEnumTableIndex(Module, 0);
1472 dvModuleSetNumEnumTable(Module, 0);
1473 if(numValues == 0) {
1474 return NULL;
1475 }
1476 dvModuleAllocEnumTables(Module, numValues);
1477 return dvModuleGetEnumTables(Module);
1478 }
1479
1480 /*----------------------------------------------------------------------------------------
1481 Free memory used by the Module.EnumTable array.
1482 ----------------------------------------------------------------------------------------*/
dvModuleFreeEnumTables(dvModule Module)1483 void dvModuleFreeEnumTables(
1484 dvModule Module)
1485 {
1486 uint32 elementSize = sizeof(dvEnum);
1487 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1488 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1489 uint32 size = utMax(dvModuleGetNumEnumTable(Module) + usedHeaderSize, freeHeaderSize);
1490 dvEnum *dataPtr = dvModuleGetEnumTables(Module) - usedHeaderSize;
1491
1492 if(dvModuleGetNumEnumTable(Module) == 0) {
1493 return;
1494 }
1495 *(dvModule *)(void *)(dataPtr) = dvModuleNull;
1496 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = size;
1497 dvModuleSetNumEnumTable(Module, 0);
1498 dvSetFreeModuleEnumTable(dvFreeModuleEnumTable() + size);
1499 }
1500
1501 /*----------------------------------------------------------------------------------------
1502 Resize the Module.EnumTable array.
1503 ----------------------------------------------------------------------------------------*/
dvModuleResizeEnumTables(dvModule Module,uint32 numEnumTables)1504 void dvModuleResizeEnumTables(
1505 dvModule Module,
1506 uint32 numEnumTables)
1507 {
1508 uint32 freeSpace;
1509 uint32 elementSize = sizeof(dvEnum);
1510 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1511 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1512 uint32 newSize = utMax(numEnumTables + usedHeaderSize, freeHeaderSize);
1513 uint32 oldSize = utMax(dvModuleGetNumEnumTable(Module) + usedHeaderSize, freeHeaderSize);
1514 dvEnum *dataPtr;
1515
1516 if(numEnumTables == 0) {
1517 if(dvModuleGetNumEnumTable(Module) != 0) {
1518 dvModuleFreeEnumTables(Module);
1519 }
1520 return;
1521 }
1522 if(dvModuleGetNumEnumTable(Module) == 0) {
1523 dvModuleAllocEnumTables(Module, numEnumTables);
1524 return;
1525 }
1526 freeSpace = dvAllocatedModuleEnumTable() - dvUsedModuleEnumTable();
1527 if(freeSpace < newSize) {
1528 allocMoreModuleEnumTables(newSize);
1529 }
1530 dataPtr = dvModuleGetEnumTables(Module) - usedHeaderSize;
1531 memcpy((void *)(dvModules.EnumTable + dvUsedModuleEnumTable()), dataPtr,
1532 elementSize*utMin(oldSize, newSize));
1533 if(newSize > oldSize) {
1534 {
1535 uint32 xModule;
1536 for(xModule = (uint32)(dvUsedModuleEnumTable() + oldSize); xModule < dvUsedModuleEnumTable() + oldSize + newSize - oldSize; xModule++) {
1537 dvModules.EnumTable[xModule] = dvEnumNull;
1538 }
1539 }
1540 }
1541 *(dvModule *)(void *)dataPtr = dvModuleNull;
1542 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = oldSize;
1543 dvSetFreeModuleEnumTable(dvFreeModuleEnumTable() + oldSize);
1544 dvModuleSetEnumTableIndex(Module, dvUsedModuleEnumTable() + usedHeaderSize);
1545 dvModuleSetNumEnumTable(Module, numEnumTables);
1546 dvSetUsedModuleEnumTable(dvUsedModuleEnumTable() + newSize);
1547 }
1548
1549 /*----------------------------------------------------------------------------------------
1550 Compact the Module.TypedefTable heap to free memory.
1551 ----------------------------------------------------------------------------------------*/
dvCompactModuleTypedefTables(void)1552 void dvCompactModuleTypedefTables(void)
1553 {
1554 uint32 elementSize = sizeof(dvTypedef);
1555 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1556 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1557 dvTypedef *toPtr = dvModules.TypedefTable;
1558 dvTypedef *fromPtr = toPtr;
1559 dvModule Module;
1560 uint32 size;
1561
1562 while(fromPtr < dvModules.TypedefTable + dvUsedModuleTypedefTable()) {
1563 Module = *(dvModule *)(void *)fromPtr;
1564 if(Module != dvModuleNull) {
1565 /* Need to move it to toPtr */
1566 size = utMax(dvModuleGetNumTypedefTable(Module) + usedHeaderSize, freeHeaderSize);
1567 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
1568 dvModuleSetTypedefTableIndex(Module, toPtr - dvModules.TypedefTable + usedHeaderSize);
1569 toPtr += size;
1570 } else {
1571 /* Just skip it */
1572 size = *(uint32 *)(void *)(((dvModule *)(void *)fromPtr) + 1);
1573 }
1574 fromPtr += size;
1575 }
1576 dvSetUsedModuleTypedefTable(toPtr - dvModules.TypedefTable);
1577 dvSetFreeModuleTypedefTable(0);
1578 }
1579
1580 /*----------------------------------------------------------------------------------------
1581 Allocate more memory for the Module.TypedefTable heap.
1582 ----------------------------------------------------------------------------------------*/
allocMoreModuleTypedefTables(uint32 spaceNeeded)1583 static void allocMoreModuleTypedefTables(
1584 uint32 spaceNeeded)
1585 {
1586 uint32 freeSpace = dvAllocatedModuleTypedefTable() - dvUsedModuleTypedefTable();
1587
1588 if((dvFreeModuleTypedefTable() << 2) > dvUsedModuleTypedefTable()) {
1589 dvCompactModuleTypedefTables();
1590 freeSpace = dvAllocatedModuleTypedefTable() - dvUsedModuleTypedefTable();
1591 }
1592 if(freeSpace < spaceNeeded) {
1593 dvSetAllocatedModuleTypedefTable(dvAllocatedModuleTypedefTable() + spaceNeeded - freeSpace +
1594 (dvAllocatedModuleTypedefTable() >> 1));
1595 utResizeArray(dvModules.TypedefTable, dvAllocatedModuleTypedefTable());
1596 }
1597 }
1598
1599 /*----------------------------------------------------------------------------------------
1600 Allocate memory for a new Module.TypedefTable array.
1601 ----------------------------------------------------------------------------------------*/
dvModuleAllocTypedefTables(dvModule Module,uint32 numTypedefTables)1602 void dvModuleAllocTypedefTables(
1603 dvModule Module,
1604 uint32 numTypedefTables)
1605 {
1606 uint32 freeSpace = dvAllocatedModuleTypedefTable() - dvUsedModuleTypedefTable();
1607 uint32 elementSize = sizeof(dvTypedef);
1608 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1609 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1610 uint32 spaceNeeded = utMax(numTypedefTables + usedHeaderSize, freeHeaderSize);
1611
1612 #if defined(DD_DEBUG)
1613 utAssert(dvModuleGetNumTypedefTable(Module) == 0);
1614 #endif
1615 if(numTypedefTables == 0) {
1616 return;
1617 }
1618 if(freeSpace < spaceNeeded) {
1619 allocMoreModuleTypedefTables(spaceNeeded);
1620 }
1621 dvModuleSetTypedefTableIndex(Module, dvUsedModuleTypedefTable() + usedHeaderSize);
1622 dvModuleSetNumTypedefTable(Module, numTypedefTables);
1623 *(dvModule *)(void *)(dvModules.TypedefTable + dvUsedModuleTypedefTable()) = Module;
1624 {
1625 uint32 xModule;
1626 for(xModule = (uint32)(dvModuleGetTypedefTableIndex(Module)); xModule < dvModuleGetTypedefTableIndex(Module) + numTypedefTables; xModule++) {
1627 dvModules.TypedefTable[xModule] = dvTypedefNull;
1628 }
1629 }
1630 dvSetUsedModuleTypedefTable(dvUsedModuleTypedefTable() + spaceNeeded);
1631 }
1632
1633 /*----------------------------------------------------------------------------------------
1634 Wrapper around dvModuleGetTypedefTables for the database manager.
1635 ----------------------------------------------------------------------------------------*/
getModuleTypedefTables(uint64 objectNumber,uint32 * numValues)1636 static void *getModuleTypedefTables(
1637 uint64 objectNumber,
1638 uint32 *numValues)
1639 {
1640 dvModule Module = dvIndex2Module((uint32)objectNumber);
1641
1642 *numValues = dvModuleGetNumTypedefTable(Module);
1643 return dvModuleGetTypedefTables(Module);
1644 }
1645
1646 /*----------------------------------------------------------------------------------------
1647 Wrapper around dvModuleAllocTypedefTables for the database manager.
1648 ----------------------------------------------------------------------------------------*/
allocModuleTypedefTables(uint64 objectNumber,uint32 numValues)1649 static void *allocModuleTypedefTables(
1650 uint64 objectNumber,
1651 uint32 numValues)
1652 {
1653 dvModule Module = dvIndex2Module((uint32)objectNumber);
1654
1655 dvModuleSetTypedefTableIndex(Module, 0);
1656 dvModuleSetNumTypedefTable(Module, 0);
1657 if(numValues == 0) {
1658 return NULL;
1659 }
1660 dvModuleAllocTypedefTables(Module, numValues);
1661 return dvModuleGetTypedefTables(Module);
1662 }
1663
1664 /*----------------------------------------------------------------------------------------
1665 Free memory used by the Module.TypedefTable array.
1666 ----------------------------------------------------------------------------------------*/
dvModuleFreeTypedefTables(dvModule Module)1667 void dvModuleFreeTypedefTables(
1668 dvModule Module)
1669 {
1670 uint32 elementSize = sizeof(dvTypedef);
1671 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1672 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1673 uint32 size = utMax(dvModuleGetNumTypedefTable(Module) + usedHeaderSize, freeHeaderSize);
1674 dvTypedef *dataPtr = dvModuleGetTypedefTables(Module) - usedHeaderSize;
1675
1676 if(dvModuleGetNumTypedefTable(Module) == 0) {
1677 return;
1678 }
1679 *(dvModule *)(void *)(dataPtr) = dvModuleNull;
1680 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = size;
1681 dvModuleSetNumTypedefTable(Module, 0);
1682 dvSetFreeModuleTypedefTable(dvFreeModuleTypedefTable() + size);
1683 }
1684
1685 /*----------------------------------------------------------------------------------------
1686 Resize the Module.TypedefTable array.
1687 ----------------------------------------------------------------------------------------*/
dvModuleResizeTypedefTables(dvModule Module,uint32 numTypedefTables)1688 void dvModuleResizeTypedefTables(
1689 dvModule Module,
1690 uint32 numTypedefTables)
1691 {
1692 uint32 freeSpace;
1693 uint32 elementSize = sizeof(dvTypedef);
1694 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1695 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1696 uint32 newSize = utMax(numTypedefTables + usedHeaderSize, freeHeaderSize);
1697 uint32 oldSize = utMax(dvModuleGetNumTypedefTable(Module) + usedHeaderSize, freeHeaderSize);
1698 dvTypedef *dataPtr;
1699
1700 if(numTypedefTables == 0) {
1701 if(dvModuleGetNumTypedefTable(Module) != 0) {
1702 dvModuleFreeTypedefTables(Module);
1703 }
1704 return;
1705 }
1706 if(dvModuleGetNumTypedefTable(Module) == 0) {
1707 dvModuleAllocTypedefTables(Module, numTypedefTables);
1708 return;
1709 }
1710 freeSpace = dvAllocatedModuleTypedefTable() - dvUsedModuleTypedefTable();
1711 if(freeSpace < newSize) {
1712 allocMoreModuleTypedefTables(newSize);
1713 }
1714 dataPtr = dvModuleGetTypedefTables(Module) - usedHeaderSize;
1715 memcpy((void *)(dvModules.TypedefTable + dvUsedModuleTypedefTable()), dataPtr,
1716 elementSize*utMin(oldSize, newSize));
1717 if(newSize > oldSize) {
1718 {
1719 uint32 xModule;
1720 for(xModule = (uint32)(dvUsedModuleTypedefTable() + oldSize); xModule < dvUsedModuleTypedefTable() + oldSize + newSize - oldSize; xModule++) {
1721 dvModules.TypedefTable[xModule] = dvTypedefNull;
1722 }
1723 }
1724 }
1725 *(dvModule *)(void *)dataPtr = dvModuleNull;
1726 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = oldSize;
1727 dvSetFreeModuleTypedefTable(dvFreeModuleTypedefTable() + oldSize);
1728 dvModuleSetTypedefTableIndex(Module, dvUsedModuleTypedefTable() + usedHeaderSize);
1729 dvModuleSetNumTypedefTable(Module, numTypedefTables);
1730 dvSetUsedModuleTypedefTable(dvUsedModuleTypedefTable() + newSize);
1731 }
1732
1733 /*----------------------------------------------------------------------------------------
1734 Compact the Module.SchemaTable heap to free memory.
1735 ----------------------------------------------------------------------------------------*/
dvCompactModuleSchemaTables(void)1736 void dvCompactModuleSchemaTables(void)
1737 {
1738 uint32 elementSize = sizeof(dvSchema);
1739 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1740 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1741 dvSchema *toPtr = dvModules.SchemaTable;
1742 dvSchema *fromPtr = toPtr;
1743 dvModule Module;
1744 uint32 size;
1745
1746 while(fromPtr < dvModules.SchemaTable + dvUsedModuleSchemaTable()) {
1747 Module = *(dvModule *)(void *)fromPtr;
1748 if(Module != dvModuleNull) {
1749 /* Need to move it to toPtr */
1750 size = utMax(dvModuleGetNumSchemaTable(Module) + usedHeaderSize, freeHeaderSize);
1751 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
1752 dvModuleSetSchemaTableIndex(Module, toPtr - dvModules.SchemaTable + usedHeaderSize);
1753 toPtr += size;
1754 } else {
1755 /* Just skip it */
1756 size = *(uint32 *)(void *)(((dvModule *)(void *)fromPtr) + 1);
1757 }
1758 fromPtr += size;
1759 }
1760 dvSetUsedModuleSchemaTable(toPtr - dvModules.SchemaTable);
1761 dvSetFreeModuleSchemaTable(0);
1762 }
1763
1764 /*----------------------------------------------------------------------------------------
1765 Allocate more memory for the Module.SchemaTable heap.
1766 ----------------------------------------------------------------------------------------*/
allocMoreModuleSchemaTables(uint32 spaceNeeded)1767 static void allocMoreModuleSchemaTables(
1768 uint32 spaceNeeded)
1769 {
1770 uint32 freeSpace = dvAllocatedModuleSchemaTable() - dvUsedModuleSchemaTable();
1771
1772 if((dvFreeModuleSchemaTable() << 2) > dvUsedModuleSchemaTable()) {
1773 dvCompactModuleSchemaTables();
1774 freeSpace = dvAllocatedModuleSchemaTable() - dvUsedModuleSchemaTable();
1775 }
1776 if(freeSpace < spaceNeeded) {
1777 dvSetAllocatedModuleSchemaTable(dvAllocatedModuleSchemaTable() + spaceNeeded - freeSpace +
1778 (dvAllocatedModuleSchemaTable() >> 1));
1779 utResizeArray(dvModules.SchemaTable, dvAllocatedModuleSchemaTable());
1780 }
1781 }
1782
1783 /*----------------------------------------------------------------------------------------
1784 Allocate memory for a new Module.SchemaTable array.
1785 ----------------------------------------------------------------------------------------*/
dvModuleAllocSchemaTables(dvModule Module,uint32 numSchemaTables)1786 void dvModuleAllocSchemaTables(
1787 dvModule Module,
1788 uint32 numSchemaTables)
1789 {
1790 uint32 freeSpace = dvAllocatedModuleSchemaTable() - dvUsedModuleSchemaTable();
1791 uint32 elementSize = sizeof(dvSchema);
1792 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1793 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1794 uint32 spaceNeeded = utMax(numSchemaTables + usedHeaderSize, freeHeaderSize);
1795
1796 #if defined(DD_DEBUG)
1797 utAssert(dvModuleGetNumSchemaTable(Module) == 0);
1798 #endif
1799 if(numSchemaTables == 0) {
1800 return;
1801 }
1802 if(freeSpace < spaceNeeded) {
1803 allocMoreModuleSchemaTables(spaceNeeded);
1804 }
1805 dvModuleSetSchemaTableIndex(Module, dvUsedModuleSchemaTable() + usedHeaderSize);
1806 dvModuleSetNumSchemaTable(Module, numSchemaTables);
1807 *(dvModule *)(void *)(dvModules.SchemaTable + dvUsedModuleSchemaTable()) = Module;
1808 {
1809 uint32 xModule;
1810 for(xModule = (uint32)(dvModuleGetSchemaTableIndex(Module)); xModule < dvModuleGetSchemaTableIndex(Module) + numSchemaTables; xModule++) {
1811 dvModules.SchemaTable[xModule] = dvSchemaNull;
1812 }
1813 }
1814 dvSetUsedModuleSchemaTable(dvUsedModuleSchemaTable() + spaceNeeded);
1815 }
1816
1817 /*----------------------------------------------------------------------------------------
1818 Wrapper around dvModuleGetSchemaTables for the database manager.
1819 ----------------------------------------------------------------------------------------*/
getModuleSchemaTables(uint64 objectNumber,uint32 * numValues)1820 static void *getModuleSchemaTables(
1821 uint64 objectNumber,
1822 uint32 *numValues)
1823 {
1824 dvModule Module = dvIndex2Module((uint32)objectNumber);
1825
1826 *numValues = dvModuleGetNumSchemaTable(Module);
1827 return dvModuleGetSchemaTables(Module);
1828 }
1829
1830 /*----------------------------------------------------------------------------------------
1831 Wrapper around dvModuleAllocSchemaTables for the database manager.
1832 ----------------------------------------------------------------------------------------*/
allocModuleSchemaTables(uint64 objectNumber,uint32 numValues)1833 static void *allocModuleSchemaTables(
1834 uint64 objectNumber,
1835 uint32 numValues)
1836 {
1837 dvModule Module = dvIndex2Module((uint32)objectNumber);
1838
1839 dvModuleSetSchemaTableIndex(Module, 0);
1840 dvModuleSetNumSchemaTable(Module, 0);
1841 if(numValues == 0) {
1842 return NULL;
1843 }
1844 dvModuleAllocSchemaTables(Module, numValues);
1845 return dvModuleGetSchemaTables(Module);
1846 }
1847
1848 /*----------------------------------------------------------------------------------------
1849 Free memory used by the Module.SchemaTable array.
1850 ----------------------------------------------------------------------------------------*/
dvModuleFreeSchemaTables(dvModule Module)1851 void dvModuleFreeSchemaTables(
1852 dvModule Module)
1853 {
1854 uint32 elementSize = sizeof(dvSchema);
1855 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1856 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1857 uint32 size = utMax(dvModuleGetNumSchemaTable(Module) + usedHeaderSize, freeHeaderSize);
1858 dvSchema *dataPtr = dvModuleGetSchemaTables(Module) - usedHeaderSize;
1859
1860 if(dvModuleGetNumSchemaTable(Module) == 0) {
1861 return;
1862 }
1863 *(dvModule *)(void *)(dataPtr) = dvModuleNull;
1864 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = size;
1865 dvModuleSetNumSchemaTable(Module, 0);
1866 dvSetFreeModuleSchemaTable(dvFreeModuleSchemaTable() + size);
1867 }
1868
1869 /*----------------------------------------------------------------------------------------
1870 Resize the Module.SchemaTable array.
1871 ----------------------------------------------------------------------------------------*/
dvModuleResizeSchemaTables(dvModule Module,uint32 numSchemaTables)1872 void dvModuleResizeSchemaTables(
1873 dvModule Module,
1874 uint32 numSchemaTables)
1875 {
1876 uint32 freeSpace;
1877 uint32 elementSize = sizeof(dvSchema);
1878 uint32 usedHeaderSize = (sizeof(dvModule) + elementSize - 1)/elementSize;
1879 uint32 freeHeaderSize = (sizeof(dvModule) + sizeof(uint32) + elementSize - 1)/elementSize;
1880 uint32 newSize = utMax(numSchemaTables + usedHeaderSize, freeHeaderSize);
1881 uint32 oldSize = utMax(dvModuleGetNumSchemaTable(Module) + usedHeaderSize, freeHeaderSize);
1882 dvSchema *dataPtr;
1883
1884 if(numSchemaTables == 0) {
1885 if(dvModuleGetNumSchemaTable(Module) != 0) {
1886 dvModuleFreeSchemaTables(Module);
1887 }
1888 return;
1889 }
1890 if(dvModuleGetNumSchemaTable(Module) == 0) {
1891 dvModuleAllocSchemaTables(Module, numSchemaTables);
1892 return;
1893 }
1894 freeSpace = dvAllocatedModuleSchemaTable() - dvUsedModuleSchemaTable();
1895 if(freeSpace < newSize) {
1896 allocMoreModuleSchemaTables(newSize);
1897 }
1898 dataPtr = dvModuleGetSchemaTables(Module) - usedHeaderSize;
1899 memcpy((void *)(dvModules.SchemaTable + dvUsedModuleSchemaTable()), dataPtr,
1900 elementSize*utMin(oldSize, newSize));
1901 if(newSize > oldSize) {
1902 {
1903 uint32 xModule;
1904 for(xModule = (uint32)(dvUsedModuleSchemaTable() + oldSize); xModule < dvUsedModuleSchemaTable() + oldSize + newSize - oldSize; xModule++) {
1905 dvModules.SchemaTable[xModule] = dvSchemaNull;
1906 }
1907 }
1908 }
1909 *(dvModule *)(void *)dataPtr = dvModuleNull;
1910 *(uint32 *)(void *)(((dvModule *)(void *)dataPtr) + 1) = oldSize;
1911 dvSetFreeModuleSchemaTable(dvFreeModuleSchemaTable() + oldSize);
1912 dvModuleSetSchemaTableIndex(Module, dvUsedModuleSchemaTable() + usedHeaderSize);
1913 dvModuleSetNumSchemaTable(Module, numSchemaTables);
1914 dvSetUsedModuleSchemaTable(dvUsedModuleSchemaTable() + newSize);
1915 }
1916
1917 /*----------------------------------------------------------------------------------------
1918 Copy the properties of Module.
1919 ----------------------------------------------------------------------------------------*/
dvModuleCopyProps(dvModule oldModule,dvModule newModule)1920 void dvModuleCopyProps(
1921 dvModule oldModule,
1922 dvModule newModule)
1923 {
1924 dvModuleSetPrefixSym(newModule, dvModuleGetPrefixSym(oldModule));
1925 dvModuleSetPersistent(newModule, dvModulePersistent(oldModule));
1926 dvModuleSetUndoRedo(newModule, dvModuleUndoRedo(oldModule));
1927 dvModuleSetHasSparseData(newModule, dvModuleHasSparseData(oldModule));
1928 dvModuleSetNumFields(newModule, dvModuleGetNumFields(oldModule));
1929 dvModuleSetNumClasses(newModule, dvModuleGetNumClasses(oldModule));
1930 dvModuleSetNumEnums(newModule, dvModuleGetNumEnums(oldModule));
1931 }
1932
1933 /*----------------------------------------------------------------------------------------
1934 Return the integer equivalent for the bit fields in Module.
1935 ----------------------------------------------------------------------------------------*/
dvModuleGetBitfield(dvModule _Module)1936 uint32 dvModuleGetBitfield(
1937 dvModule _Module)
1938 {
1939 uint32 bitfield = 0;
1940 uint8 xLevel = 0;
1941
1942 bitfield |= dvModulePersistent(_Module) << xLevel++;
1943 bitfield |= dvModuleUndoRedo(_Module) << xLevel++;
1944 bitfield |= dvModuleHasSparseData(_Module) << xLevel++;
1945 return bitfield;
1946 }
1947
1948 /*----------------------------------------------------------------------------------------
1949 Set bit fields in Module using bitfield.
1950 ----------------------------------------------------------------------------------------*/
dvModuleSetBitfield(dvModule _Module,uint32 bitfield)1951 void dvModuleSetBitfield(
1952 dvModule _Module,
1953 uint32 bitfield)
1954 {
1955 dvModuleSetPersistent(_Module, bitfield & 1);
1956 bitfield >>= 1;
1957 dvModuleSetUndoRedo(_Module, bitfield & 1);
1958 bitfield >>= 1;
1959 dvModuleSetHasSparseData(_Module, bitfield & 1);
1960 bitfield >>= 1;
1961 }
1962
1963 static void addModuleClassToHashTable(dvModule Module, dvClass _Class);
1964 /*----------------------------------------------------------------------------------------
1965 Increase the size of the hash table.
1966 ----------------------------------------------------------------------------------------*/
resizeModuleClassHashTable(dvModule Module)1967 static void resizeModuleClassHashTable(
1968 dvModule Module)
1969 {
1970 dvClass _Class;
1971 dvClass *Classs;
1972 uint32 numClasss = dvModuleGetNumClassTable(Module) << 1;
1973
1974 if(numClasss == 0) {
1975 numClasss = 2;
1976 dvModuleAllocClassTables(Module, 2);
1977 } else {
1978 dvModuleResizeClassTables(Module, numClasss);
1979 }
1980 Classs = dvModuleGetClassTables(Module);
1981 /* Zero out the table */
1982 while(numClasss-- != 0) {
1983 *Classs++ = dvClassNull;
1984 }
1985 dvModuleSetNumClass(Module, 0);
1986 dvForeachModuleClass(Module, _Class) {
1987 if(dvClassGetSym(_Class) != utSymNull) {
1988 addModuleClassToHashTable(Module, _Class);
1989 }
1990 } dvEndModuleClass;
1991 }
1992
1993 /*----------------------------------------------------------------------------------------
1994 Add the Class to the Module. If the table is near full, build a new one twice
1995 as big, delete the old one, and return the new one.
1996 ----------------------------------------------------------------------------------------*/
addModuleClassToHashTable(dvModule Module,dvClass _Class)1997 static void addModuleClassToHashTable(
1998 dvModule Module,
1999 dvClass _Class)
2000 {
2001 dvClass nextClass;
2002 uint32 index;
2003
2004 if(dvModuleGetNumClass(Module) >= dvModuleGetNumClassTable(Module)) {
2005 resizeModuleClassHashTable(Module);
2006 return;
2007 }
2008 index = (dvModuleGetNumClassTable(Module) - 1) & utSymGetHashValue(dvClassGetSym(_Class));
2009 nextClass = dvModuleGetiClassTable(Module, index);
2010 dvClassSetNextTableModuleClass(_Class, nextClass);
2011 dvModuleSetiClassTable(Module, index, _Class);
2012 dvModuleSetNumClass(Module, dvModuleGetNumClass(Module) + 1);
2013 }
2014
2015 /*----------------------------------------------------------------------------------------
2016 Remove the Class from the hash table.
2017 ----------------------------------------------------------------------------------------*/
removeModuleClassFromHashTable(dvModule Module,dvClass _Class)2018 static void removeModuleClassFromHashTable(
2019 dvModule Module,
2020 dvClass _Class)
2021 {
2022 uint32 index = (dvModuleGetNumClassTable(Module) - 1) & utSymGetHashValue(dvClassGetSym(_Class));
2023 dvClass prevClass, nextClass;
2024
2025 nextClass = dvModuleGetiClassTable(Module, index);
2026 if(nextClass == _Class) {
2027 dvModuleSetiClassTable(Module, index, dvClassGetNextTableModuleClass(nextClass));
2028 } else {
2029 do {
2030 prevClass = nextClass;
2031 nextClass = dvClassGetNextTableModuleClass(nextClass);
2032 } while(nextClass != _Class);
2033 dvClassSetNextTableModuleClass(prevClass, dvClassGetNextTableModuleClass(_Class));
2034 }
2035 dvModuleSetNumClass(Module, dvModuleGetNumClass(Module) - 1);
2036 dvClassSetNextTableModuleClass(_Class, dvClassNull);
2037 }
2038
2039 /*----------------------------------------------------------------------------------------
2040 Find the Class from the Module and its hash key.
2041 ----------------------------------------------------------------------------------------*/
dvModuleFindClass(dvModule Module,utSym Sym)2042 dvClass dvModuleFindClass(
2043 dvModule Module,
2044 utSym Sym)
2045 {
2046 uint32 mask = dvModuleGetNumClassTable(Module) - 1;
2047 dvClass _Class;
2048
2049 if(mask + 1 != 0) {
2050 _Class = dvModuleGetiClassTable(Module, utSymGetHashValue(Sym) & mask);
2051 while(_Class != dvClassNull) {
2052 if(dvClassGetSym(_Class) == Sym) {
2053 return _Class;
2054 }
2055 _Class = dvClassGetNextTableModuleClass(_Class);
2056 }
2057 }
2058 return dvClassNull;
2059 }
2060
2061 /*----------------------------------------------------------------------------------------
2062 Find the Class from the Module and its name.
2063 ----------------------------------------------------------------------------------------*/
dvModuleRenameClass(dvModule Module,dvClass _Class,utSym sym)2064 void dvModuleRenameClass(
2065 dvModule Module,
2066 dvClass _Class,
2067 utSym sym)
2068 {
2069 if(dvClassGetSym(_Class) != utSymNull) {
2070 removeModuleClassFromHashTable(Module, _Class);
2071 }
2072 dvClassSetSym(_Class, sym);
2073 if(sym != utSymNull) {
2074 addModuleClassToHashTable(Module, _Class);
2075 }
2076 }
2077
2078 /*----------------------------------------------------------------------------------------
2079 Add the Class to the head of the list on the Module.
2080 ----------------------------------------------------------------------------------------*/
dvModuleInsertClass(dvModule Module,dvClass _Class)2081 void dvModuleInsertClass(
2082 dvModule Module,
2083 dvClass _Class)
2084 {
2085 #if defined(DD_DEBUG)
2086 if(Module == dvModuleNull) {
2087 utExit("Non-existent Module");
2088 }
2089 if(_Class == dvClassNull) {
2090 utExit("Non-existent Class");
2091 }
2092 if(dvClassGetModule(_Class) != dvModuleNull) {
2093 utExit("Attempting to add Class to Module twice");
2094 }
2095 #endif
2096 dvClassSetNextModuleClass(_Class, dvModuleGetFirstClass(Module));
2097 if(dvModuleGetFirstClass(Module) != dvClassNull) {
2098 dvClassSetPrevModuleClass(dvModuleGetFirstClass(Module), _Class);
2099 }
2100 dvModuleSetFirstClass(Module, _Class);
2101 dvClassSetPrevModuleClass(_Class, dvClassNull);
2102 if(dvModuleGetLastClass(Module) == dvClassNull) {
2103 dvModuleSetLastClass(Module, _Class);
2104 }
2105 dvClassSetModule(_Class, Module);
2106 if(dvClassGetSym(_Class) != utSymNull) {
2107 addModuleClassToHashTable(Module, _Class);
2108 }
2109 }
2110
2111 /*----------------------------------------------------------------------------------------
2112 Add the Class to the end of the list on the Module.
2113 ----------------------------------------------------------------------------------------*/
dvModuleAppendClass(dvModule Module,dvClass _Class)2114 void dvModuleAppendClass(
2115 dvModule Module,
2116 dvClass _Class)
2117 {
2118 #if defined(DD_DEBUG)
2119 if(Module == dvModuleNull) {
2120 utExit("Non-existent Module");
2121 }
2122 if(_Class == dvClassNull) {
2123 utExit("Non-existent Class");
2124 }
2125 if(dvClassGetModule(_Class) != dvModuleNull) {
2126 utExit("Attempting to add Class to Module twice");
2127 }
2128 #endif
2129 dvClassSetPrevModuleClass(_Class, dvModuleGetLastClass(Module));
2130 if(dvModuleGetLastClass(Module) != dvClassNull) {
2131 dvClassSetNextModuleClass(dvModuleGetLastClass(Module), _Class);
2132 }
2133 dvModuleSetLastClass(Module, _Class);
2134 dvClassSetNextModuleClass(_Class, dvClassNull);
2135 if(dvModuleGetFirstClass(Module) == dvClassNull) {
2136 dvModuleSetFirstClass(Module, _Class);
2137 }
2138 dvClassSetModule(_Class, Module);
2139 if(dvClassGetSym(_Class) != utSymNull) {
2140 addModuleClassToHashTable(Module, _Class);
2141 }
2142 }
2143
2144 /*----------------------------------------------------------------------------------------
2145 Insert the Class to the Module after the previous Class.
2146 ----------------------------------------------------------------------------------------*/
dvModuleInsertAfterClass(dvModule Module,dvClass prevClass,dvClass _Class)2147 void dvModuleInsertAfterClass(
2148 dvModule Module,
2149 dvClass prevClass,
2150 dvClass _Class)
2151 {
2152 dvClass nextClass = dvClassGetNextModuleClass(prevClass);
2153
2154 #if defined(DD_DEBUG)
2155 if(Module == dvModuleNull) {
2156 utExit("Non-existent Module");
2157 }
2158 if(_Class == dvClassNull) {
2159 utExit("Non-existent Class");
2160 }
2161 if(dvClassGetModule(_Class) != dvModuleNull) {
2162 utExit("Attempting to add Class to Module twice");
2163 }
2164 #endif
2165 dvClassSetNextModuleClass(_Class, nextClass);
2166 dvClassSetNextModuleClass(prevClass, _Class);
2167 dvClassSetPrevModuleClass(_Class, prevClass);
2168 if(nextClass != dvClassNull) {
2169 dvClassSetPrevModuleClass(nextClass, _Class);
2170 }
2171 if(dvModuleGetLastClass(Module) == prevClass) {
2172 dvModuleSetLastClass(Module, _Class);
2173 }
2174 dvClassSetModule(_Class, Module);
2175 if(dvClassGetSym(_Class) != utSymNull) {
2176 addModuleClassToHashTable(Module, _Class);
2177 }
2178 }
2179
2180 /*----------------------------------------------------------------------------------------
2181 Remove the Class from the Module.
2182 ----------------------------------------------------------------------------------------*/
dvModuleRemoveClass(dvModule Module,dvClass _Class)2183 void dvModuleRemoveClass(
2184 dvModule Module,
2185 dvClass _Class)
2186 {
2187 dvClass pClass, nClass;
2188
2189 #if defined(DD_DEBUG)
2190 if(_Class == dvClassNull) {
2191 utExit("Non-existent Class");
2192 }
2193 if(dvClassGetModule(_Class) != dvModuleNull && dvClassGetModule(_Class) != Module) {
2194 utExit("Delete Class from non-owning Module");
2195 }
2196 #endif
2197 nClass = dvClassGetNextModuleClass(_Class);
2198 pClass = dvClassGetPrevModuleClass(_Class);
2199 if(pClass != dvClassNull) {
2200 dvClassSetNextModuleClass(pClass, nClass);
2201 } else if(dvModuleGetFirstClass(Module) == _Class) {
2202 dvModuleSetFirstClass(Module, nClass);
2203 }
2204 if(nClass != dvClassNull) {
2205 dvClassSetPrevModuleClass(nClass, pClass);
2206 } else if(dvModuleGetLastClass(Module) == _Class) {
2207 dvModuleSetLastClass(Module, pClass);
2208 }
2209 dvClassSetNextModuleClass(_Class, dvClassNull);
2210 dvClassSetPrevModuleClass(_Class, dvClassNull);
2211 dvClassSetModule(_Class, dvModuleNull);
2212 if(dvClassGetSym(_Class) != utSymNull) {
2213 removeModuleClassFromHashTable(Module, _Class);
2214 }
2215 }
2216
2217 static void addModuleEnumToHashTable(dvModule Module, dvEnum _Enum);
2218 /*----------------------------------------------------------------------------------------
2219 Increase the size of the hash table.
2220 ----------------------------------------------------------------------------------------*/
resizeModuleEnumHashTable(dvModule Module)2221 static void resizeModuleEnumHashTable(
2222 dvModule Module)
2223 {
2224 dvEnum _Enum;
2225 dvEnum *Enums;
2226 uint32 numEnums = dvModuleGetNumEnumTable(Module) << 1;
2227
2228 if(numEnums == 0) {
2229 numEnums = 2;
2230 dvModuleAllocEnumTables(Module, 2);
2231 } else {
2232 dvModuleResizeEnumTables(Module, numEnums);
2233 }
2234 Enums = dvModuleGetEnumTables(Module);
2235 /* Zero out the table */
2236 while(numEnums-- != 0) {
2237 *Enums++ = dvEnumNull;
2238 }
2239 dvModuleSetNumEnum(Module, 0);
2240 dvForeachModuleEnum(Module, _Enum) {
2241 if(dvEnumGetSym(_Enum) != utSymNull) {
2242 addModuleEnumToHashTable(Module, _Enum);
2243 }
2244 } dvEndModuleEnum;
2245 }
2246
2247 /*----------------------------------------------------------------------------------------
2248 Add the Enum to the Module. If the table is near full, build a new one twice
2249 as big, delete the old one, and return the new one.
2250 ----------------------------------------------------------------------------------------*/
addModuleEnumToHashTable(dvModule Module,dvEnum _Enum)2251 static void addModuleEnumToHashTable(
2252 dvModule Module,
2253 dvEnum _Enum)
2254 {
2255 dvEnum nextEnum;
2256 uint32 index;
2257
2258 if(dvModuleGetNumEnum(Module) >= dvModuleGetNumEnumTable(Module)) {
2259 resizeModuleEnumHashTable(Module);
2260 return;
2261 }
2262 index = (dvModuleGetNumEnumTable(Module) - 1) & utSymGetHashValue(dvEnumGetSym(_Enum));
2263 nextEnum = dvModuleGetiEnumTable(Module, index);
2264 dvEnumSetNextTableModuleEnum(_Enum, nextEnum);
2265 dvModuleSetiEnumTable(Module, index, _Enum);
2266 dvModuleSetNumEnum(Module, dvModuleGetNumEnum(Module) + 1);
2267 }
2268
2269 /*----------------------------------------------------------------------------------------
2270 Remove the Enum from the hash table.
2271 ----------------------------------------------------------------------------------------*/
removeModuleEnumFromHashTable(dvModule Module,dvEnum _Enum)2272 static void removeModuleEnumFromHashTable(
2273 dvModule Module,
2274 dvEnum _Enum)
2275 {
2276 uint32 index = (dvModuleGetNumEnumTable(Module) - 1) & utSymGetHashValue(dvEnumGetSym(_Enum));
2277 dvEnum prevEnum, nextEnum;
2278
2279 nextEnum = dvModuleGetiEnumTable(Module, index);
2280 if(nextEnum == _Enum) {
2281 dvModuleSetiEnumTable(Module, index, dvEnumGetNextTableModuleEnum(nextEnum));
2282 } else {
2283 do {
2284 prevEnum = nextEnum;
2285 nextEnum = dvEnumGetNextTableModuleEnum(nextEnum);
2286 } while(nextEnum != _Enum);
2287 dvEnumSetNextTableModuleEnum(prevEnum, dvEnumGetNextTableModuleEnum(_Enum));
2288 }
2289 dvModuleSetNumEnum(Module, dvModuleGetNumEnum(Module) - 1);
2290 dvEnumSetNextTableModuleEnum(_Enum, dvEnumNull);
2291 }
2292
2293 /*----------------------------------------------------------------------------------------
2294 Find the Enum from the Module and its hash key.
2295 ----------------------------------------------------------------------------------------*/
dvModuleFindEnum(dvModule Module,utSym Sym)2296 dvEnum dvModuleFindEnum(
2297 dvModule Module,
2298 utSym Sym)
2299 {
2300 uint32 mask = dvModuleGetNumEnumTable(Module) - 1;
2301 dvEnum _Enum;
2302
2303 if(mask + 1 != 0) {
2304 _Enum = dvModuleGetiEnumTable(Module, utSymGetHashValue(Sym) & mask);
2305 while(_Enum != dvEnumNull) {
2306 if(dvEnumGetSym(_Enum) == Sym) {
2307 return _Enum;
2308 }
2309 _Enum = dvEnumGetNextTableModuleEnum(_Enum);
2310 }
2311 }
2312 return dvEnumNull;
2313 }
2314
2315 /*----------------------------------------------------------------------------------------
2316 Find the Enum from the Module and its name.
2317 ----------------------------------------------------------------------------------------*/
dvModuleRenameEnum(dvModule Module,dvEnum _Enum,utSym sym)2318 void dvModuleRenameEnum(
2319 dvModule Module,
2320 dvEnum _Enum,
2321 utSym sym)
2322 {
2323 if(dvEnumGetSym(_Enum) != utSymNull) {
2324 removeModuleEnumFromHashTable(Module, _Enum);
2325 }
2326 dvEnumSetSym(_Enum, sym);
2327 if(sym != utSymNull) {
2328 addModuleEnumToHashTable(Module, _Enum);
2329 }
2330 }
2331
2332 /*----------------------------------------------------------------------------------------
2333 Add the Enum to the head of the list on the Module.
2334 ----------------------------------------------------------------------------------------*/
dvModuleInsertEnum(dvModule Module,dvEnum _Enum)2335 void dvModuleInsertEnum(
2336 dvModule Module,
2337 dvEnum _Enum)
2338 {
2339 #if defined(DD_DEBUG)
2340 if(Module == dvModuleNull) {
2341 utExit("Non-existent Module");
2342 }
2343 if(_Enum == dvEnumNull) {
2344 utExit("Non-existent Enum");
2345 }
2346 if(dvEnumGetModule(_Enum) != dvModuleNull) {
2347 utExit("Attempting to add Enum to Module twice");
2348 }
2349 #endif
2350 dvEnumSetNextModuleEnum(_Enum, dvModuleGetFirstEnum(Module));
2351 if(dvModuleGetFirstEnum(Module) != dvEnumNull) {
2352 dvEnumSetPrevModuleEnum(dvModuleGetFirstEnum(Module), _Enum);
2353 }
2354 dvModuleSetFirstEnum(Module, _Enum);
2355 dvEnumSetPrevModuleEnum(_Enum, dvEnumNull);
2356 if(dvModuleGetLastEnum(Module) == dvEnumNull) {
2357 dvModuleSetLastEnum(Module, _Enum);
2358 }
2359 dvEnumSetModule(_Enum, Module);
2360 if(dvEnumGetSym(_Enum) != utSymNull) {
2361 addModuleEnumToHashTable(Module, _Enum);
2362 }
2363 }
2364
2365 /*----------------------------------------------------------------------------------------
2366 Add the Enum to the end of the list on the Module.
2367 ----------------------------------------------------------------------------------------*/
dvModuleAppendEnum(dvModule Module,dvEnum _Enum)2368 void dvModuleAppendEnum(
2369 dvModule Module,
2370 dvEnum _Enum)
2371 {
2372 #if defined(DD_DEBUG)
2373 if(Module == dvModuleNull) {
2374 utExit("Non-existent Module");
2375 }
2376 if(_Enum == dvEnumNull) {
2377 utExit("Non-existent Enum");
2378 }
2379 if(dvEnumGetModule(_Enum) != dvModuleNull) {
2380 utExit("Attempting to add Enum to Module twice");
2381 }
2382 #endif
2383 dvEnumSetPrevModuleEnum(_Enum, dvModuleGetLastEnum(Module));
2384 if(dvModuleGetLastEnum(Module) != dvEnumNull) {
2385 dvEnumSetNextModuleEnum(dvModuleGetLastEnum(Module), _Enum);
2386 }
2387 dvModuleSetLastEnum(Module, _Enum);
2388 dvEnumSetNextModuleEnum(_Enum, dvEnumNull);
2389 if(dvModuleGetFirstEnum(Module) == dvEnumNull) {
2390 dvModuleSetFirstEnum(Module, _Enum);
2391 }
2392 dvEnumSetModule(_Enum, Module);
2393 if(dvEnumGetSym(_Enum) != utSymNull) {
2394 addModuleEnumToHashTable(Module, _Enum);
2395 }
2396 }
2397
2398 /*----------------------------------------------------------------------------------------
2399 Insert the Enum to the Module after the previous Enum.
2400 ----------------------------------------------------------------------------------------*/
dvModuleInsertAfterEnum(dvModule Module,dvEnum prevEnum,dvEnum _Enum)2401 void dvModuleInsertAfterEnum(
2402 dvModule Module,
2403 dvEnum prevEnum,
2404 dvEnum _Enum)
2405 {
2406 dvEnum nextEnum = dvEnumGetNextModuleEnum(prevEnum);
2407
2408 #if defined(DD_DEBUG)
2409 if(Module == dvModuleNull) {
2410 utExit("Non-existent Module");
2411 }
2412 if(_Enum == dvEnumNull) {
2413 utExit("Non-existent Enum");
2414 }
2415 if(dvEnumGetModule(_Enum) != dvModuleNull) {
2416 utExit("Attempting to add Enum to Module twice");
2417 }
2418 #endif
2419 dvEnumSetNextModuleEnum(_Enum, nextEnum);
2420 dvEnumSetNextModuleEnum(prevEnum, _Enum);
2421 dvEnumSetPrevModuleEnum(_Enum, prevEnum);
2422 if(nextEnum != dvEnumNull) {
2423 dvEnumSetPrevModuleEnum(nextEnum, _Enum);
2424 }
2425 if(dvModuleGetLastEnum(Module) == prevEnum) {
2426 dvModuleSetLastEnum(Module, _Enum);
2427 }
2428 dvEnumSetModule(_Enum, Module);
2429 if(dvEnumGetSym(_Enum) != utSymNull) {
2430 addModuleEnumToHashTable(Module, _Enum);
2431 }
2432 }
2433
2434 /*----------------------------------------------------------------------------------------
2435 Remove the Enum from the Module.
2436 ----------------------------------------------------------------------------------------*/
dvModuleRemoveEnum(dvModule Module,dvEnum _Enum)2437 void dvModuleRemoveEnum(
2438 dvModule Module,
2439 dvEnum _Enum)
2440 {
2441 dvEnum pEnum, nEnum;
2442
2443 #if defined(DD_DEBUG)
2444 if(_Enum == dvEnumNull) {
2445 utExit("Non-existent Enum");
2446 }
2447 if(dvEnumGetModule(_Enum) != dvModuleNull && dvEnumGetModule(_Enum) != Module) {
2448 utExit("Delete Enum from non-owning Module");
2449 }
2450 #endif
2451 nEnum = dvEnumGetNextModuleEnum(_Enum);
2452 pEnum = dvEnumGetPrevModuleEnum(_Enum);
2453 if(pEnum != dvEnumNull) {
2454 dvEnumSetNextModuleEnum(pEnum, nEnum);
2455 } else if(dvModuleGetFirstEnum(Module) == _Enum) {
2456 dvModuleSetFirstEnum(Module, nEnum);
2457 }
2458 if(nEnum != dvEnumNull) {
2459 dvEnumSetPrevModuleEnum(nEnum, pEnum);
2460 } else if(dvModuleGetLastEnum(Module) == _Enum) {
2461 dvModuleSetLastEnum(Module, pEnum);
2462 }
2463 dvEnumSetNextModuleEnum(_Enum, dvEnumNull);
2464 dvEnumSetPrevModuleEnum(_Enum, dvEnumNull);
2465 dvEnumSetModule(_Enum, dvModuleNull);
2466 if(dvEnumGetSym(_Enum) != utSymNull) {
2467 removeModuleEnumFromHashTable(Module, _Enum);
2468 }
2469 }
2470
2471 static void addModuleTypedefToHashTable(dvModule Module, dvTypedef _Typedef);
2472 /*----------------------------------------------------------------------------------------
2473 Increase the size of the hash table.
2474 ----------------------------------------------------------------------------------------*/
resizeModuleTypedefHashTable(dvModule Module)2475 static void resizeModuleTypedefHashTable(
2476 dvModule Module)
2477 {
2478 dvTypedef _Typedef;
2479 dvTypedef *Typedefs;
2480 uint32 numTypedefs = dvModuleGetNumTypedefTable(Module) << 1;
2481
2482 if(numTypedefs == 0) {
2483 numTypedefs = 2;
2484 dvModuleAllocTypedefTables(Module, 2);
2485 } else {
2486 dvModuleResizeTypedefTables(Module, numTypedefs);
2487 }
2488 Typedefs = dvModuleGetTypedefTables(Module);
2489 /* Zero out the table */
2490 while(numTypedefs-- != 0) {
2491 *Typedefs++ = dvTypedefNull;
2492 }
2493 dvModuleSetNumTypedef(Module, 0);
2494 dvForeachModuleTypedef(Module, _Typedef) {
2495 if(dvTypedefGetSym(_Typedef) != utSymNull) {
2496 addModuleTypedefToHashTable(Module, _Typedef);
2497 }
2498 } dvEndModuleTypedef;
2499 }
2500
2501 /*----------------------------------------------------------------------------------------
2502 Add the Typedef to the Module. If the table is near full, build a new one twice
2503 as big, delete the old one, and return the new one.
2504 ----------------------------------------------------------------------------------------*/
addModuleTypedefToHashTable(dvModule Module,dvTypedef _Typedef)2505 static void addModuleTypedefToHashTable(
2506 dvModule Module,
2507 dvTypedef _Typedef)
2508 {
2509 dvTypedef nextTypedef;
2510 uint32 index;
2511
2512 if(dvModuleGetNumTypedef(Module) >= dvModuleGetNumTypedefTable(Module)) {
2513 resizeModuleTypedefHashTable(Module);
2514 return;
2515 }
2516 index = (dvModuleGetNumTypedefTable(Module) - 1) & utSymGetHashValue(dvTypedefGetSym(_Typedef));
2517 nextTypedef = dvModuleGetiTypedefTable(Module, index);
2518 dvTypedefSetNextTableModuleTypedef(_Typedef, nextTypedef);
2519 dvModuleSetiTypedefTable(Module, index, _Typedef);
2520 dvModuleSetNumTypedef(Module, dvModuleGetNumTypedef(Module) + 1);
2521 }
2522
2523 /*----------------------------------------------------------------------------------------
2524 Remove the Typedef from the hash table.
2525 ----------------------------------------------------------------------------------------*/
removeModuleTypedefFromHashTable(dvModule Module,dvTypedef _Typedef)2526 static void removeModuleTypedefFromHashTable(
2527 dvModule Module,
2528 dvTypedef _Typedef)
2529 {
2530 uint32 index = (dvModuleGetNumTypedefTable(Module) - 1) & utSymGetHashValue(dvTypedefGetSym(_Typedef));
2531 dvTypedef prevTypedef, nextTypedef;
2532
2533 nextTypedef = dvModuleGetiTypedefTable(Module, index);
2534 if(nextTypedef == _Typedef) {
2535 dvModuleSetiTypedefTable(Module, index, dvTypedefGetNextTableModuleTypedef(nextTypedef));
2536 } else {
2537 do {
2538 prevTypedef = nextTypedef;
2539 nextTypedef = dvTypedefGetNextTableModuleTypedef(nextTypedef);
2540 } while(nextTypedef != _Typedef);
2541 dvTypedefSetNextTableModuleTypedef(prevTypedef, dvTypedefGetNextTableModuleTypedef(_Typedef));
2542 }
2543 dvModuleSetNumTypedef(Module, dvModuleGetNumTypedef(Module) - 1);
2544 dvTypedefSetNextTableModuleTypedef(_Typedef, dvTypedefNull);
2545 }
2546
2547 /*----------------------------------------------------------------------------------------
2548 Find the Typedef from the Module and its hash key.
2549 ----------------------------------------------------------------------------------------*/
dvModuleFindTypedef(dvModule Module,utSym Sym)2550 dvTypedef dvModuleFindTypedef(
2551 dvModule Module,
2552 utSym Sym)
2553 {
2554 uint32 mask = dvModuleGetNumTypedefTable(Module) - 1;
2555 dvTypedef _Typedef;
2556
2557 if(mask + 1 != 0) {
2558 _Typedef = dvModuleGetiTypedefTable(Module, utSymGetHashValue(Sym) & mask);
2559 while(_Typedef != dvTypedefNull) {
2560 if(dvTypedefGetSym(_Typedef) == Sym) {
2561 return _Typedef;
2562 }
2563 _Typedef = dvTypedefGetNextTableModuleTypedef(_Typedef);
2564 }
2565 }
2566 return dvTypedefNull;
2567 }
2568
2569 /*----------------------------------------------------------------------------------------
2570 Find the Typedef from the Module and its name.
2571 ----------------------------------------------------------------------------------------*/
dvModuleRenameTypedef(dvModule Module,dvTypedef _Typedef,utSym sym)2572 void dvModuleRenameTypedef(
2573 dvModule Module,
2574 dvTypedef _Typedef,
2575 utSym sym)
2576 {
2577 if(dvTypedefGetSym(_Typedef) != utSymNull) {
2578 removeModuleTypedefFromHashTable(Module, _Typedef);
2579 }
2580 dvTypedefSetSym(_Typedef, sym);
2581 if(sym != utSymNull) {
2582 addModuleTypedefToHashTable(Module, _Typedef);
2583 }
2584 }
2585
2586 /*----------------------------------------------------------------------------------------
2587 Add the Typedef to the head of the list on the Module.
2588 ----------------------------------------------------------------------------------------*/
dvModuleInsertTypedef(dvModule Module,dvTypedef _Typedef)2589 void dvModuleInsertTypedef(
2590 dvModule Module,
2591 dvTypedef _Typedef)
2592 {
2593 #if defined(DD_DEBUG)
2594 if(Module == dvModuleNull) {
2595 utExit("Non-existent Module");
2596 }
2597 if(_Typedef == dvTypedefNull) {
2598 utExit("Non-existent Typedef");
2599 }
2600 if(dvTypedefGetModule(_Typedef) != dvModuleNull) {
2601 utExit("Attempting to add Typedef to Module twice");
2602 }
2603 #endif
2604 dvTypedefSetNextModuleTypedef(_Typedef, dvModuleGetFirstTypedef(Module));
2605 if(dvModuleGetFirstTypedef(Module) != dvTypedefNull) {
2606 dvTypedefSetPrevModuleTypedef(dvModuleGetFirstTypedef(Module), _Typedef);
2607 }
2608 dvModuleSetFirstTypedef(Module, _Typedef);
2609 dvTypedefSetPrevModuleTypedef(_Typedef, dvTypedefNull);
2610 if(dvModuleGetLastTypedef(Module) == dvTypedefNull) {
2611 dvModuleSetLastTypedef(Module, _Typedef);
2612 }
2613 dvTypedefSetModule(_Typedef, Module);
2614 if(dvTypedefGetSym(_Typedef) != utSymNull) {
2615 addModuleTypedefToHashTable(Module, _Typedef);
2616 }
2617 }
2618
2619 /*----------------------------------------------------------------------------------------
2620 Add the Typedef to the end of the list on the Module.
2621 ----------------------------------------------------------------------------------------*/
dvModuleAppendTypedef(dvModule Module,dvTypedef _Typedef)2622 void dvModuleAppendTypedef(
2623 dvModule Module,
2624 dvTypedef _Typedef)
2625 {
2626 #if defined(DD_DEBUG)
2627 if(Module == dvModuleNull) {
2628 utExit("Non-existent Module");
2629 }
2630 if(_Typedef == dvTypedefNull) {
2631 utExit("Non-existent Typedef");
2632 }
2633 if(dvTypedefGetModule(_Typedef) != dvModuleNull) {
2634 utExit("Attempting to add Typedef to Module twice");
2635 }
2636 #endif
2637 dvTypedefSetPrevModuleTypedef(_Typedef, dvModuleGetLastTypedef(Module));
2638 if(dvModuleGetLastTypedef(Module) != dvTypedefNull) {
2639 dvTypedefSetNextModuleTypedef(dvModuleGetLastTypedef(Module), _Typedef);
2640 }
2641 dvModuleSetLastTypedef(Module, _Typedef);
2642 dvTypedefSetNextModuleTypedef(_Typedef, dvTypedefNull);
2643 if(dvModuleGetFirstTypedef(Module) == dvTypedefNull) {
2644 dvModuleSetFirstTypedef(Module, _Typedef);
2645 }
2646 dvTypedefSetModule(_Typedef, Module);
2647 if(dvTypedefGetSym(_Typedef) != utSymNull) {
2648 addModuleTypedefToHashTable(Module, _Typedef);
2649 }
2650 }
2651
2652 /*----------------------------------------------------------------------------------------
2653 Insert the Typedef to the Module after the previous Typedef.
2654 ----------------------------------------------------------------------------------------*/
dvModuleInsertAfterTypedef(dvModule Module,dvTypedef prevTypedef,dvTypedef _Typedef)2655 void dvModuleInsertAfterTypedef(
2656 dvModule Module,
2657 dvTypedef prevTypedef,
2658 dvTypedef _Typedef)
2659 {
2660 dvTypedef nextTypedef = dvTypedefGetNextModuleTypedef(prevTypedef);
2661
2662 #if defined(DD_DEBUG)
2663 if(Module == dvModuleNull) {
2664 utExit("Non-existent Module");
2665 }
2666 if(_Typedef == dvTypedefNull) {
2667 utExit("Non-existent Typedef");
2668 }
2669 if(dvTypedefGetModule(_Typedef) != dvModuleNull) {
2670 utExit("Attempting to add Typedef to Module twice");
2671 }
2672 #endif
2673 dvTypedefSetNextModuleTypedef(_Typedef, nextTypedef);
2674 dvTypedefSetNextModuleTypedef(prevTypedef, _Typedef);
2675 dvTypedefSetPrevModuleTypedef(_Typedef, prevTypedef);
2676 if(nextTypedef != dvTypedefNull) {
2677 dvTypedefSetPrevModuleTypedef(nextTypedef, _Typedef);
2678 }
2679 if(dvModuleGetLastTypedef(Module) == prevTypedef) {
2680 dvModuleSetLastTypedef(Module, _Typedef);
2681 }
2682 dvTypedefSetModule(_Typedef, Module);
2683 if(dvTypedefGetSym(_Typedef) != utSymNull) {
2684 addModuleTypedefToHashTable(Module, _Typedef);
2685 }
2686 }
2687
2688 /*----------------------------------------------------------------------------------------
2689 Remove the Typedef from the Module.
2690 ----------------------------------------------------------------------------------------*/
dvModuleRemoveTypedef(dvModule Module,dvTypedef _Typedef)2691 void dvModuleRemoveTypedef(
2692 dvModule Module,
2693 dvTypedef _Typedef)
2694 {
2695 dvTypedef pTypedef, nTypedef;
2696
2697 #if defined(DD_DEBUG)
2698 if(_Typedef == dvTypedefNull) {
2699 utExit("Non-existent Typedef");
2700 }
2701 if(dvTypedefGetModule(_Typedef) != dvModuleNull && dvTypedefGetModule(_Typedef) != Module) {
2702 utExit("Delete Typedef from non-owning Module");
2703 }
2704 #endif
2705 nTypedef = dvTypedefGetNextModuleTypedef(_Typedef);
2706 pTypedef = dvTypedefGetPrevModuleTypedef(_Typedef);
2707 if(pTypedef != dvTypedefNull) {
2708 dvTypedefSetNextModuleTypedef(pTypedef, nTypedef);
2709 } else if(dvModuleGetFirstTypedef(Module) == _Typedef) {
2710 dvModuleSetFirstTypedef(Module, nTypedef);
2711 }
2712 if(nTypedef != dvTypedefNull) {
2713 dvTypedefSetPrevModuleTypedef(nTypedef, pTypedef);
2714 } else if(dvModuleGetLastTypedef(Module) == _Typedef) {
2715 dvModuleSetLastTypedef(Module, pTypedef);
2716 }
2717 dvTypedefSetNextModuleTypedef(_Typedef, dvTypedefNull);
2718 dvTypedefSetPrevModuleTypedef(_Typedef, dvTypedefNull);
2719 dvTypedefSetModule(_Typedef, dvModuleNull);
2720 if(dvTypedefGetSym(_Typedef) != utSymNull) {
2721 removeModuleTypedefFromHashTable(Module, _Typedef);
2722 }
2723 }
2724
2725 static void addModuleSchemaToHashTable(dvModule Module, dvSchema _Schema);
2726 /*----------------------------------------------------------------------------------------
2727 Increase the size of the hash table.
2728 ----------------------------------------------------------------------------------------*/
resizeModuleSchemaHashTable(dvModule Module)2729 static void resizeModuleSchemaHashTable(
2730 dvModule Module)
2731 {
2732 dvSchema _Schema;
2733 dvSchema *Schemas;
2734 uint32 numSchemas = dvModuleGetNumSchemaTable(Module) << 1;
2735
2736 if(numSchemas == 0) {
2737 numSchemas = 2;
2738 dvModuleAllocSchemaTables(Module, 2);
2739 } else {
2740 dvModuleResizeSchemaTables(Module, numSchemas);
2741 }
2742 Schemas = dvModuleGetSchemaTables(Module);
2743 /* Zero out the table */
2744 while(numSchemas-- != 0) {
2745 *Schemas++ = dvSchemaNull;
2746 }
2747 dvModuleSetNumSchema(Module, 0);
2748 dvForeachModuleSchema(Module, _Schema) {
2749 if(dvSchemaGetSym(_Schema) != utSymNull) {
2750 addModuleSchemaToHashTable(Module, _Schema);
2751 }
2752 } dvEndModuleSchema;
2753 }
2754
2755 /*----------------------------------------------------------------------------------------
2756 Add the Schema to the Module. If the table is near full, build a new one twice
2757 as big, delete the old one, and return the new one.
2758 ----------------------------------------------------------------------------------------*/
addModuleSchemaToHashTable(dvModule Module,dvSchema _Schema)2759 static void addModuleSchemaToHashTable(
2760 dvModule Module,
2761 dvSchema _Schema)
2762 {
2763 dvSchema nextSchema;
2764 uint32 index;
2765
2766 if(dvModuleGetNumSchema(Module) >= dvModuleGetNumSchemaTable(Module)) {
2767 resizeModuleSchemaHashTable(Module);
2768 return;
2769 }
2770 index = (dvModuleGetNumSchemaTable(Module) - 1) & utSymGetHashValue(dvSchemaGetSym(_Schema));
2771 nextSchema = dvModuleGetiSchemaTable(Module, index);
2772 dvSchemaSetNextTableModuleSchema(_Schema, nextSchema);
2773 dvModuleSetiSchemaTable(Module, index, _Schema);
2774 dvModuleSetNumSchema(Module, dvModuleGetNumSchema(Module) + 1);
2775 }
2776
2777 /*----------------------------------------------------------------------------------------
2778 Remove the Schema from the hash table.
2779 ----------------------------------------------------------------------------------------*/
removeModuleSchemaFromHashTable(dvModule Module,dvSchema _Schema)2780 static void removeModuleSchemaFromHashTable(
2781 dvModule Module,
2782 dvSchema _Schema)
2783 {
2784 uint32 index = (dvModuleGetNumSchemaTable(Module) - 1) & utSymGetHashValue(dvSchemaGetSym(_Schema));
2785 dvSchema prevSchema, nextSchema;
2786
2787 nextSchema = dvModuleGetiSchemaTable(Module, index);
2788 if(nextSchema == _Schema) {
2789 dvModuleSetiSchemaTable(Module, index, dvSchemaGetNextTableModuleSchema(nextSchema));
2790 } else {
2791 do {
2792 prevSchema = nextSchema;
2793 nextSchema = dvSchemaGetNextTableModuleSchema(nextSchema);
2794 } while(nextSchema != _Schema);
2795 dvSchemaSetNextTableModuleSchema(prevSchema, dvSchemaGetNextTableModuleSchema(_Schema));
2796 }
2797 dvModuleSetNumSchema(Module, dvModuleGetNumSchema(Module) - 1);
2798 dvSchemaSetNextTableModuleSchema(_Schema, dvSchemaNull);
2799 }
2800
2801 /*----------------------------------------------------------------------------------------
2802 Find the Schema from the Module and its hash key.
2803 ----------------------------------------------------------------------------------------*/
dvModuleFindSchema(dvModule Module,utSym Sym)2804 dvSchema dvModuleFindSchema(
2805 dvModule Module,
2806 utSym Sym)
2807 {
2808 uint32 mask = dvModuleGetNumSchemaTable(Module) - 1;
2809 dvSchema _Schema;
2810
2811 if(mask + 1 != 0) {
2812 _Schema = dvModuleGetiSchemaTable(Module, utSymGetHashValue(Sym) & mask);
2813 while(_Schema != dvSchemaNull) {
2814 if(dvSchemaGetSym(_Schema) == Sym) {
2815 return _Schema;
2816 }
2817 _Schema = dvSchemaGetNextTableModuleSchema(_Schema);
2818 }
2819 }
2820 return dvSchemaNull;
2821 }
2822
2823 /*----------------------------------------------------------------------------------------
2824 Find the Schema from the Module and its name.
2825 ----------------------------------------------------------------------------------------*/
dvModuleRenameSchema(dvModule Module,dvSchema _Schema,utSym sym)2826 void dvModuleRenameSchema(
2827 dvModule Module,
2828 dvSchema _Schema,
2829 utSym sym)
2830 {
2831 if(dvSchemaGetSym(_Schema) != utSymNull) {
2832 removeModuleSchemaFromHashTable(Module, _Schema);
2833 }
2834 dvSchemaSetSym(_Schema, sym);
2835 if(sym != utSymNull) {
2836 addModuleSchemaToHashTable(Module, _Schema);
2837 }
2838 }
2839
2840 /*----------------------------------------------------------------------------------------
2841 Add the Schema to the head of the list on the Module.
2842 ----------------------------------------------------------------------------------------*/
dvModuleInsertSchema(dvModule Module,dvSchema _Schema)2843 void dvModuleInsertSchema(
2844 dvModule Module,
2845 dvSchema _Schema)
2846 {
2847 #if defined(DD_DEBUG)
2848 if(Module == dvModuleNull) {
2849 utExit("Non-existent Module");
2850 }
2851 if(_Schema == dvSchemaNull) {
2852 utExit("Non-existent Schema");
2853 }
2854 if(dvSchemaGetModule(_Schema) != dvModuleNull) {
2855 utExit("Attempting to add Schema to Module twice");
2856 }
2857 #endif
2858 dvSchemaSetNextModuleSchema(_Schema, dvModuleGetFirstSchema(Module));
2859 if(dvModuleGetFirstSchema(Module) != dvSchemaNull) {
2860 dvSchemaSetPrevModuleSchema(dvModuleGetFirstSchema(Module), _Schema);
2861 }
2862 dvModuleSetFirstSchema(Module, _Schema);
2863 dvSchemaSetPrevModuleSchema(_Schema, dvSchemaNull);
2864 if(dvModuleGetLastSchema(Module) == dvSchemaNull) {
2865 dvModuleSetLastSchema(Module, _Schema);
2866 }
2867 dvSchemaSetModule(_Schema, Module);
2868 if(dvSchemaGetSym(_Schema) != utSymNull) {
2869 addModuleSchemaToHashTable(Module, _Schema);
2870 }
2871 }
2872
2873 /*----------------------------------------------------------------------------------------
2874 Add the Schema to the end of the list on the Module.
2875 ----------------------------------------------------------------------------------------*/
dvModuleAppendSchema(dvModule Module,dvSchema _Schema)2876 void dvModuleAppendSchema(
2877 dvModule Module,
2878 dvSchema _Schema)
2879 {
2880 #if defined(DD_DEBUG)
2881 if(Module == dvModuleNull) {
2882 utExit("Non-existent Module");
2883 }
2884 if(_Schema == dvSchemaNull) {
2885 utExit("Non-existent Schema");
2886 }
2887 if(dvSchemaGetModule(_Schema) != dvModuleNull) {
2888 utExit("Attempting to add Schema to Module twice");
2889 }
2890 #endif
2891 dvSchemaSetPrevModuleSchema(_Schema, dvModuleGetLastSchema(Module));
2892 if(dvModuleGetLastSchema(Module) != dvSchemaNull) {
2893 dvSchemaSetNextModuleSchema(dvModuleGetLastSchema(Module), _Schema);
2894 }
2895 dvModuleSetLastSchema(Module, _Schema);
2896 dvSchemaSetNextModuleSchema(_Schema, dvSchemaNull);
2897 if(dvModuleGetFirstSchema(Module) == dvSchemaNull) {
2898 dvModuleSetFirstSchema(Module, _Schema);
2899 }
2900 dvSchemaSetModule(_Schema, Module);
2901 if(dvSchemaGetSym(_Schema) != utSymNull) {
2902 addModuleSchemaToHashTable(Module, _Schema);
2903 }
2904 }
2905
2906 /*----------------------------------------------------------------------------------------
2907 Insert the Schema to the Module after the previous Schema.
2908 ----------------------------------------------------------------------------------------*/
dvModuleInsertAfterSchema(dvModule Module,dvSchema prevSchema,dvSchema _Schema)2909 void dvModuleInsertAfterSchema(
2910 dvModule Module,
2911 dvSchema prevSchema,
2912 dvSchema _Schema)
2913 {
2914 dvSchema nextSchema = dvSchemaGetNextModuleSchema(prevSchema);
2915
2916 #if defined(DD_DEBUG)
2917 if(Module == dvModuleNull) {
2918 utExit("Non-existent Module");
2919 }
2920 if(_Schema == dvSchemaNull) {
2921 utExit("Non-existent Schema");
2922 }
2923 if(dvSchemaGetModule(_Schema) != dvModuleNull) {
2924 utExit("Attempting to add Schema to Module twice");
2925 }
2926 #endif
2927 dvSchemaSetNextModuleSchema(_Schema, nextSchema);
2928 dvSchemaSetNextModuleSchema(prevSchema, _Schema);
2929 dvSchemaSetPrevModuleSchema(_Schema, prevSchema);
2930 if(nextSchema != dvSchemaNull) {
2931 dvSchemaSetPrevModuleSchema(nextSchema, _Schema);
2932 }
2933 if(dvModuleGetLastSchema(Module) == prevSchema) {
2934 dvModuleSetLastSchema(Module, _Schema);
2935 }
2936 dvSchemaSetModule(_Schema, Module);
2937 if(dvSchemaGetSym(_Schema) != utSymNull) {
2938 addModuleSchemaToHashTable(Module, _Schema);
2939 }
2940 }
2941
2942 /*----------------------------------------------------------------------------------------
2943 Remove the Schema from the Module.
2944 ----------------------------------------------------------------------------------------*/
dvModuleRemoveSchema(dvModule Module,dvSchema _Schema)2945 void dvModuleRemoveSchema(
2946 dvModule Module,
2947 dvSchema _Schema)
2948 {
2949 dvSchema pSchema, nSchema;
2950
2951 #if defined(DD_DEBUG)
2952 if(_Schema == dvSchemaNull) {
2953 utExit("Non-existent Schema");
2954 }
2955 if(dvSchemaGetModule(_Schema) != dvModuleNull && dvSchemaGetModule(_Schema) != Module) {
2956 utExit("Delete Schema from non-owning Module");
2957 }
2958 #endif
2959 nSchema = dvSchemaGetNextModuleSchema(_Schema);
2960 pSchema = dvSchemaGetPrevModuleSchema(_Schema);
2961 if(pSchema != dvSchemaNull) {
2962 dvSchemaSetNextModuleSchema(pSchema, nSchema);
2963 } else if(dvModuleGetFirstSchema(Module) == _Schema) {
2964 dvModuleSetFirstSchema(Module, nSchema);
2965 }
2966 if(nSchema != dvSchemaNull) {
2967 dvSchemaSetPrevModuleSchema(nSchema, pSchema);
2968 } else if(dvModuleGetLastSchema(Module) == _Schema) {
2969 dvModuleSetLastSchema(Module, pSchema);
2970 }
2971 dvSchemaSetNextModuleSchema(_Schema, dvSchemaNull);
2972 dvSchemaSetPrevModuleSchema(_Schema, dvSchemaNull);
2973 dvSchemaSetModule(_Schema, dvModuleNull);
2974 if(dvSchemaGetSym(_Schema) != utSymNull) {
2975 removeModuleSchemaFromHashTable(Module, _Schema);
2976 }
2977 }
2978
2979 /*----------------------------------------------------------------------------------------
2980 Add the ImportLink to the head of the list on the Module.
2981 ----------------------------------------------------------------------------------------*/
dvModuleInsertImportLink(dvModule Module,dvLink _Link)2982 void dvModuleInsertImportLink(
2983 dvModule Module,
2984 dvLink _Link)
2985 {
2986 #if defined(DD_DEBUG)
2987 if(Module == dvModuleNull) {
2988 utExit("Non-existent Module");
2989 }
2990 if(_Link == dvLinkNull) {
2991 utExit("Non-existent Link");
2992 }
2993 if(dvLinkGetImportModule(_Link) != dvModuleNull) {
2994 utExit("Attempting to add Link to Module twice");
2995 }
2996 #endif
2997 dvLinkSetNextModuleImportLink(_Link, dvModuleGetFirstImportLink(Module));
2998 dvModuleSetFirstImportLink(Module, _Link);
2999 if(dvModuleGetLastImportLink(Module) == dvLinkNull) {
3000 dvModuleSetLastImportLink(Module, _Link);
3001 }
3002 dvLinkSetImportModule(_Link, Module);
3003 }
3004
3005 /*----------------------------------------------------------------------------------------
3006 Add the ImportLink to the end of the list on the Module.
3007 ----------------------------------------------------------------------------------------*/
dvModuleAppendImportLink(dvModule Module,dvLink _Link)3008 void dvModuleAppendImportLink(
3009 dvModule Module,
3010 dvLink _Link)
3011 {
3012 #if defined(DD_DEBUG)
3013 if(Module == dvModuleNull) {
3014 utExit("Non-existent Module");
3015 }
3016 if(_Link == dvLinkNull) {
3017 utExit("Non-existent Link");
3018 }
3019 if(dvLinkGetImportModule(_Link) != dvModuleNull) {
3020 utExit("Attempting to add Link to Module twice");
3021 }
3022 #endif
3023 if(dvModuleGetLastImportLink(Module) != dvLinkNull) {
3024 dvLinkSetNextModuleImportLink(dvModuleGetLastImportLink(Module), _Link);
3025 } else {
3026 dvModuleSetFirstImportLink(Module, _Link);
3027 }
3028 dvModuleSetLastImportLink(Module, _Link);
3029 dvLinkSetNextModuleImportLink(_Link, dvLinkNull);
3030 dvLinkSetImportModule(_Link, Module);
3031 }
3032
3033 /*----------------------------------------------------------------------------------------
3034 Insert the ImportLink to the Module after the previous ImportLink.
3035 ----------------------------------------------------------------------------------------*/
dvModuleInsertAfterImportLink(dvModule Module,dvLink prevLink,dvLink _Link)3036 void dvModuleInsertAfterImportLink(
3037 dvModule Module,
3038 dvLink prevLink,
3039 dvLink _Link)
3040 {
3041 dvLink nextLink = dvLinkGetNextModuleImportLink(prevLink);
3042
3043 #if defined(DD_DEBUG)
3044 if(Module == dvModuleNull) {
3045 utExit("Non-existent Module");
3046 }
3047 if(_Link == dvLinkNull) {
3048 utExit("Non-existent Link");
3049 }
3050 if(dvLinkGetImportModule(_Link) != dvModuleNull) {
3051 utExit("Attempting to add Link to Module twice");
3052 }
3053 #endif
3054 dvLinkSetNextModuleImportLink(_Link, nextLink);
3055 dvLinkSetNextModuleImportLink(prevLink, _Link);
3056 if(dvModuleGetLastImportLink(Module) == prevLink) {
3057 dvModuleSetLastImportLink(Module, _Link);
3058 }
3059 dvLinkSetImportModule(_Link, Module);
3060 }
3061
3062 /*----------------------------------------------------------------------------------------
3063 Remove the ImportLink from the Module.
3064 ----------------------------------------------------------------------------------------*/
dvModuleRemoveImportLink(dvModule Module,dvLink _Link)3065 void dvModuleRemoveImportLink(
3066 dvModule Module,
3067 dvLink _Link)
3068 {
3069 dvLink pLink, nLink;
3070
3071 #if defined(DD_DEBUG)
3072 if(_Link == dvLinkNull) {
3073 utExit("Non-existent Link");
3074 }
3075 if(dvLinkGetImportModule(_Link) != dvModuleNull && dvLinkGetImportModule(_Link) != Module) {
3076 utExit("Delete Link from non-owning Module");
3077 }
3078 #endif
3079 pLink = dvLinkNull;
3080 for(nLink = dvModuleGetFirstImportLink(Module); nLink != dvLinkNull && nLink != _Link;
3081 nLink = dvLinkGetNextModuleImportLink(nLink)) {
3082 pLink = nLink;
3083 }
3084 if(pLink != dvLinkNull) {
3085 dvLinkSetNextModuleImportLink(pLink, dvLinkGetNextModuleImportLink(_Link));
3086 } else {
3087 dvModuleSetFirstImportLink(Module, dvLinkGetNextModuleImportLink(_Link));
3088 }
3089 dvLinkSetNextModuleImportLink(_Link, dvLinkNull);
3090 if(dvModuleGetLastImportLink(Module) == _Link) {
3091 dvModuleSetLastImportLink(Module, pLink);
3092 }
3093 dvLinkSetImportModule(_Link, dvModuleNull);
3094 }
3095
3096 /*----------------------------------------------------------------------------------------
3097 Add the ExportLink to the head of the list on the Module.
3098 ----------------------------------------------------------------------------------------*/
dvModuleInsertExportLink(dvModule Module,dvLink _Link)3099 void dvModuleInsertExportLink(
3100 dvModule Module,
3101 dvLink _Link)
3102 {
3103 #if defined(DD_DEBUG)
3104 if(Module == dvModuleNull) {
3105 utExit("Non-existent Module");
3106 }
3107 if(_Link == dvLinkNull) {
3108 utExit("Non-existent Link");
3109 }
3110 if(dvLinkGetExportModule(_Link) != dvModuleNull) {
3111 utExit("Attempting to add Link to Module twice");
3112 }
3113 #endif
3114 dvLinkSetNextModuleExportLink(_Link, dvModuleGetFirstExportLink(Module));
3115 dvModuleSetFirstExportLink(Module, _Link);
3116 if(dvModuleGetLastExportLink(Module) == dvLinkNull) {
3117 dvModuleSetLastExportLink(Module, _Link);
3118 }
3119 dvLinkSetExportModule(_Link, Module);
3120 }
3121
3122 /*----------------------------------------------------------------------------------------
3123 Add the ExportLink to the end of the list on the Module.
3124 ----------------------------------------------------------------------------------------*/
dvModuleAppendExportLink(dvModule Module,dvLink _Link)3125 void dvModuleAppendExportLink(
3126 dvModule Module,
3127 dvLink _Link)
3128 {
3129 #if defined(DD_DEBUG)
3130 if(Module == dvModuleNull) {
3131 utExit("Non-existent Module");
3132 }
3133 if(_Link == dvLinkNull) {
3134 utExit("Non-existent Link");
3135 }
3136 if(dvLinkGetExportModule(_Link) != dvModuleNull) {
3137 utExit("Attempting to add Link to Module twice");
3138 }
3139 #endif
3140 if(dvModuleGetLastExportLink(Module) != dvLinkNull) {
3141 dvLinkSetNextModuleExportLink(dvModuleGetLastExportLink(Module), _Link);
3142 } else {
3143 dvModuleSetFirstExportLink(Module, _Link);
3144 }
3145 dvModuleSetLastExportLink(Module, _Link);
3146 dvLinkSetNextModuleExportLink(_Link, dvLinkNull);
3147 dvLinkSetExportModule(_Link, Module);
3148 }
3149
3150 /*----------------------------------------------------------------------------------------
3151 Insert the ExportLink to the Module after the previous ExportLink.
3152 ----------------------------------------------------------------------------------------*/
dvModuleInsertAfterExportLink(dvModule Module,dvLink prevLink,dvLink _Link)3153 void dvModuleInsertAfterExportLink(
3154 dvModule Module,
3155 dvLink prevLink,
3156 dvLink _Link)
3157 {
3158 dvLink nextLink = dvLinkGetNextModuleExportLink(prevLink);
3159
3160 #if defined(DD_DEBUG)
3161 if(Module == dvModuleNull) {
3162 utExit("Non-existent Module");
3163 }
3164 if(_Link == dvLinkNull) {
3165 utExit("Non-existent Link");
3166 }
3167 if(dvLinkGetExportModule(_Link) != dvModuleNull) {
3168 utExit("Attempting to add Link to Module twice");
3169 }
3170 #endif
3171 dvLinkSetNextModuleExportLink(_Link, nextLink);
3172 dvLinkSetNextModuleExportLink(prevLink, _Link);
3173 if(dvModuleGetLastExportLink(Module) == prevLink) {
3174 dvModuleSetLastExportLink(Module, _Link);
3175 }
3176 dvLinkSetExportModule(_Link, Module);
3177 }
3178
3179 /*----------------------------------------------------------------------------------------
3180 Remove the ExportLink from the Module.
3181 ----------------------------------------------------------------------------------------*/
dvModuleRemoveExportLink(dvModule Module,dvLink _Link)3182 void dvModuleRemoveExportLink(
3183 dvModule Module,
3184 dvLink _Link)
3185 {
3186 dvLink pLink, nLink;
3187
3188 #if defined(DD_DEBUG)
3189 if(_Link == dvLinkNull) {
3190 utExit("Non-existent Link");
3191 }
3192 if(dvLinkGetExportModule(_Link) != dvModuleNull && dvLinkGetExportModule(_Link) != Module) {
3193 utExit("Delete Link from non-owning Module");
3194 }
3195 #endif
3196 pLink = dvLinkNull;
3197 for(nLink = dvModuleGetFirstExportLink(Module); nLink != dvLinkNull && nLink != _Link;
3198 nLink = dvLinkGetNextModuleExportLink(nLink)) {
3199 pLink = nLink;
3200 }
3201 if(pLink != dvLinkNull) {
3202 dvLinkSetNextModuleExportLink(pLink, dvLinkGetNextModuleExportLink(_Link));
3203 } else {
3204 dvModuleSetFirstExportLink(Module, dvLinkGetNextModuleExportLink(_Link));
3205 }
3206 dvLinkSetNextModuleExportLink(_Link, dvLinkNull);
3207 if(dvModuleGetLastExportLink(Module) == _Link) {
3208 dvModuleSetLastExportLink(Module, pLink);
3209 }
3210 dvLinkSetExportModule(_Link, dvModuleNull);
3211 }
3212
3213 #if defined(DD_DEBUG)
3214 /*----------------------------------------------------------------------------------------
3215 Write out all the fields of an object.
3216 ----------------------------------------------------------------------------------------*/
dvShowModule(dvModule Module)3217 void dvShowModule(
3218 dvModule Module)
3219 {
3220 utDatabaseShowObject("dv", "Module", dvModule2Index(Module));
3221 }
3222 #endif
3223
3224 /*----------------------------------------------------------------------------------------
3225 Default constructor wrapper for the database manager.
3226 ----------------------------------------------------------------------------------------*/
allocLink(void)3227 static uint64 allocLink(void)
3228 {
3229 dvLink Link = dvLinkAlloc();
3230
3231 return dvLink2Index(Link);
3232 }
3233
3234 /*----------------------------------------------------------------------------------------
3235 Allocate the field arrays of Link.
3236 ----------------------------------------------------------------------------------------*/
allocLinks(void)3237 static void allocLinks(void)
3238 {
3239 dvSetAllocatedLink(2);
3240 dvSetUsedLink(0);
3241 dvLinks.ImportModule = utNewA(dvModule, (dvAllocatedLink()));
3242 dvLinks.NextModuleImportLink = utNewA(dvLink, (dvAllocatedLink()));
3243 dvLinks.ExportModule = utNewA(dvModule, (dvAllocatedLink()));
3244 dvLinks.NextModuleExportLink = utNewA(dvLink, (dvAllocatedLink()));
3245 }
3246
3247 /*----------------------------------------------------------------------------------------
3248 Realloc the arrays of properties for class Link.
3249 ----------------------------------------------------------------------------------------*/
reallocLinks(uint32 newSize)3250 static void reallocLinks(
3251 uint32 newSize)
3252 {
3253 utResizeArray(dvLinks.ImportModule, (newSize));
3254 utResizeArray(dvLinks.NextModuleImportLink, (newSize));
3255 utResizeArray(dvLinks.ExportModule, (newSize));
3256 utResizeArray(dvLinks.NextModuleExportLink, (newSize));
3257 dvSetAllocatedLink(newSize);
3258 }
3259
3260 /*----------------------------------------------------------------------------------------
3261 Allocate more Links.
3262 ----------------------------------------------------------------------------------------*/
dvLinkAllocMore(void)3263 void dvLinkAllocMore(void)
3264 {
3265 reallocLinks((uint32)(dvAllocatedLink() + (dvAllocatedLink() >> 1)));
3266 }
3267
3268 /*----------------------------------------------------------------------------------------
3269 Copy the properties of Link.
3270 ----------------------------------------------------------------------------------------*/
dvLinkCopyProps(dvLink oldLink,dvLink newLink)3271 void dvLinkCopyProps(
3272 dvLink oldLink,
3273 dvLink newLink)
3274 {
3275 }
3276
3277 #if defined(DD_DEBUG)
3278 /*----------------------------------------------------------------------------------------
3279 Write out all the fields of an object.
3280 ----------------------------------------------------------------------------------------*/
dvShowLink(dvLink Link)3281 void dvShowLink(
3282 dvLink Link)
3283 {
3284 utDatabaseShowObject("dv", "Link", dvLink2Index(Link));
3285 }
3286 #endif
3287
3288 /*----------------------------------------------------------------------------------------
3289 Default constructor wrapper for the database manager.
3290 ----------------------------------------------------------------------------------------*/
allocSchema(void)3291 static uint64 allocSchema(void)
3292 {
3293 dvSchema Schema = dvSchemaAlloc();
3294
3295 return dvSchema2Index(Schema);
3296 }
3297
3298 /*----------------------------------------------------------------------------------------
3299 Allocate the field arrays of Schema.
3300 ----------------------------------------------------------------------------------------*/
allocSchemas(void)3301 static void allocSchemas(void)
3302 {
3303 dvSetAllocatedSchema(2);
3304 dvSetUsedSchema(0);
3305 dvSchemas.Sym = utNewA(utSym, (dvAllocatedSchema()));
3306 dvSchemas.Module = utNewA(dvModule, (dvAllocatedSchema()));
3307 dvSchemas.NextModuleSchema = utNewA(dvSchema, (dvAllocatedSchema()));
3308 dvSchemas.PrevModuleSchema = utNewA(dvSchema, (dvAllocatedSchema()));
3309 dvSchemas.NextTableModuleSchema = utNewA(dvSchema, (dvAllocatedSchema()));
3310 dvSchemas.FirstRelationship = utNewA(dvRelationship, (dvAllocatedSchema()));
3311 dvSchemas.LastRelationship = utNewA(dvRelationship, (dvAllocatedSchema()));
3312 }
3313
3314 /*----------------------------------------------------------------------------------------
3315 Realloc the arrays of properties for class Schema.
3316 ----------------------------------------------------------------------------------------*/
reallocSchemas(uint32 newSize)3317 static void reallocSchemas(
3318 uint32 newSize)
3319 {
3320 utResizeArray(dvSchemas.Sym, (newSize));
3321 utResizeArray(dvSchemas.Module, (newSize));
3322 utResizeArray(dvSchemas.NextModuleSchema, (newSize));
3323 utResizeArray(dvSchemas.PrevModuleSchema, (newSize));
3324 utResizeArray(dvSchemas.NextTableModuleSchema, (newSize));
3325 utResizeArray(dvSchemas.FirstRelationship, (newSize));
3326 utResizeArray(dvSchemas.LastRelationship, (newSize));
3327 dvSetAllocatedSchema(newSize);
3328 }
3329
3330 /*----------------------------------------------------------------------------------------
3331 Allocate more Schemas.
3332 ----------------------------------------------------------------------------------------*/
dvSchemaAllocMore(void)3333 void dvSchemaAllocMore(void)
3334 {
3335 reallocSchemas((uint32)(dvAllocatedSchema() + (dvAllocatedSchema() >> 1)));
3336 }
3337
3338 /*----------------------------------------------------------------------------------------
3339 Copy the properties of Schema.
3340 ----------------------------------------------------------------------------------------*/
dvSchemaCopyProps(dvSchema oldSchema,dvSchema newSchema)3341 void dvSchemaCopyProps(
3342 dvSchema oldSchema,
3343 dvSchema newSchema)
3344 {
3345 }
3346
3347 /*----------------------------------------------------------------------------------------
3348 Add the Relationship to the head of the list on the Schema.
3349 ----------------------------------------------------------------------------------------*/
dvSchemaInsertRelationship(dvSchema Schema,dvRelationship _Relationship)3350 void dvSchemaInsertRelationship(
3351 dvSchema Schema,
3352 dvRelationship _Relationship)
3353 {
3354 #if defined(DD_DEBUG)
3355 if(Schema == dvSchemaNull) {
3356 utExit("Non-existent Schema");
3357 }
3358 if(_Relationship == dvRelationshipNull) {
3359 utExit("Non-existent Relationship");
3360 }
3361 if(dvRelationshipGetSchema(_Relationship) != dvSchemaNull) {
3362 utExit("Attempting to add Relationship to Schema twice");
3363 }
3364 #endif
3365 dvRelationshipSetNextSchemaRelationship(_Relationship, dvSchemaGetFirstRelationship(Schema));
3366 dvSchemaSetFirstRelationship(Schema, _Relationship);
3367 if(dvSchemaGetLastRelationship(Schema) == dvRelationshipNull) {
3368 dvSchemaSetLastRelationship(Schema, _Relationship);
3369 }
3370 dvRelationshipSetSchema(_Relationship, Schema);
3371 }
3372
3373 /*----------------------------------------------------------------------------------------
3374 Add the Relationship to the end of the list on the Schema.
3375 ----------------------------------------------------------------------------------------*/
dvSchemaAppendRelationship(dvSchema Schema,dvRelationship _Relationship)3376 void dvSchemaAppendRelationship(
3377 dvSchema Schema,
3378 dvRelationship _Relationship)
3379 {
3380 #if defined(DD_DEBUG)
3381 if(Schema == dvSchemaNull) {
3382 utExit("Non-existent Schema");
3383 }
3384 if(_Relationship == dvRelationshipNull) {
3385 utExit("Non-existent Relationship");
3386 }
3387 if(dvRelationshipGetSchema(_Relationship) != dvSchemaNull) {
3388 utExit("Attempting to add Relationship to Schema twice");
3389 }
3390 #endif
3391 if(dvSchemaGetLastRelationship(Schema) != dvRelationshipNull) {
3392 dvRelationshipSetNextSchemaRelationship(dvSchemaGetLastRelationship(Schema), _Relationship);
3393 } else {
3394 dvSchemaSetFirstRelationship(Schema, _Relationship);
3395 }
3396 dvSchemaSetLastRelationship(Schema, _Relationship);
3397 dvRelationshipSetNextSchemaRelationship(_Relationship, dvRelationshipNull);
3398 dvRelationshipSetSchema(_Relationship, Schema);
3399 }
3400
3401 /*----------------------------------------------------------------------------------------
3402 Insert the Relationship to the Schema after the previous Relationship.
3403 ----------------------------------------------------------------------------------------*/
dvSchemaInsertAfterRelationship(dvSchema Schema,dvRelationship prevRelationship,dvRelationship _Relationship)3404 void dvSchemaInsertAfterRelationship(
3405 dvSchema Schema,
3406 dvRelationship prevRelationship,
3407 dvRelationship _Relationship)
3408 {
3409 dvRelationship nextRelationship = dvRelationshipGetNextSchemaRelationship(prevRelationship);
3410
3411 #if defined(DD_DEBUG)
3412 if(Schema == dvSchemaNull) {
3413 utExit("Non-existent Schema");
3414 }
3415 if(_Relationship == dvRelationshipNull) {
3416 utExit("Non-existent Relationship");
3417 }
3418 if(dvRelationshipGetSchema(_Relationship) != dvSchemaNull) {
3419 utExit("Attempting to add Relationship to Schema twice");
3420 }
3421 #endif
3422 dvRelationshipSetNextSchemaRelationship(_Relationship, nextRelationship);
3423 dvRelationshipSetNextSchemaRelationship(prevRelationship, _Relationship);
3424 if(dvSchemaGetLastRelationship(Schema) == prevRelationship) {
3425 dvSchemaSetLastRelationship(Schema, _Relationship);
3426 }
3427 dvRelationshipSetSchema(_Relationship, Schema);
3428 }
3429
3430 /*----------------------------------------------------------------------------------------
3431 Remove the Relationship from the Schema.
3432 ----------------------------------------------------------------------------------------*/
dvSchemaRemoveRelationship(dvSchema Schema,dvRelationship _Relationship)3433 void dvSchemaRemoveRelationship(
3434 dvSchema Schema,
3435 dvRelationship _Relationship)
3436 {
3437 dvRelationship pRelationship, nRelationship;
3438
3439 #if defined(DD_DEBUG)
3440 if(_Relationship == dvRelationshipNull) {
3441 utExit("Non-existent Relationship");
3442 }
3443 if(dvRelationshipGetSchema(_Relationship) != dvSchemaNull && dvRelationshipGetSchema(_Relationship) != Schema) {
3444 utExit("Delete Relationship from non-owning Schema");
3445 }
3446 #endif
3447 pRelationship = dvRelationshipNull;
3448 for(nRelationship = dvSchemaGetFirstRelationship(Schema); nRelationship != dvRelationshipNull && nRelationship != _Relationship;
3449 nRelationship = dvRelationshipGetNextSchemaRelationship(nRelationship)) {
3450 pRelationship = nRelationship;
3451 }
3452 if(pRelationship != dvRelationshipNull) {
3453 dvRelationshipSetNextSchemaRelationship(pRelationship, dvRelationshipGetNextSchemaRelationship(_Relationship));
3454 } else {
3455 dvSchemaSetFirstRelationship(Schema, dvRelationshipGetNextSchemaRelationship(_Relationship));
3456 }
3457 dvRelationshipSetNextSchemaRelationship(_Relationship, dvRelationshipNull);
3458 if(dvSchemaGetLastRelationship(Schema) == _Relationship) {
3459 dvSchemaSetLastRelationship(Schema, pRelationship);
3460 }
3461 dvRelationshipSetSchema(_Relationship, dvSchemaNull);
3462 }
3463
3464 #if defined(DD_DEBUG)
3465 /*----------------------------------------------------------------------------------------
3466 Write out all the fields of an object.
3467 ----------------------------------------------------------------------------------------*/
dvShowSchema(dvSchema Schema)3468 void dvShowSchema(
3469 dvSchema Schema)
3470 {
3471 utDatabaseShowObject("dv", "Schema", dvSchema2Index(Schema));
3472 }
3473 #endif
3474
3475 /*----------------------------------------------------------------------------------------
3476 Default constructor wrapper for the database manager.
3477 ----------------------------------------------------------------------------------------*/
allocEnum(void)3478 static uint64 allocEnum(void)
3479 {
3480 dvEnum Enum = dvEnumAlloc();
3481
3482 return dvEnum2Index(Enum);
3483 }
3484
3485 /*----------------------------------------------------------------------------------------
3486 Allocate the field arrays of Enum.
3487 ----------------------------------------------------------------------------------------*/
allocEnums(void)3488 static void allocEnums(void)
3489 {
3490 dvSetAllocatedEnum(2);
3491 dvSetUsedEnum(0);
3492 dvEnums.Sym = utNewA(utSym, (dvAllocatedEnum()));
3493 dvEnums.PrefixSym = utNewA(utSym, (dvAllocatedEnum()));
3494 dvEnums.NumEntries = utNewA(uint16, (dvAllocatedEnum()));
3495 dvEnums.Module = utNewA(dvModule, (dvAllocatedEnum()));
3496 dvEnums.NextModuleEnum = utNewA(dvEnum, (dvAllocatedEnum()));
3497 dvEnums.PrevModuleEnum = utNewA(dvEnum, (dvAllocatedEnum()));
3498 dvEnums.NextTableModuleEnum = utNewA(dvEnum, (dvAllocatedEnum()));
3499 dvEnums.FirstEntry = utNewA(dvEntry, (dvAllocatedEnum()));
3500 dvEnums.LastEntry = utNewA(dvEntry, (dvAllocatedEnum()));
3501 dvEnums.EntryTableIndex = utNewA(uint32, (dvAllocatedEnum()));
3502 dvEnums.NumEntryTable = utNewA(uint32, (dvAllocatedEnum()));
3503 dvSetUsedEnumEntryTable(0);
3504 dvSetAllocatedEnumEntryTable(2);
3505 dvSetFreeEnumEntryTable(0);
3506 dvEnums.EntryTable = utNewA(dvEntry, dvAllocatedEnumEntryTable());
3507 dvEnums.NumEntry = utNewA(uint32, (dvAllocatedEnum()));
3508 }
3509
3510 /*----------------------------------------------------------------------------------------
3511 Realloc the arrays of properties for class Enum.
3512 ----------------------------------------------------------------------------------------*/
reallocEnums(uint32 newSize)3513 static void reallocEnums(
3514 uint32 newSize)
3515 {
3516 utResizeArray(dvEnums.Sym, (newSize));
3517 utResizeArray(dvEnums.PrefixSym, (newSize));
3518 utResizeArray(dvEnums.NumEntries, (newSize));
3519 utResizeArray(dvEnums.Module, (newSize));
3520 utResizeArray(dvEnums.NextModuleEnum, (newSize));
3521 utResizeArray(dvEnums.PrevModuleEnum, (newSize));
3522 utResizeArray(dvEnums.NextTableModuleEnum, (newSize));
3523 utResizeArray(dvEnums.FirstEntry, (newSize));
3524 utResizeArray(dvEnums.LastEntry, (newSize));
3525 utResizeArray(dvEnums.EntryTableIndex, (newSize));
3526 utResizeArray(dvEnums.NumEntryTable, (newSize));
3527 utResizeArray(dvEnums.NumEntry, (newSize));
3528 dvSetAllocatedEnum(newSize);
3529 }
3530
3531 /*----------------------------------------------------------------------------------------
3532 Allocate more Enums.
3533 ----------------------------------------------------------------------------------------*/
dvEnumAllocMore(void)3534 void dvEnumAllocMore(void)
3535 {
3536 reallocEnums((uint32)(dvAllocatedEnum() + (dvAllocatedEnum() >> 1)));
3537 }
3538
3539 /*----------------------------------------------------------------------------------------
3540 Compact the Enum.EntryTable heap to free memory.
3541 ----------------------------------------------------------------------------------------*/
dvCompactEnumEntryTables(void)3542 void dvCompactEnumEntryTables(void)
3543 {
3544 uint32 elementSize = sizeof(dvEntry);
3545 uint32 usedHeaderSize = (sizeof(dvEnum) + elementSize - 1)/elementSize;
3546 uint32 freeHeaderSize = (sizeof(dvEnum) + sizeof(uint32) + elementSize - 1)/elementSize;
3547 dvEntry *toPtr = dvEnums.EntryTable;
3548 dvEntry *fromPtr = toPtr;
3549 dvEnum Enum;
3550 uint32 size;
3551
3552 while(fromPtr < dvEnums.EntryTable + dvUsedEnumEntryTable()) {
3553 Enum = *(dvEnum *)(void *)fromPtr;
3554 if(Enum != dvEnumNull) {
3555 /* Need to move it to toPtr */
3556 size = utMax(dvEnumGetNumEntryTable(Enum) + usedHeaderSize, freeHeaderSize);
3557 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
3558 dvEnumSetEntryTableIndex(Enum, toPtr - dvEnums.EntryTable + usedHeaderSize);
3559 toPtr += size;
3560 } else {
3561 /* Just skip it */
3562 size = *(uint32 *)(void *)(((dvEnum *)(void *)fromPtr) + 1);
3563 }
3564 fromPtr += size;
3565 }
3566 dvSetUsedEnumEntryTable(toPtr - dvEnums.EntryTable);
3567 dvSetFreeEnumEntryTable(0);
3568 }
3569
3570 /*----------------------------------------------------------------------------------------
3571 Allocate more memory for the Enum.EntryTable heap.
3572 ----------------------------------------------------------------------------------------*/
allocMoreEnumEntryTables(uint32 spaceNeeded)3573 static void allocMoreEnumEntryTables(
3574 uint32 spaceNeeded)
3575 {
3576 uint32 freeSpace = dvAllocatedEnumEntryTable() - dvUsedEnumEntryTable();
3577
3578 if((dvFreeEnumEntryTable() << 2) > dvUsedEnumEntryTable()) {
3579 dvCompactEnumEntryTables();
3580 freeSpace = dvAllocatedEnumEntryTable() - dvUsedEnumEntryTable();
3581 }
3582 if(freeSpace < spaceNeeded) {
3583 dvSetAllocatedEnumEntryTable(dvAllocatedEnumEntryTable() + spaceNeeded - freeSpace +
3584 (dvAllocatedEnumEntryTable() >> 1));
3585 utResizeArray(dvEnums.EntryTable, dvAllocatedEnumEntryTable());
3586 }
3587 }
3588
3589 /*----------------------------------------------------------------------------------------
3590 Allocate memory for a new Enum.EntryTable array.
3591 ----------------------------------------------------------------------------------------*/
dvEnumAllocEntryTables(dvEnum Enum,uint32 numEntryTables)3592 void dvEnumAllocEntryTables(
3593 dvEnum Enum,
3594 uint32 numEntryTables)
3595 {
3596 uint32 freeSpace = dvAllocatedEnumEntryTable() - dvUsedEnumEntryTable();
3597 uint32 elementSize = sizeof(dvEntry);
3598 uint32 usedHeaderSize = (sizeof(dvEnum) + elementSize - 1)/elementSize;
3599 uint32 freeHeaderSize = (sizeof(dvEnum) + sizeof(uint32) + elementSize - 1)/elementSize;
3600 uint32 spaceNeeded = utMax(numEntryTables + usedHeaderSize, freeHeaderSize);
3601
3602 #if defined(DD_DEBUG)
3603 utAssert(dvEnumGetNumEntryTable(Enum) == 0);
3604 #endif
3605 if(numEntryTables == 0) {
3606 return;
3607 }
3608 if(freeSpace < spaceNeeded) {
3609 allocMoreEnumEntryTables(spaceNeeded);
3610 }
3611 dvEnumSetEntryTableIndex(Enum, dvUsedEnumEntryTable() + usedHeaderSize);
3612 dvEnumSetNumEntryTable(Enum, numEntryTables);
3613 *(dvEnum *)(void *)(dvEnums.EntryTable + dvUsedEnumEntryTable()) = Enum;
3614 {
3615 uint32 xEnum;
3616 for(xEnum = (uint32)(dvEnumGetEntryTableIndex(Enum)); xEnum < dvEnumGetEntryTableIndex(Enum) + numEntryTables; xEnum++) {
3617 dvEnums.EntryTable[xEnum] = dvEntryNull;
3618 }
3619 }
3620 dvSetUsedEnumEntryTable(dvUsedEnumEntryTable() + spaceNeeded);
3621 }
3622
3623 /*----------------------------------------------------------------------------------------
3624 Wrapper around dvEnumGetEntryTables for the database manager.
3625 ----------------------------------------------------------------------------------------*/
getEnumEntryTables(uint64 objectNumber,uint32 * numValues)3626 static void *getEnumEntryTables(
3627 uint64 objectNumber,
3628 uint32 *numValues)
3629 {
3630 dvEnum Enum = dvIndex2Enum((uint32)objectNumber);
3631
3632 *numValues = dvEnumGetNumEntryTable(Enum);
3633 return dvEnumGetEntryTables(Enum);
3634 }
3635
3636 /*----------------------------------------------------------------------------------------
3637 Wrapper around dvEnumAllocEntryTables for the database manager.
3638 ----------------------------------------------------------------------------------------*/
allocEnumEntryTables(uint64 objectNumber,uint32 numValues)3639 static void *allocEnumEntryTables(
3640 uint64 objectNumber,
3641 uint32 numValues)
3642 {
3643 dvEnum Enum = dvIndex2Enum((uint32)objectNumber);
3644
3645 dvEnumSetEntryTableIndex(Enum, 0);
3646 dvEnumSetNumEntryTable(Enum, 0);
3647 if(numValues == 0) {
3648 return NULL;
3649 }
3650 dvEnumAllocEntryTables(Enum, numValues);
3651 return dvEnumGetEntryTables(Enum);
3652 }
3653
3654 /*----------------------------------------------------------------------------------------
3655 Free memory used by the Enum.EntryTable array.
3656 ----------------------------------------------------------------------------------------*/
dvEnumFreeEntryTables(dvEnum Enum)3657 void dvEnumFreeEntryTables(
3658 dvEnum Enum)
3659 {
3660 uint32 elementSize = sizeof(dvEntry);
3661 uint32 usedHeaderSize = (sizeof(dvEnum) + elementSize - 1)/elementSize;
3662 uint32 freeHeaderSize = (sizeof(dvEnum) + sizeof(uint32) + elementSize - 1)/elementSize;
3663 uint32 size = utMax(dvEnumGetNumEntryTable(Enum) + usedHeaderSize, freeHeaderSize);
3664 dvEntry *dataPtr = dvEnumGetEntryTables(Enum) - usedHeaderSize;
3665
3666 if(dvEnumGetNumEntryTable(Enum) == 0) {
3667 return;
3668 }
3669 *(dvEnum *)(void *)(dataPtr) = dvEnumNull;
3670 *(uint32 *)(void *)(((dvEnum *)(void *)dataPtr) + 1) = size;
3671 dvEnumSetNumEntryTable(Enum, 0);
3672 dvSetFreeEnumEntryTable(dvFreeEnumEntryTable() + size);
3673 }
3674
3675 /*----------------------------------------------------------------------------------------
3676 Resize the Enum.EntryTable array.
3677 ----------------------------------------------------------------------------------------*/
dvEnumResizeEntryTables(dvEnum Enum,uint32 numEntryTables)3678 void dvEnumResizeEntryTables(
3679 dvEnum Enum,
3680 uint32 numEntryTables)
3681 {
3682 uint32 freeSpace;
3683 uint32 elementSize = sizeof(dvEntry);
3684 uint32 usedHeaderSize = (sizeof(dvEnum) + elementSize - 1)/elementSize;
3685 uint32 freeHeaderSize = (sizeof(dvEnum) + sizeof(uint32) + elementSize - 1)/elementSize;
3686 uint32 newSize = utMax(numEntryTables + usedHeaderSize, freeHeaderSize);
3687 uint32 oldSize = utMax(dvEnumGetNumEntryTable(Enum) + usedHeaderSize, freeHeaderSize);
3688 dvEntry *dataPtr;
3689
3690 if(numEntryTables == 0) {
3691 if(dvEnumGetNumEntryTable(Enum) != 0) {
3692 dvEnumFreeEntryTables(Enum);
3693 }
3694 return;
3695 }
3696 if(dvEnumGetNumEntryTable(Enum) == 0) {
3697 dvEnumAllocEntryTables(Enum, numEntryTables);
3698 return;
3699 }
3700 freeSpace = dvAllocatedEnumEntryTable() - dvUsedEnumEntryTable();
3701 if(freeSpace < newSize) {
3702 allocMoreEnumEntryTables(newSize);
3703 }
3704 dataPtr = dvEnumGetEntryTables(Enum) - usedHeaderSize;
3705 memcpy((void *)(dvEnums.EntryTable + dvUsedEnumEntryTable()), dataPtr,
3706 elementSize*utMin(oldSize, newSize));
3707 if(newSize > oldSize) {
3708 {
3709 uint32 xEnum;
3710 for(xEnum = (uint32)(dvUsedEnumEntryTable() + oldSize); xEnum < dvUsedEnumEntryTable() + oldSize + newSize - oldSize; xEnum++) {
3711 dvEnums.EntryTable[xEnum] = dvEntryNull;
3712 }
3713 }
3714 }
3715 *(dvEnum *)(void *)dataPtr = dvEnumNull;
3716 *(uint32 *)(void *)(((dvEnum *)(void *)dataPtr) + 1) = oldSize;
3717 dvSetFreeEnumEntryTable(dvFreeEnumEntryTable() + oldSize);
3718 dvEnumSetEntryTableIndex(Enum, dvUsedEnumEntryTable() + usedHeaderSize);
3719 dvEnumSetNumEntryTable(Enum, numEntryTables);
3720 dvSetUsedEnumEntryTable(dvUsedEnumEntryTable() + newSize);
3721 }
3722
3723 /*----------------------------------------------------------------------------------------
3724 Copy the properties of Enum.
3725 ----------------------------------------------------------------------------------------*/
dvEnumCopyProps(dvEnum oldEnum,dvEnum newEnum)3726 void dvEnumCopyProps(
3727 dvEnum oldEnum,
3728 dvEnum newEnum)
3729 {
3730 dvEnumSetPrefixSym(newEnum, dvEnumGetPrefixSym(oldEnum));
3731 dvEnumSetNumEntries(newEnum, dvEnumGetNumEntries(oldEnum));
3732 }
3733
3734 static void addEnumEntryToHashTable(dvEnum Enum, dvEntry _Entry);
3735 /*----------------------------------------------------------------------------------------
3736 Increase the size of the hash table.
3737 ----------------------------------------------------------------------------------------*/
resizeEnumEntryHashTable(dvEnum Enum)3738 static void resizeEnumEntryHashTable(
3739 dvEnum Enum)
3740 {
3741 dvEntry _Entry;
3742 dvEntry *Entrys;
3743 uint32 numEntrys = dvEnumGetNumEntryTable(Enum) << 1;
3744
3745 if(numEntrys == 0) {
3746 numEntrys = 2;
3747 dvEnumAllocEntryTables(Enum, 2);
3748 } else {
3749 dvEnumResizeEntryTables(Enum, numEntrys);
3750 }
3751 Entrys = dvEnumGetEntryTables(Enum);
3752 /* Zero out the table */
3753 while(numEntrys-- != 0) {
3754 *Entrys++ = dvEntryNull;
3755 }
3756 dvEnumSetNumEntry(Enum, 0);
3757 dvForeachEnumEntry(Enum, _Entry) {
3758 if(dvEntryGetSym(_Entry) != utSymNull) {
3759 addEnumEntryToHashTable(Enum, _Entry);
3760 }
3761 } dvEndEnumEntry;
3762 }
3763
3764 /*----------------------------------------------------------------------------------------
3765 Add the Entry to the Enum. If the table is near full, build a new one twice
3766 as big, delete the old one, and return the new one.
3767 ----------------------------------------------------------------------------------------*/
addEnumEntryToHashTable(dvEnum Enum,dvEntry _Entry)3768 static void addEnumEntryToHashTable(
3769 dvEnum Enum,
3770 dvEntry _Entry)
3771 {
3772 dvEntry nextEntry;
3773 uint32 index;
3774
3775 if(dvEnumGetNumEntry(Enum) >= dvEnumGetNumEntryTable(Enum)) {
3776 resizeEnumEntryHashTable(Enum);
3777 return;
3778 }
3779 index = (dvEnumGetNumEntryTable(Enum) - 1) & utSymGetHashValue(dvEntryGetSym(_Entry));
3780 nextEntry = dvEnumGetiEntryTable(Enum, index);
3781 dvEntrySetNextTableEnumEntry(_Entry, nextEntry);
3782 dvEnumSetiEntryTable(Enum, index, _Entry);
3783 dvEnumSetNumEntry(Enum, dvEnumGetNumEntry(Enum) + 1);
3784 }
3785
3786 /*----------------------------------------------------------------------------------------
3787 Remove the Entry from the hash table.
3788 ----------------------------------------------------------------------------------------*/
removeEnumEntryFromHashTable(dvEnum Enum,dvEntry _Entry)3789 static void removeEnumEntryFromHashTable(
3790 dvEnum Enum,
3791 dvEntry _Entry)
3792 {
3793 uint32 index = (dvEnumGetNumEntryTable(Enum) - 1) & utSymGetHashValue(dvEntryGetSym(_Entry));
3794 dvEntry prevEntry, nextEntry;
3795
3796 nextEntry = dvEnumGetiEntryTable(Enum, index);
3797 if(nextEntry == _Entry) {
3798 dvEnumSetiEntryTable(Enum, index, dvEntryGetNextTableEnumEntry(nextEntry));
3799 } else {
3800 do {
3801 prevEntry = nextEntry;
3802 nextEntry = dvEntryGetNextTableEnumEntry(nextEntry);
3803 } while(nextEntry != _Entry);
3804 dvEntrySetNextTableEnumEntry(prevEntry, dvEntryGetNextTableEnumEntry(_Entry));
3805 }
3806 dvEnumSetNumEntry(Enum, dvEnumGetNumEntry(Enum) - 1);
3807 dvEntrySetNextTableEnumEntry(_Entry, dvEntryNull);
3808 }
3809
3810 /*----------------------------------------------------------------------------------------
3811 Find the Entry from the Enum and its hash key.
3812 ----------------------------------------------------------------------------------------*/
dvEnumFindEntry(dvEnum Enum,utSym Sym)3813 dvEntry dvEnumFindEntry(
3814 dvEnum Enum,
3815 utSym Sym)
3816 {
3817 uint32 mask = dvEnumGetNumEntryTable(Enum) - 1;
3818 dvEntry _Entry;
3819
3820 if(mask + 1 != 0) {
3821 _Entry = dvEnumGetiEntryTable(Enum, utSymGetHashValue(Sym) & mask);
3822 while(_Entry != dvEntryNull) {
3823 if(dvEntryGetSym(_Entry) == Sym) {
3824 return _Entry;
3825 }
3826 _Entry = dvEntryGetNextTableEnumEntry(_Entry);
3827 }
3828 }
3829 return dvEntryNull;
3830 }
3831
3832 /*----------------------------------------------------------------------------------------
3833 Find the Entry from the Enum and its name.
3834 ----------------------------------------------------------------------------------------*/
dvEnumRenameEntry(dvEnum Enum,dvEntry _Entry,utSym sym)3835 void dvEnumRenameEntry(
3836 dvEnum Enum,
3837 dvEntry _Entry,
3838 utSym sym)
3839 {
3840 if(dvEntryGetSym(_Entry) != utSymNull) {
3841 removeEnumEntryFromHashTable(Enum, _Entry);
3842 }
3843 dvEntrySetSym(_Entry, sym);
3844 if(sym != utSymNull) {
3845 addEnumEntryToHashTable(Enum, _Entry);
3846 }
3847 }
3848
3849 /*----------------------------------------------------------------------------------------
3850 Add the Entry to the head of the list on the Enum.
3851 ----------------------------------------------------------------------------------------*/
dvEnumInsertEntry(dvEnum Enum,dvEntry _Entry)3852 void dvEnumInsertEntry(
3853 dvEnum Enum,
3854 dvEntry _Entry)
3855 {
3856 #if defined(DD_DEBUG)
3857 if(Enum == dvEnumNull) {
3858 utExit("Non-existent Enum");
3859 }
3860 if(_Entry == dvEntryNull) {
3861 utExit("Non-existent Entry");
3862 }
3863 if(dvEntryGetEnum(_Entry) != dvEnumNull) {
3864 utExit("Attempting to add Entry to Enum twice");
3865 }
3866 #endif
3867 dvEntrySetNextEnumEntry(_Entry, dvEnumGetFirstEntry(Enum));
3868 if(dvEnumGetFirstEntry(Enum) != dvEntryNull) {
3869 dvEntrySetPrevEnumEntry(dvEnumGetFirstEntry(Enum), _Entry);
3870 }
3871 dvEnumSetFirstEntry(Enum, _Entry);
3872 dvEntrySetPrevEnumEntry(_Entry, dvEntryNull);
3873 if(dvEnumGetLastEntry(Enum) == dvEntryNull) {
3874 dvEnumSetLastEntry(Enum, _Entry);
3875 }
3876 dvEntrySetEnum(_Entry, Enum);
3877 if(dvEntryGetSym(_Entry) != utSymNull) {
3878 addEnumEntryToHashTable(Enum, _Entry);
3879 }
3880 }
3881
3882 /*----------------------------------------------------------------------------------------
3883 Add the Entry to the end of the list on the Enum.
3884 ----------------------------------------------------------------------------------------*/
dvEnumAppendEntry(dvEnum Enum,dvEntry _Entry)3885 void dvEnumAppendEntry(
3886 dvEnum Enum,
3887 dvEntry _Entry)
3888 {
3889 #if defined(DD_DEBUG)
3890 if(Enum == dvEnumNull) {
3891 utExit("Non-existent Enum");
3892 }
3893 if(_Entry == dvEntryNull) {
3894 utExit("Non-existent Entry");
3895 }
3896 if(dvEntryGetEnum(_Entry) != dvEnumNull) {
3897 utExit("Attempting to add Entry to Enum twice");
3898 }
3899 #endif
3900 dvEntrySetPrevEnumEntry(_Entry, dvEnumGetLastEntry(Enum));
3901 if(dvEnumGetLastEntry(Enum) != dvEntryNull) {
3902 dvEntrySetNextEnumEntry(dvEnumGetLastEntry(Enum), _Entry);
3903 }
3904 dvEnumSetLastEntry(Enum, _Entry);
3905 dvEntrySetNextEnumEntry(_Entry, dvEntryNull);
3906 if(dvEnumGetFirstEntry(Enum) == dvEntryNull) {
3907 dvEnumSetFirstEntry(Enum, _Entry);
3908 }
3909 dvEntrySetEnum(_Entry, Enum);
3910 if(dvEntryGetSym(_Entry) != utSymNull) {
3911 addEnumEntryToHashTable(Enum, _Entry);
3912 }
3913 }
3914
3915 /*----------------------------------------------------------------------------------------
3916 Insert the Entry to the Enum after the previous Entry.
3917 ----------------------------------------------------------------------------------------*/
dvEnumInsertAfterEntry(dvEnum Enum,dvEntry prevEntry,dvEntry _Entry)3918 void dvEnumInsertAfterEntry(
3919 dvEnum Enum,
3920 dvEntry prevEntry,
3921 dvEntry _Entry)
3922 {
3923 dvEntry nextEntry = dvEntryGetNextEnumEntry(prevEntry);
3924
3925 #if defined(DD_DEBUG)
3926 if(Enum == dvEnumNull) {
3927 utExit("Non-existent Enum");
3928 }
3929 if(_Entry == dvEntryNull) {
3930 utExit("Non-existent Entry");
3931 }
3932 if(dvEntryGetEnum(_Entry) != dvEnumNull) {
3933 utExit("Attempting to add Entry to Enum twice");
3934 }
3935 #endif
3936 dvEntrySetNextEnumEntry(_Entry, nextEntry);
3937 dvEntrySetNextEnumEntry(prevEntry, _Entry);
3938 dvEntrySetPrevEnumEntry(_Entry, prevEntry);
3939 if(nextEntry != dvEntryNull) {
3940 dvEntrySetPrevEnumEntry(nextEntry, _Entry);
3941 }
3942 if(dvEnumGetLastEntry(Enum) == prevEntry) {
3943 dvEnumSetLastEntry(Enum, _Entry);
3944 }
3945 dvEntrySetEnum(_Entry, Enum);
3946 if(dvEntryGetSym(_Entry) != utSymNull) {
3947 addEnumEntryToHashTable(Enum, _Entry);
3948 }
3949 }
3950
3951 /*----------------------------------------------------------------------------------------
3952 Remove the Entry from the Enum.
3953 ----------------------------------------------------------------------------------------*/
dvEnumRemoveEntry(dvEnum Enum,dvEntry _Entry)3954 void dvEnumRemoveEntry(
3955 dvEnum Enum,
3956 dvEntry _Entry)
3957 {
3958 dvEntry pEntry, nEntry;
3959
3960 #if defined(DD_DEBUG)
3961 if(_Entry == dvEntryNull) {
3962 utExit("Non-existent Entry");
3963 }
3964 if(dvEntryGetEnum(_Entry) != dvEnumNull && dvEntryGetEnum(_Entry) != Enum) {
3965 utExit("Delete Entry from non-owning Enum");
3966 }
3967 #endif
3968 nEntry = dvEntryGetNextEnumEntry(_Entry);
3969 pEntry = dvEntryGetPrevEnumEntry(_Entry);
3970 if(pEntry != dvEntryNull) {
3971 dvEntrySetNextEnumEntry(pEntry, nEntry);
3972 } else if(dvEnumGetFirstEntry(Enum) == _Entry) {
3973 dvEnumSetFirstEntry(Enum, nEntry);
3974 }
3975 if(nEntry != dvEntryNull) {
3976 dvEntrySetPrevEnumEntry(nEntry, pEntry);
3977 } else if(dvEnumGetLastEntry(Enum) == _Entry) {
3978 dvEnumSetLastEntry(Enum, pEntry);
3979 }
3980 dvEntrySetNextEnumEntry(_Entry, dvEntryNull);
3981 dvEntrySetPrevEnumEntry(_Entry, dvEntryNull);
3982 dvEntrySetEnum(_Entry, dvEnumNull);
3983 if(dvEntryGetSym(_Entry) != utSymNull) {
3984 removeEnumEntryFromHashTable(Enum, _Entry);
3985 }
3986 }
3987
3988 #if defined(DD_DEBUG)
3989 /*----------------------------------------------------------------------------------------
3990 Write out all the fields of an object.
3991 ----------------------------------------------------------------------------------------*/
dvShowEnum(dvEnum Enum)3992 void dvShowEnum(
3993 dvEnum Enum)
3994 {
3995 utDatabaseShowObject("dv", "Enum", dvEnum2Index(Enum));
3996 }
3997 #endif
3998
3999 /*----------------------------------------------------------------------------------------
4000 Default constructor wrapper for the database manager.
4001 ----------------------------------------------------------------------------------------*/
allocEntry(void)4002 static uint64 allocEntry(void)
4003 {
4004 dvEntry Entry = dvEntryAlloc();
4005
4006 return dvEntry2Index(Entry);
4007 }
4008
4009 /*----------------------------------------------------------------------------------------
4010 Allocate the field arrays of Entry.
4011 ----------------------------------------------------------------------------------------*/
allocEntrys(void)4012 static void allocEntrys(void)
4013 {
4014 dvSetAllocatedEntry(2);
4015 dvSetUsedEntry(0);
4016 dvEntrys.Sym = utNewA(utSym, (dvAllocatedEntry()));
4017 dvEntrys.Value = utNewA(uint32, (dvAllocatedEntry()));
4018 dvEntrys.Enum = utNewA(dvEnum, (dvAllocatedEntry()));
4019 dvEntrys.NextEnumEntry = utNewA(dvEntry, (dvAllocatedEntry()));
4020 dvEntrys.PrevEnumEntry = utNewA(dvEntry, (dvAllocatedEntry()));
4021 dvEntrys.NextTableEnumEntry = utNewA(dvEntry, (dvAllocatedEntry()));
4022 dvEntrys.FirstCase = utNewA(dvCase, (dvAllocatedEntry()));
4023 dvEntrys.LastCase = utNewA(dvCase, (dvAllocatedEntry()));
4024 }
4025
4026 /*----------------------------------------------------------------------------------------
4027 Realloc the arrays of properties for class Entry.
4028 ----------------------------------------------------------------------------------------*/
reallocEntrys(uint32 newSize)4029 static void reallocEntrys(
4030 uint32 newSize)
4031 {
4032 utResizeArray(dvEntrys.Sym, (newSize));
4033 utResizeArray(dvEntrys.Value, (newSize));
4034 utResizeArray(dvEntrys.Enum, (newSize));
4035 utResizeArray(dvEntrys.NextEnumEntry, (newSize));
4036 utResizeArray(dvEntrys.PrevEnumEntry, (newSize));
4037 utResizeArray(dvEntrys.NextTableEnumEntry, (newSize));
4038 utResizeArray(dvEntrys.FirstCase, (newSize));
4039 utResizeArray(dvEntrys.LastCase, (newSize));
4040 dvSetAllocatedEntry(newSize);
4041 }
4042
4043 /*----------------------------------------------------------------------------------------
4044 Allocate more Entrys.
4045 ----------------------------------------------------------------------------------------*/
dvEntryAllocMore(void)4046 void dvEntryAllocMore(void)
4047 {
4048 reallocEntrys((uint32)(dvAllocatedEntry() + (dvAllocatedEntry() >> 1)));
4049 }
4050
4051 /*----------------------------------------------------------------------------------------
4052 Copy the properties of Entry.
4053 ----------------------------------------------------------------------------------------*/
dvEntryCopyProps(dvEntry oldEntry,dvEntry newEntry)4054 void dvEntryCopyProps(
4055 dvEntry oldEntry,
4056 dvEntry newEntry)
4057 {
4058 dvEntrySetValue(newEntry, dvEntryGetValue(oldEntry));
4059 }
4060
4061 /*----------------------------------------------------------------------------------------
4062 Add the Case to the head of the list on the Entry.
4063 ----------------------------------------------------------------------------------------*/
dvEntryInsertCase(dvEntry Entry,dvCase _Case)4064 void dvEntryInsertCase(
4065 dvEntry Entry,
4066 dvCase _Case)
4067 {
4068 #if defined(DD_DEBUG)
4069 if(Entry == dvEntryNull) {
4070 utExit("Non-existent Entry");
4071 }
4072 if(_Case == dvCaseNull) {
4073 utExit("Non-existent Case");
4074 }
4075 if(dvCaseGetEntry(_Case) != dvEntryNull) {
4076 utExit("Attempting to add Case to Entry twice");
4077 }
4078 #endif
4079 dvCaseSetNextEntryCase(_Case, dvEntryGetFirstCase(Entry));
4080 dvEntrySetFirstCase(Entry, _Case);
4081 if(dvEntryGetLastCase(Entry) == dvCaseNull) {
4082 dvEntrySetLastCase(Entry, _Case);
4083 }
4084 dvCaseSetEntry(_Case, Entry);
4085 }
4086
4087 /*----------------------------------------------------------------------------------------
4088 Add the Case to the end of the list on the Entry.
4089 ----------------------------------------------------------------------------------------*/
dvEntryAppendCase(dvEntry Entry,dvCase _Case)4090 void dvEntryAppendCase(
4091 dvEntry Entry,
4092 dvCase _Case)
4093 {
4094 #if defined(DD_DEBUG)
4095 if(Entry == dvEntryNull) {
4096 utExit("Non-existent Entry");
4097 }
4098 if(_Case == dvCaseNull) {
4099 utExit("Non-existent Case");
4100 }
4101 if(dvCaseGetEntry(_Case) != dvEntryNull) {
4102 utExit("Attempting to add Case to Entry twice");
4103 }
4104 #endif
4105 if(dvEntryGetLastCase(Entry) != dvCaseNull) {
4106 dvCaseSetNextEntryCase(dvEntryGetLastCase(Entry), _Case);
4107 } else {
4108 dvEntrySetFirstCase(Entry, _Case);
4109 }
4110 dvEntrySetLastCase(Entry, _Case);
4111 dvCaseSetNextEntryCase(_Case, dvCaseNull);
4112 dvCaseSetEntry(_Case, Entry);
4113 }
4114
4115 /*----------------------------------------------------------------------------------------
4116 Insert the Case to the Entry after the previous Case.
4117 ----------------------------------------------------------------------------------------*/
dvEntryInsertAfterCase(dvEntry Entry,dvCase prevCase,dvCase _Case)4118 void dvEntryInsertAfterCase(
4119 dvEntry Entry,
4120 dvCase prevCase,
4121 dvCase _Case)
4122 {
4123 dvCase nextCase = dvCaseGetNextEntryCase(prevCase);
4124
4125 #if defined(DD_DEBUG)
4126 if(Entry == dvEntryNull) {
4127 utExit("Non-existent Entry");
4128 }
4129 if(_Case == dvCaseNull) {
4130 utExit("Non-existent Case");
4131 }
4132 if(dvCaseGetEntry(_Case) != dvEntryNull) {
4133 utExit("Attempting to add Case to Entry twice");
4134 }
4135 #endif
4136 dvCaseSetNextEntryCase(_Case, nextCase);
4137 dvCaseSetNextEntryCase(prevCase, _Case);
4138 if(dvEntryGetLastCase(Entry) == prevCase) {
4139 dvEntrySetLastCase(Entry, _Case);
4140 }
4141 dvCaseSetEntry(_Case, Entry);
4142 }
4143
4144 /*----------------------------------------------------------------------------------------
4145 Remove the Case from the Entry.
4146 ----------------------------------------------------------------------------------------*/
dvEntryRemoveCase(dvEntry Entry,dvCase _Case)4147 void dvEntryRemoveCase(
4148 dvEntry Entry,
4149 dvCase _Case)
4150 {
4151 dvCase pCase, nCase;
4152
4153 #if defined(DD_DEBUG)
4154 if(_Case == dvCaseNull) {
4155 utExit("Non-existent Case");
4156 }
4157 if(dvCaseGetEntry(_Case) != dvEntryNull && dvCaseGetEntry(_Case) != Entry) {
4158 utExit("Delete Case from non-owning Entry");
4159 }
4160 #endif
4161 pCase = dvCaseNull;
4162 for(nCase = dvEntryGetFirstCase(Entry); nCase != dvCaseNull && nCase != _Case;
4163 nCase = dvCaseGetNextEntryCase(nCase)) {
4164 pCase = nCase;
4165 }
4166 if(pCase != dvCaseNull) {
4167 dvCaseSetNextEntryCase(pCase, dvCaseGetNextEntryCase(_Case));
4168 } else {
4169 dvEntrySetFirstCase(Entry, dvCaseGetNextEntryCase(_Case));
4170 }
4171 dvCaseSetNextEntryCase(_Case, dvCaseNull);
4172 if(dvEntryGetLastCase(Entry) == _Case) {
4173 dvEntrySetLastCase(Entry, pCase);
4174 }
4175 dvCaseSetEntry(_Case, dvEntryNull);
4176 }
4177
4178 #if defined(DD_DEBUG)
4179 /*----------------------------------------------------------------------------------------
4180 Write out all the fields of an object.
4181 ----------------------------------------------------------------------------------------*/
dvShowEntry(dvEntry Entry)4182 void dvShowEntry(
4183 dvEntry Entry)
4184 {
4185 utDatabaseShowObject("dv", "Entry", dvEntry2Index(Entry));
4186 }
4187 #endif
4188
4189 /*----------------------------------------------------------------------------------------
4190 Default constructor wrapper for the database manager.
4191 ----------------------------------------------------------------------------------------*/
allocTypedef(void)4192 static uint64 allocTypedef(void)
4193 {
4194 dvTypedef Typedef = dvTypedefAlloc();
4195
4196 return dvTypedef2Index(Typedef);
4197 }
4198
4199 /*----------------------------------------------------------------------------------------
4200 Allocate the field arrays of Typedef.
4201 ----------------------------------------------------------------------------------------*/
allocTypedefs(void)4202 static void allocTypedefs(void)
4203 {
4204 dvSetAllocatedTypedef(2);
4205 dvSetUsedTypedef(0);
4206 dvTypedefs.Sym = utNewA(utSym, (dvAllocatedTypedef()));
4207 dvTypedefs.InitializerIndex = utNewA(uint32, (dvAllocatedTypedef()));
4208 dvTypedefs.NumInitializer = utNewA(uint32, (dvAllocatedTypedef()));
4209 dvSetUsedTypedefInitializer(0);
4210 dvSetAllocatedTypedefInitializer(2);
4211 dvSetFreeTypedefInitializer(0);
4212 dvTypedefs.Initializer = utNewA(char, dvAllocatedTypedefInitializer());
4213 dvTypedefs.Module = utNewA(dvModule, (dvAllocatedTypedef()));
4214 dvTypedefs.NextModuleTypedef = utNewA(dvTypedef, (dvAllocatedTypedef()));
4215 dvTypedefs.PrevModuleTypedef = utNewA(dvTypedef, (dvAllocatedTypedef()));
4216 dvTypedefs.NextTableModuleTypedef = utNewA(dvTypedef, (dvAllocatedTypedef()));
4217 }
4218
4219 /*----------------------------------------------------------------------------------------
4220 Realloc the arrays of properties for class Typedef.
4221 ----------------------------------------------------------------------------------------*/
reallocTypedefs(uint32 newSize)4222 static void reallocTypedefs(
4223 uint32 newSize)
4224 {
4225 utResizeArray(dvTypedefs.Sym, (newSize));
4226 utResizeArray(dvTypedefs.InitializerIndex, (newSize));
4227 utResizeArray(dvTypedefs.NumInitializer, (newSize));
4228 utResizeArray(dvTypedefs.Module, (newSize));
4229 utResizeArray(dvTypedefs.NextModuleTypedef, (newSize));
4230 utResizeArray(dvTypedefs.PrevModuleTypedef, (newSize));
4231 utResizeArray(dvTypedefs.NextTableModuleTypedef, (newSize));
4232 dvSetAllocatedTypedef(newSize);
4233 }
4234
4235 /*----------------------------------------------------------------------------------------
4236 Allocate more Typedefs.
4237 ----------------------------------------------------------------------------------------*/
dvTypedefAllocMore(void)4238 void dvTypedefAllocMore(void)
4239 {
4240 reallocTypedefs((uint32)(dvAllocatedTypedef() + (dvAllocatedTypedef() >> 1)));
4241 }
4242
4243 /*----------------------------------------------------------------------------------------
4244 Compact the Typedef.Initializer heap to free memory.
4245 ----------------------------------------------------------------------------------------*/
dvCompactTypedefInitializers(void)4246 void dvCompactTypedefInitializers(void)
4247 {
4248 uint32 elementSize = sizeof(char);
4249 uint32 usedHeaderSize = (sizeof(dvTypedef) + elementSize - 1)/elementSize;
4250 uint32 freeHeaderSize = (sizeof(dvTypedef) + sizeof(uint32) + elementSize - 1)/elementSize;
4251 char *toPtr = dvTypedefs.Initializer;
4252 char *fromPtr = toPtr;
4253 dvTypedef Typedef;
4254 uint32 size;
4255
4256 while(fromPtr < dvTypedefs.Initializer + dvUsedTypedefInitializer()) {
4257 Typedef = *(dvTypedef *)(void *)fromPtr;
4258 if(Typedef != dvTypedefNull) {
4259 /* Need to move it to toPtr */
4260 size = utMax(dvTypedefGetNumInitializer(Typedef) + usedHeaderSize, freeHeaderSize);
4261 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
4262 dvTypedefSetInitializerIndex(Typedef, toPtr - dvTypedefs.Initializer + usedHeaderSize);
4263 toPtr += size;
4264 } else {
4265 /* Just skip it */
4266 size = *(uint32 *)(void *)(((dvTypedef *)(void *)fromPtr) + 1);
4267 }
4268 fromPtr += size;
4269 }
4270 dvSetUsedTypedefInitializer(toPtr - dvTypedefs.Initializer);
4271 dvSetFreeTypedefInitializer(0);
4272 }
4273
4274 /*----------------------------------------------------------------------------------------
4275 Allocate more memory for the Typedef.Initializer heap.
4276 ----------------------------------------------------------------------------------------*/
allocMoreTypedefInitializers(uint32 spaceNeeded)4277 static void allocMoreTypedefInitializers(
4278 uint32 spaceNeeded)
4279 {
4280 uint32 freeSpace = dvAllocatedTypedefInitializer() - dvUsedTypedefInitializer();
4281
4282 if((dvFreeTypedefInitializer() << 2) > dvUsedTypedefInitializer()) {
4283 dvCompactTypedefInitializers();
4284 freeSpace = dvAllocatedTypedefInitializer() - dvUsedTypedefInitializer();
4285 }
4286 if(freeSpace < spaceNeeded) {
4287 dvSetAllocatedTypedefInitializer(dvAllocatedTypedefInitializer() + spaceNeeded - freeSpace +
4288 (dvAllocatedTypedefInitializer() >> 1));
4289 utResizeArray(dvTypedefs.Initializer, dvAllocatedTypedefInitializer());
4290 }
4291 }
4292
4293 /*----------------------------------------------------------------------------------------
4294 Allocate memory for a new Typedef.Initializer array.
4295 ----------------------------------------------------------------------------------------*/
dvTypedefAllocInitializers(dvTypedef Typedef,uint32 numInitializers)4296 void dvTypedefAllocInitializers(
4297 dvTypedef Typedef,
4298 uint32 numInitializers)
4299 {
4300 uint32 freeSpace = dvAllocatedTypedefInitializer() - dvUsedTypedefInitializer();
4301 uint32 elementSize = sizeof(char);
4302 uint32 usedHeaderSize = (sizeof(dvTypedef) + elementSize - 1)/elementSize;
4303 uint32 freeHeaderSize = (sizeof(dvTypedef) + sizeof(uint32) + elementSize - 1)/elementSize;
4304 uint32 spaceNeeded = utMax(numInitializers + usedHeaderSize, freeHeaderSize);
4305
4306 #if defined(DD_DEBUG)
4307 utAssert(dvTypedefGetNumInitializer(Typedef) == 0);
4308 #endif
4309 if(numInitializers == 0) {
4310 return;
4311 }
4312 if(freeSpace < spaceNeeded) {
4313 allocMoreTypedefInitializers(spaceNeeded);
4314 }
4315 dvTypedefSetInitializerIndex(Typedef, dvUsedTypedefInitializer() + usedHeaderSize);
4316 dvTypedefSetNumInitializer(Typedef, numInitializers);
4317 *(dvTypedef *)(void *)(dvTypedefs.Initializer + dvUsedTypedefInitializer()) = Typedef;
4318 memset(dvTypedefs.Initializer + dvTypedefGetInitializerIndex(Typedef), 0, ((numInitializers))*sizeof(char));
4319 dvSetUsedTypedefInitializer(dvUsedTypedefInitializer() + spaceNeeded);
4320 }
4321
4322 /*----------------------------------------------------------------------------------------
4323 Wrapper around dvTypedefGetInitializers for the database manager.
4324 ----------------------------------------------------------------------------------------*/
getTypedefInitializers(uint64 objectNumber,uint32 * numValues)4325 static void *getTypedefInitializers(
4326 uint64 objectNumber,
4327 uint32 *numValues)
4328 {
4329 dvTypedef Typedef = dvIndex2Typedef((uint32)objectNumber);
4330
4331 *numValues = dvTypedefGetNumInitializer(Typedef);
4332 return dvTypedefGetInitializers(Typedef);
4333 }
4334
4335 /*----------------------------------------------------------------------------------------
4336 Wrapper around dvTypedefAllocInitializers for the database manager.
4337 ----------------------------------------------------------------------------------------*/
allocTypedefInitializers(uint64 objectNumber,uint32 numValues)4338 static void *allocTypedefInitializers(
4339 uint64 objectNumber,
4340 uint32 numValues)
4341 {
4342 dvTypedef Typedef = dvIndex2Typedef((uint32)objectNumber);
4343
4344 dvTypedefSetInitializerIndex(Typedef, 0);
4345 dvTypedefSetNumInitializer(Typedef, 0);
4346 if(numValues == 0) {
4347 return NULL;
4348 }
4349 dvTypedefAllocInitializers(Typedef, numValues);
4350 return dvTypedefGetInitializers(Typedef);
4351 }
4352
4353 /*----------------------------------------------------------------------------------------
4354 Free memory used by the Typedef.Initializer array.
4355 ----------------------------------------------------------------------------------------*/
dvTypedefFreeInitializers(dvTypedef Typedef)4356 void dvTypedefFreeInitializers(
4357 dvTypedef Typedef)
4358 {
4359 uint32 elementSize = sizeof(char);
4360 uint32 usedHeaderSize = (sizeof(dvTypedef) + elementSize - 1)/elementSize;
4361 uint32 freeHeaderSize = (sizeof(dvTypedef) + sizeof(uint32) + elementSize - 1)/elementSize;
4362 uint32 size = utMax(dvTypedefGetNumInitializer(Typedef) + usedHeaderSize, freeHeaderSize);
4363 char *dataPtr = dvTypedefGetInitializers(Typedef) - usedHeaderSize;
4364
4365 if(dvTypedefGetNumInitializer(Typedef) == 0) {
4366 return;
4367 }
4368 *(dvTypedef *)(void *)(dataPtr) = dvTypedefNull;
4369 *(uint32 *)(void *)(((dvTypedef *)(void *)dataPtr) + 1) = size;
4370 dvTypedefSetNumInitializer(Typedef, 0);
4371 dvSetFreeTypedefInitializer(dvFreeTypedefInitializer() + size);
4372 }
4373
4374 /*----------------------------------------------------------------------------------------
4375 Resize the Typedef.Initializer array.
4376 ----------------------------------------------------------------------------------------*/
dvTypedefResizeInitializers(dvTypedef Typedef,uint32 numInitializers)4377 void dvTypedefResizeInitializers(
4378 dvTypedef Typedef,
4379 uint32 numInitializers)
4380 {
4381 uint32 freeSpace;
4382 uint32 elementSize = sizeof(char);
4383 uint32 usedHeaderSize = (sizeof(dvTypedef) + elementSize - 1)/elementSize;
4384 uint32 freeHeaderSize = (sizeof(dvTypedef) + sizeof(uint32) + elementSize - 1)/elementSize;
4385 uint32 newSize = utMax(numInitializers + usedHeaderSize, freeHeaderSize);
4386 uint32 oldSize = utMax(dvTypedefGetNumInitializer(Typedef) + usedHeaderSize, freeHeaderSize);
4387 char *dataPtr;
4388
4389 if(numInitializers == 0) {
4390 if(dvTypedefGetNumInitializer(Typedef) != 0) {
4391 dvTypedefFreeInitializers(Typedef);
4392 }
4393 return;
4394 }
4395 if(dvTypedefGetNumInitializer(Typedef) == 0) {
4396 dvTypedefAllocInitializers(Typedef, numInitializers);
4397 return;
4398 }
4399 freeSpace = dvAllocatedTypedefInitializer() - dvUsedTypedefInitializer();
4400 if(freeSpace < newSize) {
4401 allocMoreTypedefInitializers(newSize);
4402 }
4403 dataPtr = dvTypedefGetInitializers(Typedef) - usedHeaderSize;
4404 memcpy((void *)(dvTypedefs.Initializer + dvUsedTypedefInitializer()), dataPtr,
4405 elementSize*utMin(oldSize, newSize));
4406 if(newSize > oldSize) {
4407 memset(dvTypedefs.Initializer + dvUsedTypedefInitializer() + oldSize, 0, ((newSize - oldSize))*sizeof(char));
4408 }
4409 *(dvTypedef *)(void *)dataPtr = dvTypedefNull;
4410 *(uint32 *)(void *)(((dvTypedef *)(void *)dataPtr) + 1) = oldSize;
4411 dvSetFreeTypedefInitializer(dvFreeTypedefInitializer() + oldSize);
4412 dvTypedefSetInitializerIndex(Typedef, dvUsedTypedefInitializer() + usedHeaderSize);
4413 dvTypedefSetNumInitializer(Typedef, numInitializers);
4414 dvSetUsedTypedefInitializer(dvUsedTypedefInitializer() + newSize);
4415 }
4416
4417 /*----------------------------------------------------------------------------------------
4418 Copy the properties of Typedef.
4419 ----------------------------------------------------------------------------------------*/
dvTypedefCopyProps(dvTypedef oldTypedef,dvTypedef newTypedef)4420 void dvTypedefCopyProps(
4421 dvTypedef oldTypedef,
4422 dvTypedef newTypedef)
4423 {
4424 }
4425
4426 #if defined(DD_DEBUG)
4427 /*----------------------------------------------------------------------------------------
4428 Write out all the fields of an object.
4429 ----------------------------------------------------------------------------------------*/
dvShowTypedef(dvTypedef Typedef)4430 void dvShowTypedef(
4431 dvTypedef Typedef)
4432 {
4433 utDatabaseShowObject("dv", "Typedef", dvTypedef2Index(Typedef));
4434 }
4435 #endif
4436
4437 /*----------------------------------------------------------------------------------------
4438 Default constructor wrapper for the database manager.
4439 ----------------------------------------------------------------------------------------*/
allocClass(void)4440 static uint64 allocClass(void)
4441 {
4442 dvClass Class = dvClassAlloc();
4443
4444 return dvClass2Index(Class);
4445 }
4446
4447 /*----------------------------------------------------------------------------------------
4448 Allocate the field arrays of Class.
4449 ----------------------------------------------------------------------------------------*/
allocClasss(void)4450 static void allocClasss(void)
4451 {
4452 dvSetAllocatedClass(2);
4453 dvSetUsedClass(0);
4454 dvClasss.Sym = utNewA(utSym, (dvAllocatedClass()));
4455 dvClasss.MemoryStyle = utNewA(dvMemoryStyle, (dvAllocatedClass()));
4456 dvClasss.ReferenceSize = utNewA(uint8, (dvAllocatedClass()));
4457 dvClasss.GenerateArrayClass = utNewA(uint8, (dvAllocatedClass() + 7) >> 3);
4458 dvClasss.GenerateAttributes = utNewA(uint8, (dvAllocatedClass() + 7) >> 3);
4459 dvClasss.Sparse = utNewA(uint8, (dvAllocatedClass() + 7) >> 3);
4460 dvClasss.NumFields = utNewA(uint16, (dvAllocatedClass()));
4461 dvClasss.Number = utNewA(uint16, (dvAllocatedClass()));
4462 dvClasss.Module = utNewA(dvModule, (dvAllocatedClass()));
4463 dvClasss.NextModuleClass = utNewA(dvClass, (dvAllocatedClass()));
4464 dvClasss.PrevModuleClass = utNewA(dvClass, (dvAllocatedClass()));
4465 dvClasss.NextTableModuleClass = utNewA(dvClass, (dvAllocatedClass()));
4466 dvClasss.FirstProperty = utNewA(dvProperty, (dvAllocatedClass()));
4467 dvClasss.LastProperty = utNewA(dvProperty, (dvAllocatedClass()));
4468 dvClasss.PropertyTableIndex = utNewA(uint32, (dvAllocatedClass()));
4469 dvClasss.NumPropertyTable = utNewA(uint32, (dvAllocatedClass()));
4470 dvSetUsedClassPropertyTable(0);
4471 dvSetAllocatedClassPropertyTable(2);
4472 dvSetFreeClassPropertyTable(0);
4473 dvClasss.PropertyTable = utNewA(dvProperty, dvAllocatedClassPropertyTable());
4474 dvClasss.NumProperty = utNewA(uint32, (dvAllocatedClass()));
4475 dvClasss.FreeListProperty = utNewA(dvProperty, (dvAllocatedClass()));
4476 dvClasss.FirstSparsegroup = utNewA(dvSparsegroup, (dvAllocatedClass()));
4477 dvClasss.LastSparsegroup = utNewA(dvSparsegroup, (dvAllocatedClass()));
4478 dvClasss.SparsegroupTableIndex = utNewA(uint32, (dvAllocatedClass()));
4479 dvClasss.NumSparsegroupTable = utNewA(uint32, (dvAllocatedClass()));
4480 dvSetUsedClassSparsegroupTable(0);
4481 dvSetAllocatedClassSparsegroupTable(2);
4482 dvSetFreeClassSparsegroupTable(0);
4483 dvClasss.SparsegroupTable = utNewA(dvSparsegroup, dvAllocatedClassSparsegroupTable());
4484 dvClasss.NumSparsegroup = utNewA(uint32, (dvAllocatedClass()));
4485 dvClasss.BaseClass = utNewA(dvClass, (dvAllocatedClass()));
4486 dvClasss.FirstDerivedClass = utNewA(dvClass, (dvAllocatedClass()));
4487 dvClasss.NextClassDerivedClass = utNewA(dvClass, (dvAllocatedClass()));
4488 dvClasss.LastDerivedClass = utNewA(dvClass, (dvAllocatedClass()));
4489 dvClasss.FirstChildRelationship = utNewA(dvRelationship, (dvAllocatedClass()));
4490 dvClasss.LastChildRelationship = utNewA(dvRelationship, (dvAllocatedClass()));
4491 dvClasss.FirstParentRelationship = utNewA(dvRelationship, (dvAllocatedClass()));
4492 dvClasss.LastParentRelationship = utNewA(dvRelationship, (dvAllocatedClass()));
4493 dvClasss.FirstUnion = utNewA(dvUnion, (dvAllocatedClass()));
4494 dvClasss.LastUnion = utNewA(dvUnion, (dvAllocatedClass()));
4495 }
4496
4497 /*----------------------------------------------------------------------------------------
4498 Realloc the arrays of properties for class Class.
4499 ----------------------------------------------------------------------------------------*/
reallocClasss(uint32 newSize)4500 static void reallocClasss(
4501 uint32 newSize)
4502 {
4503 utResizeArray(dvClasss.Sym, (newSize));
4504 utResizeArray(dvClasss.MemoryStyle, (newSize));
4505 utResizeArray(dvClasss.ReferenceSize, (newSize));
4506 utResizeArray(dvClasss.GenerateArrayClass, (newSize + 7) >> 3);
4507 utResizeArray(dvClasss.GenerateAttributes, (newSize + 7) >> 3);
4508 utResizeArray(dvClasss.Sparse, (newSize + 7) >> 3);
4509 utResizeArray(dvClasss.NumFields, (newSize));
4510 utResizeArray(dvClasss.Number, (newSize));
4511 utResizeArray(dvClasss.Module, (newSize));
4512 utResizeArray(dvClasss.NextModuleClass, (newSize));
4513 utResizeArray(dvClasss.PrevModuleClass, (newSize));
4514 utResizeArray(dvClasss.NextTableModuleClass, (newSize));
4515 utResizeArray(dvClasss.FirstProperty, (newSize));
4516 utResizeArray(dvClasss.LastProperty, (newSize));
4517 utResizeArray(dvClasss.PropertyTableIndex, (newSize));
4518 utResizeArray(dvClasss.NumPropertyTable, (newSize));
4519 utResizeArray(dvClasss.NumProperty, (newSize));
4520 utResizeArray(dvClasss.FreeListProperty, (newSize));
4521 utResizeArray(dvClasss.FirstSparsegroup, (newSize));
4522 utResizeArray(dvClasss.LastSparsegroup, (newSize));
4523 utResizeArray(dvClasss.SparsegroupTableIndex, (newSize));
4524 utResizeArray(dvClasss.NumSparsegroupTable, (newSize));
4525 utResizeArray(dvClasss.NumSparsegroup, (newSize));
4526 utResizeArray(dvClasss.BaseClass, (newSize));
4527 utResizeArray(dvClasss.FirstDerivedClass, (newSize));
4528 utResizeArray(dvClasss.NextClassDerivedClass, (newSize));
4529 utResizeArray(dvClasss.LastDerivedClass, (newSize));
4530 utResizeArray(dvClasss.FirstChildRelationship, (newSize));
4531 utResizeArray(dvClasss.LastChildRelationship, (newSize));
4532 utResizeArray(dvClasss.FirstParentRelationship, (newSize));
4533 utResizeArray(dvClasss.LastParentRelationship, (newSize));
4534 utResizeArray(dvClasss.FirstUnion, (newSize));
4535 utResizeArray(dvClasss.LastUnion, (newSize));
4536 dvSetAllocatedClass(newSize);
4537 }
4538
4539 /*----------------------------------------------------------------------------------------
4540 Allocate more Classs.
4541 ----------------------------------------------------------------------------------------*/
dvClassAllocMore(void)4542 void dvClassAllocMore(void)
4543 {
4544 reallocClasss((uint32)(dvAllocatedClass() + (dvAllocatedClass() >> 1)));
4545 }
4546
4547 /*----------------------------------------------------------------------------------------
4548 Compact the Class.PropertyTable heap to free memory.
4549 ----------------------------------------------------------------------------------------*/
dvCompactClassPropertyTables(void)4550 void dvCompactClassPropertyTables(void)
4551 {
4552 uint32 elementSize = sizeof(dvProperty);
4553 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4554 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4555 dvProperty *toPtr = dvClasss.PropertyTable;
4556 dvProperty *fromPtr = toPtr;
4557 dvClass Class;
4558 uint32 size;
4559
4560 while(fromPtr < dvClasss.PropertyTable + dvUsedClassPropertyTable()) {
4561 Class = *(dvClass *)(void *)fromPtr;
4562 if(Class != dvClassNull) {
4563 /* Need to move it to toPtr */
4564 size = utMax(dvClassGetNumPropertyTable(Class) + usedHeaderSize, freeHeaderSize);
4565 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
4566 dvClassSetPropertyTableIndex(Class, toPtr - dvClasss.PropertyTable + usedHeaderSize);
4567 toPtr += size;
4568 } else {
4569 /* Just skip it */
4570 size = *(uint32 *)(void *)(((dvClass *)(void *)fromPtr) + 1);
4571 }
4572 fromPtr += size;
4573 }
4574 dvSetUsedClassPropertyTable(toPtr - dvClasss.PropertyTable);
4575 dvSetFreeClassPropertyTable(0);
4576 }
4577
4578 /*----------------------------------------------------------------------------------------
4579 Allocate more memory for the Class.PropertyTable heap.
4580 ----------------------------------------------------------------------------------------*/
allocMoreClassPropertyTables(uint32 spaceNeeded)4581 static void allocMoreClassPropertyTables(
4582 uint32 spaceNeeded)
4583 {
4584 uint32 freeSpace = dvAllocatedClassPropertyTable() - dvUsedClassPropertyTable();
4585
4586 if((dvFreeClassPropertyTable() << 2) > dvUsedClassPropertyTable()) {
4587 dvCompactClassPropertyTables();
4588 freeSpace = dvAllocatedClassPropertyTable() - dvUsedClassPropertyTable();
4589 }
4590 if(freeSpace < spaceNeeded) {
4591 dvSetAllocatedClassPropertyTable(dvAllocatedClassPropertyTable() + spaceNeeded - freeSpace +
4592 (dvAllocatedClassPropertyTable() >> 1));
4593 utResizeArray(dvClasss.PropertyTable, dvAllocatedClassPropertyTable());
4594 }
4595 }
4596
4597 /*----------------------------------------------------------------------------------------
4598 Allocate memory for a new Class.PropertyTable array.
4599 ----------------------------------------------------------------------------------------*/
dvClassAllocPropertyTables(dvClass Class,uint32 numPropertyTables)4600 void dvClassAllocPropertyTables(
4601 dvClass Class,
4602 uint32 numPropertyTables)
4603 {
4604 uint32 freeSpace = dvAllocatedClassPropertyTable() - dvUsedClassPropertyTable();
4605 uint32 elementSize = sizeof(dvProperty);
4606 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4607 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4608 uint32 spaceNeeded = utMax(numPropertyTables + usedHeaderSize, freeHeaderSize);
4609
4610 #if defined(DD_DEBUG)
4611 utAssert(dvClassGetNumPropertyTable(Class) == 0);
4612 #endif
4613 if(numPropertyTables == 0) {
4614 return;
4615 }
4616 if(freeSpace < spaceNeeded) {
4617 allocMoreClassPropertyTables(spaceNeeded);
4618 }
4619 dvClassSetPropertyTableIndex(Class, dvUsedClassPropertyTable() + usedHeaderSize);
4620 dvClassSetNumPropertyTable(Class, numPropertyTables);
4621 *(dvClass *)(void *)(dvClasss.PropertyTable + dvUsedClassPropertyTable()) = Class;
4622 {
4623 uint32 xClass;
4624 for(xClass = (uint32)(dvClassGetPropertyTableIndex(Class)); xClass < dvClassGetPropertyTableIndex(Class) + numPropertyTables; xClass++) {
4625 dvClasss.PropertyTable[xClass] = dvPropertyNull;
4626 }
4627 }
4628 dvSetUsedClassPropertyTable(dvUsedClassPropertyTable() + spaceNeeded);
4629 }
4630
4631 /*----------------------------------------------------------------------------------------
4632 Wrapper around dvClassGetPropertyTables for the database manager.
4633 ----------------------------------------------------------------------------------------*/
getClassPropertyTables(uint64 objectNumber,uint32 * numValues)4634 static void *getClassPropertyTables(
4635 uint64 objectNumber,
4636 uint32 *numValues)
4637 {
4638 dvClass Class = dvIndex2Class((uint32)objectNumber);
4639
4640 *numValues = dvClassGetNumPropertyTable(Class);
4641 return dvClassGetPropertyTables(Class);
4642 }
4643
4644 /*----------------------------------------------------------------------------------------
4645 Wrapper around dvClassAllocPropertyTables for the database manager.
4646 ----------------------------------------------------------------------------------------*/
allocClassPropertyTables(uint64 objectNumber,uint32 numValues)4647 static void *allocClassPropertyTables(
4648 uint64 objectNumber,
4649 uint32 numValues)
4650 {
4651 dvClass Class = dvIndex2Class((uint32)objectNumber);
4652
4653 dvClassSetPropertyTableIndex(Class, 0);
4654 dvClassSetNumPropertyTable(Class, 0);
4655 if(numValues == 0) {
4656 return NULL;
4657 }
4658 dvClassAllocPropertyTables(Class, numValues);
4659 return dvClassGetPropertyTables(Class);
4660 }
4661
4662 /*----------------------------------------------------------------------------------------
4663 Free memory used by the Class.PropertyTable array.
4664 ----------------------------------------------------------------------------------------*/
dvClassFreePropertyTables(dvClass Class)4665 void dvClassFreePropertyTables(
4666 dvClass Class)
4667 {
4668 uint32 elementSize = sizeof(dvProperty);
4669 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4670 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4671 uint32 size = utMax(dvClassGetNumPropertyTable(Class) + usedHeaderSize, freeHeaderSize);
4672 dvProperty *dataPtr = dvClassGetPropertyTables(Class) - usedHeaderSize;
4673
4674 if(dvClassGetNumPropertyTable(Class) == 0) {
4675 return;
4676 }
4677 *(dvClass *)(void *)(dataPtr) = dvClassNull;
4678 *(uint32 *)(void *)(((dvClass *)(void *)dataPtr) + 1) = size;
4679 dvClassSetNumPropertyTable(Class, 0);
4680 dvSetFreeClassPropertyTable(dvFreeClassPropertyTable() + size);
4681 }
4682
4683 /*----------------------------------------------------------------------------------------
4684 Resize the Class.PropertyTable array.
4685 ----------------------------------------------------------------------------------------*/
dvClassResizePropertyTables(dvClass Class,uint32 numPropertyTables)4686 void dvClassResizePropertyTables(
4687 dvClass Class,
4688 uint32 numPropertyTables)
4689 {
4690 uint32 freeSpace;
4691 uint32 elementSize = sizeof(dvProperty);
4692 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4693 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4694 uint32 newSize = utMax(numPropertyTables + usedHeaderSize, freeHeaderSize);
4695 uint32 oldSize = utMax(dvClassGetNumPropertyTable(Class) + usedHeaderSize, freeHeaderSize);
4696 dvProperty *dataPtr;
4697
4698 if(numPropertyTables == 0) {
4699 if(dvClassGetNumPropertyTable(Class) != 0) {
4700 dvClassFreePropertyTables(Class);
4701 }
4702 return;
4703 }
4704 if(dvClassGetNumPropertyTable(Class) == 0) {
4705 dvClassAllocPropertyTables(Class, numPropertyTables);
4706 return;
4707 }
4708 freeSpace = dvAllocatedClassPropertyTable() - dvUsedClassPropertyTable();
4709 if(freeSpace < newSize) {
4710 allocMoreClassPropertyTables(newSize);
4711 }
4712 dataPtr = dvClassGetPropertyTables(Class) - usedHeaderSize;
4713 memcpy((void *)(dvClasss.PropertyTable + dvUsedClassPropertyTable()), dataPtr,
4714 elementSize*utMin(oldSize, newSize));
4715 if(newSize > oldSize) {
4716 {
4717 uint32 xClass;
4718 for(xClass = (uint32)(dvUsedClassPropertyTable() + oldSize); xClass < dvUsedClassPropertyTable() + oldSize + newSize - oldSize; xClass++) {
4719 dvClasss.PropertyTable[xClass] = dvPropertyNull;
4720 }
4721 }
4722 }
4723 *(dvClass *)(void *)dataPtr = dvClassNull;
4724 *(uint32 *)(void *)(((dvClass *)(void *)dataPtr) + 1) = oldSize;
4725 dvSetFreeClassPropertyTable(dvFreeClassPropertyTable() + oldSize);
4726 dvClassSetPropertyTableIndex(Class, dvUsedClassPropertyTable() + usedHeaderSize);
4727 dvClassSetNumPropertyTable(Class, numPropertyTables);
4728 dvSetUsedClassPropertyTable(dvUsedClassPropertyTable() + newSize);
4729 }
4730
4731 /*----------------------------------------------------------------------------------------
4732 Compact the Class.SparsegroupTable heap to free memory.
4733 ----------------------------------------------------------------------------------------*/
dvCompactClassSparsegroupTables(void)4734 void dvCompactClassSparsegroupTables(void)
4735 {
4736 uint32 elementSize = sizeof(dvSparsegroup);
4737 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4738 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4739 dvSparsegroup *toPtr = dvClasss.SparsegroupTable;
4740 dvSparsegroup *fromPtr = toPtr;
4741 dvClass Class;
4742 uint32 size;
4743
4744 while(fromPtr < dvClasss.SparsegroupTable + dvUsedClassSparsegroupTable()) {
4745 Class = *(dvClass *)(void *)fromPtr;
4746 if(Class != dvClassNull) {
4747 /* Need to move it to toPtr */
4748 size = utMax(dvClassGetNumSparsegroupTable(Class) + usedHeaderSize, freeHeaderSize);
4749 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
4750 dvClassSetSparsegroupTableIndex(Class, toPtr - dvClasss.SparsegroupTable + usedHeaderSize);
4751 toPtr += size;
4752 } else {
4753 /* Just skip it */
4754 size = *(uint32 *)(void *)(((dvClass *)(void *)fromPtr) + 1);
4755 }
4756 fromPtr += size;
4757 }
4758 dvSetUsedClassSparsegroupTable(toPtr - dvClasss.SparsegroupTable);
4759 dvSetFreeClassSparsegroupTable(0);
4760 }
4761
4762 /*----------------------------------------------------------------------------------------
4763 Allocate more memory for the Class.SparsegroupTable heap.
4764 ----------------------------------------------------------------------------------------*/
allocMoreClassSparsegroupTables(uint32 spaceNeeded)4765 static void allocMoreClassSparsegroupTables(
4766 uint32 spaceNeeded)
4767 {
4768 uint32 freeSpace = dvAllocatedClassSparsegroupTable() - dvUsedClassSparsegroupTable();
4769
4770 if((dvFreeClassSparsegroupTable() << 2) > dvUsedClassSparsegroupTable()) {
4771 dvCompactClassSparsegroupTables();
4772 freeSpace = dvAllocatedClassSparsegroupTable() - dvUsedClassSparsegroupTable();
4773 }
4774 if(freeSpace < spaceNeeded) {
4775 dvSetAllocatedClassSparsegroupTable(dvAllocatedClassSparsegroupTable() + spaceNeeded - freeSpace +
4776 (dvAllocatedClassSparsegroupTable() >> 1));
4777 utResizeArray(dvClasss.SparsegroupTable, dvAllocatedClassSparsegroupTable());
4778 }
4779 }
4780
4781 /*----------------------------------------------------------------------------------------
4782 Allocate memory for a new Class.SparsegroupTable array.
4783 ----------------------------------------------------------------------------------------*/
dvClassAllocSparsegroupTables(dvClass Class,uint32 numSparsegroupTables)4784 void dvClassAllocSparsegroupTables(
4785 dvClass Class,
4786 uint32 numSparsegroupTables)
4787 {
4788 uint32 freeSpace = dvAllocatedClassSparsegroupTable() - dvUsedClassSparsegroupTable();
4789 uint32 elementSize = sizeof(dvSparsegroup);
4790 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4791 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4792 uint32 spaceNeeded = utMax(numSparsegroupTables + usedHeaderSize, freeHeaderSize);
4793
4794 #if defined(DD_DEBUG)
4795 utAssert(dvClassGetNumSparsegroupTable(Class) == 0);
4796 #endif
4797 if(numSparsegroupTables == 0) {
4798 return;
4799 }
4800 if(freeSpace < spaceNeeded) {
4801 allocMoreClassSparsegroupTables(spaceNeeded);
4802 }
4803 dvClassSetSparsegroupTableIndex(Class, dvUsedClassSparsegroupTable() + usedHeaderSize);
4804 dvClassSetNumSparsegroupTable(Class, numSparsegroupTables);
4805 *(dvClass *)(void *)(dvClasss.SparsegroupTable + dvUsedClassSparsegroupTable()) = Class;
4806 {
4807 uint32 xClass;
4808 for(xClass = (uint32)(dvClassGetSparsegroupTableIndex(Class)); xClass < dvClassGetSparsegroupTableIndex(Class) + numSparsegroupTables; xClass++) {
4809 dvClasss.SparsegroupTable[xClass] = dvSparsegroupNull;
4810 }
4811 }
4812 dvSetUsedClassSparsegroupTable(dvUsedClassSparsegroupTable() + spaceNeeded);
4813 }
4814
4815 /*----------------------------------------------------------------------------------------
4816 Wrapper around dvClassGetSparsegroupTables for the database manager.
4817 ----------------------------------------------------------------------------------------*/
getClassSparsegroupTables(uint64 objectNumber,uint32 * numValues)4818 static void *getClassSparsegroupTables(
4819 uint64 objectNumber,
4820 uint32 *numValues)
4821 {
4822 dvClass Class = dvIndex2Class((uint32)objectNumber);
4823
4824 *numValues = dvClassGetNumSparsegroupTable(Class);
4825 return dvClassGetSparsegroupTables(Class);
4826 }
4827
4828 /*----------------------------------------------------------------------------------------
4829 Wrapper around dvClassAllocSparsegroupTables for the database manager.
4830 ----------------------------------------------------------------------------------------*/
allocClassSparsegroupTables(uint64 objectNumber,uint32 numValues)4831 static void *allocClassSparsegroupTables(
4832 uint64 objectNumber,
4833 uint32 numValues)
4834 {
4835 dvClass Class = dvIndex2Class((uint32)objectNumber);
4836
4837 dvClassSetSparsegroupTableIndex(Class, 0);
4838 dvClassSetNumSparsegroupTable(Class, 0);
4839 if(numValues == 0) {
4840 return NULL;
4841 }
4842 dvClassAllocSparsegroupTables(Class, numValues);
4843 return dvClassGetSparsegroupTables(Class);
4844 }
4845
4846 /*----------------------------------------------------------------------------------------
4847 Free memory used by the Class.SparsegroupTable array.
4848 ----------------------------------------------------------------------------------------*/
dvClassFreeSparsegroupTables(dvClass Class)4849 void dvClassFreeSparsegroupTables(
4850 dvClass Class)
4851 {
4852 uint32 elementSize = sizeof(dvSparsegroup);
4853 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4854 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4855 uint32 size = utMax(dvClassGetNumSparsegroupTable(Class) + usedHeaderSize, freeHeaderSize);
4856 dvSparsegroup *dataPtr = dvClassGetSparsegroupTables(Class) - usedHeaderSize;
4857
4858 if(dvClassGetNumSparsegroupTable(Class) == 0) {
4859 return;
4860 }
4861 *(dvClass *)(void *)(dataPtr) = dvClassNull;
4862 *(uint32 *)(void *)(((dvClass *)(void *)dataPtr) + 1) = size;
4863 dvClassSetNumSparsegroupTable(Class, 0);
4864 dvSetFreeClassSparsegroupTable(dvFreeClassSparsegroupTable() + size);
4865 }
4866
4867 /*----------------------------------------------------------------------------------------
4868 Resize the Class.SparsegroupTable array.
4869 ----------------------------------------------------------------------------------------*/
dvClassResizeSparsegroupTables(dvClass Class,uint32 numSparsegroupTables)4870 void dvClassResizeSparsegroupTables(
4871 dvClass Class,
4872 uint32 numSparsegroupTables)
4873 {
4874 uint32 freeSpace;
4875 uint32 elementSize = sizeof(dvSparsegroup);
4876 uint32 usedHeaderSize = (sizeof(dvClass) + elementSize - 1)/elementSize;
4877 uint32 freeHeaderSize = (sizeof(dvClass) + sizeof(uint32) + elementSize - 1)/elementSize;
4878 uint32 newSize = utMax(numSparsegroupTables + usedHeaderSize, freeHeaderSize);
4879 uint32 oldSize = utMax(dvClassGetNumSparsegroupTable(Class) + usedHeaderSize, freeHeaderSize);
4880 dvSparsegroup *dataPtr;
4881
4882 if(numSparsegroupTables == 0) {
4883 if(dvClassGetNumSparsegroupTable(Class) != 0) {
4884 dvClassFreeSparsegroupTables(Class);
4885 }
4886 return;
4887 }
4888 if(dvClassGetNumSparsegroupTable(Class) == 0) {
4889 dvClassAllocSparsegroupTables(Class, numSparsegroupTables);
4890 return;
4891 }
4892 freeSpace = dvAllocatedClassSparsegroupTable() - dvUsedClassSparsegroupTable();
4893 if(freeSpace < newSize) {
4894 allocMoreClassSparsegroupTables(newSize);
4895 }
4896 dataPtr = dvClassGetSparsegroupTables(Class) - usedHeaderSize;
4897 memcpy((void *)(dvClasss.SparsegroupTable + dvUsedClassSparsegroupTable()), dataPtr,
4898 elementSize*utMin(oldSize, newSize));
4899 if(newSize > oldSize) {
4900 {
4901 uint32 xClass;
4902 for(xClass = (uint32)(dvUsedClassSparsegroupTable() + oldSize); xClass < dvUsedClassSparsegroupTable() + oldSize + newSize - oldSize; xClass++) {
4903 dvClasss.SparsegroupTable[xClass] = dvSparsegroupNull;
4904 }
4905 }
4906 }
4907 *(dvClass *)(void *)dataPtr = dvClassNull;
4908 *(uint32 *)(void *)(((dvClass *)(void *)dataPtr) + 1) = oldSize;
4909 dvSetFreeClassSparsegroupTable(dvFreeClassSparsegroupTable() + oldSize);
4910 dvClassSetSparsegroupTableIndex(Class, dvUsedClassSparsegroupTable() + usedHeaderSize);
4911 dvClassSetNumSparsegroupTable(Class, numSparsegroupTables);
4912 dvSetUsedClassSparsegroupTable(dvUsedClassSparsegroupTable() + newSize);
4913 }
4914
4915 /*----------------------------------------------------------------------------------------
4916 Copy the properties of Class.
4917 ----------------------------------------------------------------------------------------*/
dvClassCopyProps(dvClass oldClass,dvClass newClass)4918 void dvClassCopyProps(
4919 dvClass oldClass,
4920 dvClass newClass)
4921 {
4922 dvClassSetMemoryStyle(newClass, dvClassGetMemoryStyle(oldClass));
4923 dvClassSetReferenceSize(newClass, dvClassGetReferenceSize(oldClass));
4924 dvClassSetGenerateArrayClass(newClass, dvClassGenerateArrayClass(oldClass));
4925 dvClassSetGenerateAttributes(newClass, dvClassGenerateAttributes(oldClass));
4926 dvClassSetSparse(newClass, dvClassSparse(oldClass));
4927 dvClassSetNumFields(newClass, dvClassGetNumFields(oldClass));
4928 dvClassSetNumber(newClass, dvClassGetNumber(oldClass));
4929 }
4930
4931 /*----------------------------------------------------------------------------------------
4932 Return the integer equivalent for the bit fields in Class.
4933 ----------------------------------------------------------------------------------------*/
dvClassGetBitfield(dvClass _Class)4934 uint32 dvClassGetBitfield(
4935 dvClass _Class)
4936 {
4937 uint32 bitfield = 0;
4938 uint8 xLevel = 0;
4939
4940 bitfield |= dvClassGenerateArrayClass(_Class) << xLevel++;
4941 bitfield |= dvClassGenerateAttributes(_Class) << xLevel++;
4942 bitfield |= dvClassSparse(_Class) << xLevel++;
4943 return bitfield;
4944 }
4945
4946 /*----------------------------------------------------------------------------------------
4947 Set bit fields in Class using bitfield.
4948 ----------------------------------------------------------------------------------------*/
dvClassSetBitfield(dvClass _Class,uint32 bitfield)4949 void dvClassSetBitfield(
4950 dvClass _Class,
4951 uint32 bitfield)
4952 {
4953 dvClassSetGenerateArrayClass(_Class, bitfield & 1);
4954 bitfield >>= 1;
4955 dvClassSetGenerateAttributes(_Class, bitfield & 1);
4956 bitfield >>= 1;
4957 dvClassSetSparse(_Class, bitfield & 1);
4958 bitfield >>= 1;
4959 }
4960
4961 static void addClassPropertyToHashTable(dvClass Class, dvProperty _Property);
4962 /*----------------------------------------------------------------------------------------
4963 Increase the size of the hash table.
4964 ----------------------------------------------------------------------------------------*/
resizeClassPropertyHashTable(dvClass Class)4965 static void resizeClassPropertyHashTable(
4966 dvClass Class)
4967 {
4968 dvProperty _Property;
4969 dvProperty *Propertys;
4970 uint32 numPropertys = dvClassGetNumPropertyTable(Class) << 1;
4971
4972 if(numPropertys == 0) {
4973 numPropertys = 2;
4974 dvClassAllocPropertyTables(Class, 2);
4975 } else {
4976 dvClassResizePropertyTables(Class, numPropertys);
4977 }
4978 Propertys = dvClassGetPropertyTables(Class);
4979 /* Zero out the table */
4980 while(numPropertys-- != 0) {
4981 *Propertys++ = dvPropertyNull;
4982 }
4983 dvClassSetNumProperty(Class, 0);
4984 dvForeachClassProperty(Class, _Property) {
4985 if(dvPropertyGetSym(_Property) != utSymNull) {
4986 addClassPropertyToHashTable(Class, _Property);
4987 }
4988 } dvEndClassProperty;
4989 }
4990
4991 /*----------------------------------------------------------------------------------------
4992 Add the Property to the Class. If the table is near full, build a new one twice
4993 as big, delete the old one, and return the new one.
4994 ----------------------------------------------------------------------------------------*/
addClassPropertyToHashTable(dvClass Class,dvProperty _Property)4995 static void addClassPropertyToHashTable(
4996 dvClass Class,
4997 dvProperty _Property)
4998 {
4999 dvProperty nextProperty;
5000 uint32 index;
5001
5002 if(dvClassGetNumProperty(Class) >= dvClassGetNumPropertyTable(Class)) {
5003 resizeClassPropertyHashTable(Class);
5004 return;
5005 }
5006 index = (dvClassGetNumPropertyTable(Class) - 1) & utSymGetHashValue(dvPropertyGetSym(_Property));
5007 nextProperty = dvClassGetiPropertyTable(Class, index);
5008 dvPropertySetNextTableClassProperty(_Property, nextProperty);
5009 dvClassSetiPropertyTable(Class, index, _Property);
5010 dvClassSetNumProperty(Class, dvClassGetNumProperty(Class) + 1);
5011 }
5012
5013 /*----------------------------------------------------------------------------------------
5014 Remove the Property from the hash table.
5015 ----------------------------------------------------------------------------------------*/
removeClassPropertyFromHashTable(dvClass Class,dvProperty _Property)5016 static void removeClassPropertyFromHashTable(
5017 dvClass Class,
5018 dvProperty _Property)
5019 {
5020 uint32 index = (dvClassGetNumPropertyTable(Class) - 1) & utSymGetHashValue(dvPropertyGetSym(_Property));
5021 dvProperty prevProperty, nextProperty;
5022
5023 nextProperty = dvClassGetiPropertyTable(Class, index);
5024 if(nextProperty == _Property) {
5025 dvClassSetiPropertyTable(Class, index, dvPropertyGetNextTableClassProperty(nextProperty));
5026 } else {
5027 do {
5028 prevProperty = nextProperty;
5029 nextProperty = dvPropertyGetNextTableClassProperty(nextProperty);
5030 } while(nextProperty != _Property);
5031 dvPropertySetNextTableClassProperty(prevProperty, dvPropertyGetNextTableClassProperty(_Property));
5032 }
5033 dvClassSetNumProperty(Class, dvClassGetNumProperty(Class) - 1);
5034 dvPropertySetNextTableClassProperty(_Property, dvPropertyNull);
5035 }
5036
5037 /*----------------------------------------------------------------------------------------
5038 Find the Property from the Class and its hash key.
5039 ----------------------------------------------------------------------------------------*/
dvClassFindProperty(dvClass Class,utSym Sym)5040 dvProperty dvClassFindProperty(
5041 dvClass Class,
5042 utSym Sym)
5043 {
5044 uint32 mask = dvClassGetNumPropertyTable(Class) - 1;
5045 dvProperty _Property;
5046
5047 if(mask + 1 != 0) {
5048 _Property = dvClassGetiPropertyTable(Class, utSymGetHashValue(Sym) & mask);
5049 while(_Property != dvPropertyNull) {
5050 if(dvPropertyGetSym(_Property) == Sym) {
5051 return _Property;
5052 }
5053 _Property = dvPropertyGetNextTableClassProperty(_Property);
5054 }
5055 }
5056 return dvPropertyNull;
5057 }
5058
5059 /*----------------------------------------------------------------------------------------
5060 Find the Property from the Class and its name.
5061 ----------------------------------------------------------------------------------------*/
dvClassRenameProperty(dvClass Class,dvProperty _Property,utSym sym)5062 void dvClassRenameProperty(
5063 dvClass Class,
5064 dvProperty _Property,
5065 utSym sym)
5066 {
5067 if(dvPropertyGetSym(_Property) != utSymNull) {
5068 removeClassPropertyFromHashTable(Class, _Property);
5069 }
5070 dvPropertySetSym(_Property, sym);
5071 if(sym != utSymNull) {
5072 addClassPropertyToHashTable(Class, _Property);
5073 }
5074 }
5075
5076 /*----------------------------------------------------------------------------------------
5077 Add the Property to the head of the list on the Class.
5078 ----------------------------------------------------------------------------------------*/
dvClassInsertProperty(dvClass Class,dvProperty _Property)5079 void dvClassInsertProperty(
5080 dvClass Class,
5081 dvProperty _Property)
5082 {
5083 #if defined(DD_DEBUG)
5084 if(Class == dvClassNull) {
5085 utExit("Non-existent Class");
5086 }
5087 if(_Property == dvPropertyNull) {
5088 utExit("Non-existent Property");
5089 }
5090 if(dvPropertyGetClass(_Property) != dvClassNull) {
5091 utExit("Attempting to add Property to Class twice");
5092 }
5093 #endif
5094 dvPropertySetNextClassProperty(_Property, dvClassGetFirstProperty(Class));
5095 if(dvClassGetFirstProperty(Class) != dvPropertyNull) {
5096 dvPropertySetPrevClassProperty(dvClassGetFirstProperty(Class), _Property);
5097 }
5098 dvClassSetFirstProperty(Class, _Property);
5099 dvPropertySetPrevClassProperty(_Property, dvPropertyNull);
5100 if(dvClassGetLastProperty(Class) == dvPropertyNull) {
5101 dvClassSetLastProperty(Class, _Property);
5102 }
5103 dvPropertySetClass(_Property, Class);
5104 if(dvPropertyGetSym(_Property) != utSymNull) {
5105 addClassPropertyToHashTable(Class, _Property);
5106 }
5107 }
5108
5109 /*----------------------------------------------------------------------------------------
5110 Add the Property to the end of the list on the Class.
5111 ----------------------------------------------------------------------------------------*/
dvClassAppendProperty(dvClass Class,dvProperty _Property)5112 void dvClassAppendProperty(
5113 dvClass Class,
5114 dvProperty _Property)
5115 {
5116 #if defined(DD_DEBUG)
5117 if(Class == dvClassNull) {
5118 utExit("Non-existent Class");
5119 }
5120 if(_Property == dvPropertyNull) {
5121 utExit("Non-existent Property");
5122 }
5123 if(dvPropertyGetClass(_Property) != dvClassNull) {
5124 utExit("Attempting to add Property to Class twice");
5125 }
5126 #endif
5127 dvPropertySetPrevClassProperty(_Property, dvClassGetLastProperty(Class));
5128 if(dvClassGetLastProperty(Class) != dvPropertyNull) {
5129 dvPropertySetNextClassProperty(dvClassGetLastProperty(Class), _Property);
5130 }
5131 dvClassSetLastProperty(Class, _Property);
5132 dvPropertySetNextClassProperty(_Property, dvPropertyNull);
5133 if(dvClassGetFirstProperty(Class) == dvPropertyNull) {
5134 dvClassSetFirstProperty(Class, _Property);
5135 }
5136 dvPropertySetClass(_Property, Class);
5137 if(dvPropertyGetSym(_Property) != utSymNull) {
5138 addClassPropertyToHashTable(Class, _Property);
5139 }
5140 }
5141
5142 /*----------------------------------------------------------------------------------------
5143 Insert the Property to the Class after the previous Property.
5144 ----------------------------------------------------------------------------------------*/
dvClassInsertAfterProperty(dvClass Class,dvProperty prevProperty,dvProperty _Property)5145 void dvClassInsertAfterProperty(
5146 dvClass Class,
5147 dvProperty prevProperty,
5148 dvProperty _Property)
5149 {
5150 dvProperty nextProperty = dvPropertyGetNextClassProperty(prevProperty);
5151
5152 #if defined(DD_DEBUG)
5153 if(Class == dvClassNull) {
5154 utExit("Non-existent Class");
5155 }
5156 if(_Property == dvPropertyNull) {
5157 utExit("Non-existent Property");
5158 }
5159 if(dvPropertyGetClass(_Property) != dvClassNull) {
5160 utExit("Attempting to add Property to Class twice");
5161 }
5162 #endif
5163 dvPropertySetNextClassProperty(_Property, nextProperty);
5164 dvPropertySetNextClassProperty(prevProperty, _Property);
5165 dvPropertySetPrevClassProperty(_Property, prevProperty);
5166 if(nextProperty != dvPropertyNull) {
5167 dvPropertySetPrevClassProperty(nextProperty, _Property);
5168 }
5169 if(dvClassGetLastProperty(Class) == prevProperty) {
5170 dvClassSetLastProperty(Class, _Property);
5171 }
5172 dvPropertySetClass(_Property, Class);
5173 if(dvPropertyGetSym(_Property) != utSymNull) {
5174 addClassPropertyToHashTable(Class, _Property);
5175 }
5176 }
5177
5178 /*----------------------------------------------------------------------------------------
5179 Remove the Property from the Class.
5180 ----------------------------------------------------------------------------------------*/
dvClassRemoveProperty(dvClass Class,dvProperty _Property)5181 void dvClassRemoveProperty(
5182 dvClass Class,
5183 dvProperty _Property)
5184 {
5185 dvProperty pProperty, nProperty;
5186
5187 #if defined(DD_DEBUG)
5188 if(_Property == dvPropertyNull) {
5189 utExit("Non-existent Property");
5190 }
5191 if(dvPropertyGetClass(_Property) != dvClassNull && dvPropertyGetClass(_Property) != Class) {
5192 utExit("Delete Property from non-owning Class");
5193 }
5194 #endif
5195 nProperty = dvPropertyGetNextClassProperty(_Property);
5196 pProperty = dvPropertyGetPrevClassProperty(_Property);
5197 if(pProperty != dvPropertyNull) {
5198 dvPropertySetNextClassProperty(pProperty, nProperty);
5199 } else if(dvClassGetFirstProperty(Class) == _Property) {
5200 dvClassSetFirstProperty(Class, nProperty);
5201 }
5202 if(nProperty != dvPropertyNull) {
5203 dvPropertySetPrevClassProperty(nProperty, pProperty);
5204 } else if(dvClassGetLastProperty(Class) == _Property) {
5205 dvClassSetLastProperty(Class, pProperty);
5206 }
5207 dvPropertySetNextClassProperty(_Property, dvPropertyNull);
5208 dvPropertySetPrevClassProperty(_Property, dvPropertyNull);
5209 dvPropertySetClass(_Property, dvClassNull);
5210 if(dvPropertyGetSym(_Property) != utSymNull) {
5211 removeClassPropertyFromHashTable(Class, _Property);
5212 }
5213 }
5214
5215 static void addClassSparsegroupToHashTable(dvClass Class, dvSparsegroup _Sparsegroup);
5216 /*----------------------------------------------------------------------------------------
5217 Increase the size of the hash table.
5218 ----------------------------------------------------------------------------------------*/
resizeClassSparsegroupHashTable(dvClass Class)5219 static void resizeClassSparsegroupHashTable(
5220 dvClass Class)
5221 {
5222 dvSparsegroup _Sparsegroup;
5223 dvSparsegroup *Sparsegroups;
5224 uint32 numSparsegroups = dvClassGetNumSparsegroupTable(Class) << 1;
5225
5226 if(numSparsegroups == 0) {
5227 numSparsegroups = 2;
5228 dvClassAllocSparsegroupTables(Class, 2);
5229 } else {
5230 dvClassResizeSparsegroupTables(Class, numSparsegroups);
5231 }
5232 Sparsegroups = dvClassGetSparsegroupTables(Class);
5233 /* Zero out the table */
5234 while(numSparsegroups-- != 0) {
5235 *Sparsegroups++ = dvSparsegroupNull;
5236 }
5237 dvClassSetNumSparsegroup(Class, 0);
5238 dvForeachClassSparsegroup(Class, _Sparsegroup) {
5239 if(dvSparsegroupGetSym(_Sparsegroup) != utSymNull) {
5240 addClassSparsegroupToHashTable(Class, _Sparsegroup);
5241 }
5242 } dvEndClassSparsegroup;
5243 }
5244
5245 /*----------------------------------------------------------------------------------------
5246 Add the Sparsegroup to the Class. If the table is near full, build a new one twice
5247 as big, delete the old one, and return the new one.
5248 ----------------------------------------------------------------------------------------*/
addClassSparsegroupToHashTable(dvClass Class,dvSparsegroup _Sparsegroup)5249 static void addClassSparsegroupToHashTable(
5250 dvClass Class,
5251 dvSparsegroup _Sparsegroup)
5252 {
5253 dvSparsegroup nextSparsegroup;
5254 uint32 index;
5255
5256 if(dvClassGetNumSparsegroup(Class) >= dvClassGetNumSparsegroupTable(Class)) {
5257 resizeClassSparsegroupHashTable(Class);
5258 return;
5259 }
5260 index = (dvClassGetNumSparsegroupTable(Class) - 1) & utSymGetHashValue(dvSparsegroupGetSym(_Sparsegroup));
5261 nextSparsegroup = dvClassGetiSparsegroupTable(Class, index);
5262 dvSparsegroupSetNextTableClassSparsegroup(_Sparsegroup, nextSparsegroup);
5263 dvClassSetiSparsegroupTable(Class, index, _Sparsegroup);
5264 dvClassSetNumSparsegroup(Class, dvClassGetNumSparsegroup(Class) + 1);
5265 }
5266
5267 /*----------------------------------------------------------------------------------------
5268 Remove the Sparsegroup from the hash table.
5269 ----------------------------------------------------------------------------------------*/
removeClassSparsegroupFromHashTable(dvClass Class,dvSparsegroup _Sparsegroup)5270 static void removeClassSparsegroupFromHashTable(
5271 dvClass Class,
5272 dvSparsegroup _Sparsegroup)
5273 {
5274 uint32 index = (dvClassGetNumSparsegroupTable(Class) - 1) & utSymGetHashValue(dvSparsegroupGetSym(_Sparsegroup));
5275 dvSparsegroup prevSparsegroup, nextSparsegroup;
5276
5277 nextSparsegroup = dvClassGetiSparsegroupTable(Class, index);
5278 if(nextSparsegroup == _Sparsegroup) {
5279 dvClassSetiSparsegroupTable(Class, index, dvSparsegroupGetNextTableClassSparsegroup(nextSparsegroup));
5280 } else {
5281 do {
5282 prevSparsegroup = nextSparsegroup;
5283 nextSparsegroup = dvSparsegroupGetNextTableClassSparsegroup(nextSparsegroup);
5284 } while(nextSparsegroup != _Sparsegroup);
5285 dvSparsegroupSetNextTableClassSparsegroup(prevSparsegroup, dvSparsegroupGetNextTableClassSparsegroup(_Sparsegroup));
5286 }
5287 dvClassSetNumSparsegroup(Class, dvClassGetNumSparsegroup(Class) - 1);
5288 dvSparsegroupSetNextTableClassSparsegroup(_Sparsegroup, dvSparsegroupNull);
5289 }
5290
5291 /*----------------------------------------------------------------------------------------
5292 Find the Sparsegroup from the Class and its hash key.
5293 ----------------------------------------------------------------------------------------*/
dvClassFindSparsegroup(dvClass Class,utSym Sym)5294 dvSparsegroup dvClassFindSparsegroup(
5295 dvClass Class,
5296 utSym Sym)
5297 {
5298 uint32 mask = dvClassGetNumSparsegroupTable(Class) - 1;
5299 dvSparsegroup _Sparsegroup;
5300
5301 if(mask + 1 != 0) {
5302 _Sparsegroup = dvClassGetiSparsegroupTable(Class, utSymGetHashValue(Sym) & mask);
5303 while(_Sparsegroup != dvSparsegroupNull) {
5304 if(dvSparsegroupGetSym(_Sparsegroup) == Sym) {
5305 return _Sparsegroup;
5306 }
5307 _Sparsegroup = dvSparsegroupGetNextTableClassSparsegroup(_Sparsegroup);
5308 }
5309 }
5310 return dvSparsegroupNull;
5311 }
5312
5313 /*----------------------------------------------------------------------------------------
5314 Find the Sparsegroup from the Class and its name.
5315 ----------------------------------------------------------------------------------------*/
dvClassRenameSparsegroup(dvClass Class,dvSparsegroup _Sparsegroup,utSym sym)5316 void dvClassRenameSparsegroup(
5317 dvClass Class,
5318 dvSparsegroup _Sparsegroup,
5319 utSym sym)
5320 {
5321 if(dvSparsegroupGetSym(_Sparsegroup) != utSymNull) {
5322 removeClassSparsegroupFromHashTable(Class, _Sparsegroup);
5323 }
5324 dvSparsegroupSetSym(_Sparsegroup, sym);
5325 if(sym != utSymNull) {
5326 addClassSparsegroupToHashTable(Class, _Sparsegroup);
5327 }
5328 }
5329
5330 /*----------------------------------------------------------------------------------------
5331 Add the Sparsegroup to the head of the list on the Class.
5332 ----------------------------------------------------------------------------------------*/
dvClassInsertSparsegroup(dvClass Class,dvSparsegroup _Sparsegroup)5333 void dvClassInsertSparsegroup(
5334 dvClass Class,
5335 dvSparsegroup _Sparsegroup)
5336 {
5337 #if defined(DD_DEBUG)
5338 if(Class == dvClassNull) {
5339 utExit("Non-existent Class");
5340 }
5341 if(_Sparsegroup == dvSparsegroupNull) {
5342 utExit("Non-existent Sparsegroup");
5343 }
5344 if(dvSparsegroupGetClass(_Sparsegroup) != dvClassNull) {
5345 utExit("Attempting to add Sparsegroup to Class twice");
5346 }
5347 #endif
5348 dvSparsegroupSetNextClassSparsegroup(_Sparsegroup, dvClassGetFirstSparsegroup(Class));
5349 if(dvClassGetFirstSparsegroup(Class) != dvSparsegroupNull) {
5350 dvSparsegroupSetPrevClassSparsegroup(dvClassGetFirstSparsegroup(Class), _Sparsegroup);
5351 }
5352 dvClassSetFirstSparsegroup(Class, _Sparsegroup);
5353 dvSparsegroupSetPrevClassSparsegroup(_Sparsegroup, dvSparsegroupNull);
5354 if(dvClassGetLastSparsegroup(Class) == dvSparsegroupNull) {
5355 dvClassSetLastSparsegroup(Class, _Sparsegroup);
5356 }
5357 dvSparsegroupSetClass(_Sparsegroup, Class);
5358 if(dvSparsegroupGetSym(_Sparsegroup) != utSymNull) {
5359 addClassSparsegroupToHashTable(Class, _Sparsegroup);
5360 }
5361 }
5362
5363 /*----------------------------------------------------------------------------------------
5364 Add the Sparsegroup to the end of the list on the Class.
5365 ----------------------------------------------------------------------------------------*/
dvClassAppendSparsegroup(dvClass Class,dvSparsegroup _Sparsegroup)5366 void dvClassAppendSparsegroup(
5367 dvClass Class,
5368 dvSparsegroup _Sparsegroup)
5369 {
5370 #if defined(DD_DEBUG)
5371 if(Class == dvClassNull) {
5372 utExit("Non-existent Class");
5373 }
5374 if(_Sparsegroup == dvSparsegroupNull) {
5375 utExit("Non-existent Sparsegroup");
5376 }
5377 if(dvSparsegroupGetClass(_Sparsegroup) != dvClassNull) {
5378 utExit("Attempting to add Sparsegroup to Class twice");
5379 }
5380 #endif
5381 dvSparsegroupSetPrevClassSparsegroup(_Sparsegroup, dvClassGetLastSparsegroup(Class));
5382 if(dvClassGetLastSparsegroup(Class) != dvSparsegroupNull) {
5383 dvSparsegroupSetNextClassSparsegroup(dvClassGetLastSparsegroup(Class), _Sparsegroup);
5384 }
5385 dvClassSetLastSparsegroup(Class, _Sparsegroup);
5386 dvSparsegroupSetNextClassSparsegroup(_Sparsegroup, dvSparsegroupNull);
5387 if(dvClassGetFirstSparsegroup(Class) == dvSparsegroupNull) {
5388 dvClassSetFirstSparsegroup(Class, _Sparsegroup);
5389 }
5390 dvSparsegroupSetClass(_Sparsegroup, Class);
5391 if(dvSparsegroupGetSym(_Sparsegroup) != utSymNull) {
5392 addClassSparsegroupToHashTable(Class, _Sparsegroup);
5393 }
5394 }
5395
5396 /*----------------------------------------------------------------------------------------
5397 Insert the Sparsegroup to the Class after the previous Sparsegroup.
5398 ----------------------------------------------------------------------------------------*/
dvClassInsertAfterSparsegroup(dvClass Class,dvSparsegroup prevSparsegroup,dvSparsegroup _Sparsegroup)5399 void dvClassInsertAfterSparsegroup(
5400 dvClass Class,
5401 dvSparsegroup prevSparsegroup,
5402 dvSparsegroup _Sparsegroup)
5403 {
5404 dvSparsegroup nextSparsegroup = dvSparsegroupGetNextClassSparsegroup(prevSparsegroup);
5405
5406 #if defined(DD_DEBUG)
5407 if(Class == dvClassNull) {
5408 utExit("Non-existent Class");
5409 }
5410 if(_Sparsegroup == dvSparsegroupNull) {
5411 utExit("Non-existent Sparsegroup");
5412 }
5413 if(dvSparsegroupGetClass(_Sparsegroup) != dvClassNull) {
5414 utExit("Attempting to add Sparsegroup to Class twice");
5415 }
5416 #endif
5417 dvSparsegroupSetNextClassSparsegroup(_Sparsegroup, nextSparsegroup);
5418 dvSparsegroupSetNextClassSparsegroup(prevSparsegroup, _Sparsegroup);
5419 dvSparsegroupSetPrevClassSparsegroup(_Sparsegroup, prevSparsegroup);
5420 if(nextSparsegroup != dvSparsegroupNull) {
5421 dvSparsegroupSetPrevClassSparsegroup(nextSparsegroup, _Sparsegroup);
5422 }
5423 if(dvClassGetLastSparsegroup(Class) == prevSparsegroup) {
5424 dvClassSetLastSparsegroup(Class, _Sparsegroup);
5425 }
5426 dvSparsegroupSetClass(_Sparsegroup, Class);
5427 if(dvSparsegroupGetSym(_Sparsegroup) != utSymNull) {
5428 addClassSparsegroupToHashTable(Class, _Sparsegroup);
5429 }
5430 }
5431
5432 /*----------------------------------------------------------------------------------------
5433 Remove the Sparsegroup from the Class.
5434 ----------------------------------------------------------------------------------------*/
dvClassRemoveSparsegroup(dvClass Class,dvSparsegroup _Sparsegroup)5435 void dvClassRemoveSparsegroup(
5436 dvClass Class,
5437 dvSparsegroup _Sparsegroup)
5438 {
5439 dvSparsegroup pSparsegroup, nSparsegroup;
5440
5441 #if defined(DD_DEBUG)
5442 if(_Sparsegroup == dvSparsegroupNull) {
5443 utExit("Non-existent Sparsegroup");
5444 }
5445 if(dvSparsegroupGetClass(_Sparsegroup) != dvClassNull && dvSparsegroupGetClass(_Sparsegroup) != Class) {
5446 utExit("Delete Sparsegroup from non-owning Class");
5447 }
5448 #endif
5449 nSparsegroup = dvSparsegroupGetNextClassSparsegroup(_Sparsegroup);
5450 pSparsegroup = dvSparsegroupGetPrevClassSparsegroup(_Sparsegroup);
5451 if(pSparsegroup != dvSparsegroupNull) {
5452 dvSparsegroupSetNextClassSparsegroup(pSparsegroup, nSparsegroup);
5453 } else if(dvClassGetFirstSparsegroup(Class) == _Sparsegroup) {
5454 dvClassSetFirstSparsegroup(Class, nSparsegroup);
5455 }
5456 if(nSparsegroup != dvSparsegroupNull) {
5457 dvSparsegroupSetPrevClassSparsegroup(nSparsegroup, pSparsegroup);
5458 } else if(dvClassGetLastSparsegroup(Class) == _Sparsegroup) {
5459 dvClassSetLastSparsegroup(Class, pSparsegroup);
5460 }
5461 dvSparsegroupSetNextClassSparsegroup(_Sparsegroup, dvSparsegroupNull);
5462 dvSparsegroupSetPrevClassSparsegroup(_Sparsegroup, dvSparsegroupNull);
5463 dvSparsegroupSetClass(_Sparsegroup, dvClassNull);
5464 if(dvSparsegroupGetSym(_Sparsegroup) != utSymNull) {
5465 removeClassSparsegroupFromHashTable(Class, _Sparsegroup);
5466 }
5467 }
5468
5469 /*----------------------------------------------------------------------------------------
5470 Add the DerivedClass to the head of the list on the Class.
5471 ----------------------------------------------------------------------------------------*/
dvClassInsertDerivedClass(dvClass Class,dvClass _Class)5472 void dvClassInsertDerivedClass(
5473 dvClass Class,
5474 dvClass _Class)
5475 {
5476 #if defined(DD_DEBUG)
5477 if(Class == dvClassNull) {
5478 utExit("Non-existent Class");
5479 }
5480 if(_Class == dvClassNull) {
5481 utExit("Non-existent Class");
5482 }
5483 if(dvClassGetBaseClass(_Class) != dvClassNull) {
5484 utExit("Attempting to add Class to Class twice");
5485 }
5486 #endif
5487 dvClassSetNextClassDerivedClass(_Class, dvClassGetFirstDerivedClass(Class));
5488 dvClassSetFirstDerivedClass(Class, _Class);
5489 if(dvClassGetLastDerivedClass(Class) == dvClassNull) {
5490 dvClassSetLastDerivedClass(Class, _Class);
5491 }
5492 dvClassSetBaseClass(_Class, Class);
5493 }
5494
5495 /*----------------------------------------------------------------------------------------
5496 Add the DerivedClass to the end of the list on the Class.
5497 ----------------------------------------------------------------------------------------*/
dvClassAppendDerivedClass(dvClass Class,dvClass _Class)5498 void dvClassAppendDerivedClass(
5499 dvClass Class,
5500 dvClass _Class)
5501 {
5502 #if defined(DD_DEBUG)
5503 if(Class == dvClassNull) {
5504 utExit("Non-existent Class");
5505 }
5506 if(_Class == dvClassNull) {
5507 utExit("Non-existent Class");
5508 }
5509 if(dvClassGetBaseClass(_Class) != dvClassNull) {
5510 utExit("Attempting to add Class to Class twice");
5511 }
5512 #endif
5513 if(dvClassGetLastDerivedClass(Class) != dvClassNull) {
5514 dvClassSetNextClassDerivedClass(dvClassGetLastDerivedClass(Class), _Class);
5515 } else {
5516 dvClassSetFirstDerivedClass(Class, _Class);
5517 }
5518 dvClassSetLastDerivedClass(Class, _Class);
5519 dvClassSetNextClassDerivedClass(_Class, dvClassNull);
5520 dvClassSetBaseClass(_Class, Class);
5521 }
5522
5523 /*----------------------------------------------------------------------------------------
5524 Insert the DerivedClass to the Class after the previous DerivedClass.
5525 ----------------------------------------------------------------------------------------*/
dvClassInsertAfterDerivedClass(dvClass Class,dvClass prevClass,dvClass _Class)5526 void dvClassInsertAfterDerivedClass(
5527 dvClass Class,
5528 dvClass prevClass,
5529 dvClass _Class)
5530 {
5531 dvClass nextClass = dvClassGetNextClassDerivedClass(prevClass);
5532
5533 #if defined(DD_DEBUG)
5534 if(Class == dvClassNull) {
5535 utExit("Non-existent Class");
5536 }
5537 if(_Class == dvClassNull) {
5538 utExit("Non-existent Class");
5539 }
5540 if(dvClassGetBaseClass(_Class) != dvClassNull) {
5541 utExit("Attempting to add Class to Class twice");
5542 }
5543 #endif
5544 dvClassSetNextClassDerivedClass(_Class, nextClass);
5545 dvClassSetNextClassDerivedClass(prevClass, _Class);
5546 if(dvClassGetLastDerivedClass(Class) == prevClass) {
5547 dvClassSetLastDerivedClass(Class, _Class);
5548 }
5549 dvClassSetBaseClass(_Class, Class);
5550 }
5551
5552 /*----------------------------------------------------------------------------------------
5553 Remove the DerivedClass from the Class.
5554 ----------------------------------------------------------------------------------------*/
dvClassRemoveDerivedClass(dvClass Class,dvClass _Class)5555 void dvClassRemoveDerivedClass(
5556 dvClass Class,
5557 dvClass _Class)
5558 {
5559 dvClass pClass, nClass;
5560
5561 #if defined(DD_DEBUG)
5562 if(_Class == dvClassNull) {
5563 utExit("Non-existent Class");
5564 }
5565 if(dvClassGetBaseClass(_Class) != dvClassNull && dvClassGetBaseClass(_Class) != Class) {
5566 utExit("Delete Class from non-owning Class");
5567 }
5568 #endif
5569 pClass = dvClassNull;
5570 for(nClass = dvClassGetFirstDerivedClass(Class); nClass != dvClassNull && nClass != _Class;
5571 nClass = dvClassGetNextClassDerivedClass(nClass)) {
5572 pClass = nClass;
5573 }
5574 if(pClass != dvClassNull) {
5575 dvClassSetNextClassDerivedClass(pClass, dvClassGetNextClassDerivedClass(_Class));
5576 } else {
5577 dvClassSetFirstDerivedClass(Class, dvClassGetNextClassDerivedClass(_Class));
5578 }
5579 dvClassSetNextClassDerivedClass(_Class, dvClassNull);
5580 if(dvClassGetLastDerivedClass(Class) == _Class) {
5581 dvClassSetLastDerivedClass(Class, pClass);
5582 }
5583 dvClassSetBaseClass(_Class, dvClassNull);
5584 }
5585
5586 /*----------------------------------------------------------------------------------------
5587 Add the ChildRelationship to the head of the list on the Class.
5588 ----------------------------------------------------------------------------------------*/
dvClassInsertChildRelationship(dvClass Class,dvRelationship _Relationship)5589 void dvClassInsertChildRelationship(
5590 dvClass Class,
5591 dvRelationship _Relationship)
5592 {
5593 #if defined(DD_DEBUG)
5594 if(Class == dvClassNull) {
5595 utExit("Non-existent Class");
5596 }
5597 if(_Relationship == dvRelationshipNull) {
5598 utExit("Non-existent Relationship");
5599 }
5600 if(dvRelationshipGetParentClass(_Relationship) != dvClassNull) {
5601 utExit("Attempting to add Relationship to Class twice");
5602 }
5603 #endif
5604 dvRelationshipSetNextClassChildRelationship(_Relationship, dvClassGetFirstChildRelationship(Class));
5605 dvClassSetFirstChildRelationship(Class, _Relationship);
5606 if(dvClassGetLastChildRelationship(Class) == dvRelationshipNull) {
5607 dvClassSetLastChildRelationship(Class, _Relationship);
5608 }
5609 dvRelationshipSetParentClass(_Relationship, Class);
5610 }
5611
5612 /*----------------------------------------------------------------------------------------
5613 Add the ChildRelationship to the end of the list on the Class.
5614 ----------------------------------------------------------------------------------------*/
dvClassAppendChildRelationship(dvClass Class,dvRelationship _Relationship)5615 void dvClassAppendChildRelationship(
5616 dvClass Class,
5617 dvRelationship _Relationship)
5618 {
5619 #if defined(DD_DEBUG)
5620 if(Class == dvClassNull) {
5621 utExit("Non-existent Class");
5622 }
5623 if(_Relationship == dvRelationshipNull) {
5624 utExit("Non-existent Relationship");
5625 }
5626 if(dvRelationshipGetParentClass(_Relationship) != dvClassNull) {
5627 utExit("Attempting to add Relationship to Class twice");
5628 }
5629 #endif
5630 if(dvClassGetLastChildRelationship(Class) != dvRelationshipNull) {
5631 dvRelationshipSetNextClassChildRelationship(dvClassGetLastChildRelationship(Class), _Relationship);
5632 } else {
5633 dvClassSetFirstChildRelationship(Class, _Relationship);
5634 }
5635 dvClassSetLastChildRelationship(Class, _Relationship);
5636 dvRelationshipSetNextClassChildRelationship(_Relationship, dvRelationshipNull);
5637 dvRelationshipSetParentClass(_Relationship, Class);
5638 }
5639
5640 /*----------------------------------------------------------------------------------------
5641 Insert the ChildRelationship to the Class after the previous ChildRelationship.
5642 ----------------------------------------------------------------------------------------*/
dvClassInsertAfterChildRelationship(dvClass Class,dvRelationship prevRelationship,dvRelationship _Relationship)5643 void dvClassInsertAfterChildRelationship(
5644 dvClass Class,
5645 dvRelationship prevRelationship,
5646 dvRelationship _Relationship)
5647 {
5648 dvRelationship nextRelationship = dvRelationshipGetNextClassChildRelationship(prevRelationship);
5649
5650 #if defined(DD_DEBUG)
5651 if(Class == dvClassNull) {
5652 utExit("Non-existent Class");
5653 }
5654 if(_Relationship == dvRelationshipNull) {
5655 utExit("Non-existent Relationship");
5656 }
5657 if(dvRelationshipGetParentClass(_Relationship) != dvClassNull) {
5658 utExit("Attempting to add Relationship to Class twice");
5659 }
5660 #endif
5661 dvRelationshipSetNextClassChildRelationship(_Relationship, nextRelationship);
5662 dvRelationshipSetNextClassChildRelationship(prevRelationship, _Relationship);
5663 if(dvClassGetLastChildRelationship(Class) == prevRelationship) {
5664 dvClassSetLastChildRelationship(Class, _Relationship);
5665 }
5666 dvRelationshipSetParentClass(_Relationship, Class);
5667 }
5668
5669 /*----------------------------------------------------------------------------------------
5670 Remove the ChildRelationship from the Class.
5671 ----------------------------------------------------------------------------------------*/
dvClassRemoveChildRelationship(dvClass Class,dvRelationship _Relationship)5672 void dvClassRemoveChildRelationship(
5673 dvClass Class,
5674 dvRelationship _Relationship)
5675 {
5676 dvRelationship pRelationship, nRelationship;
5677
5678 #if defined(DD_DEBUG)
5679 if(_Relationship == dvRelationshipNull) {
5680 utExit("Non-existent Relationship");
5681 }
5682 if(dvRelationshipGetParentClass(_Relationship) != dvClassNull && dvRelationshipGetParentClass(_Relationship) != Class) {
5683 utExit("Delete Relationship from non-owning Class");
5684 }
5685 #endif
5686 pRelationship = dvRelationshipNull;
5687 for(nRelationship = dvClassGetFirstChildRelationship(Class); nRelationship != dvRelationshipNull && nRelationship != _Relationship;
5688 nRelationship = dvRelationshipGetNextClassChildRelationship(nRelationship)) {
5689 pRelationship = nRelationship;
5690 }
5691 if(pRelationship != dvRelationshipNull) {
5692 dvRelationshipSetNextClassChildRelationship(pRelationship, dvRelationshipGetNextClassChildRelationship(_Relationship));
5693 } else {
5694 dvClassSetFirstChildRelationship(Class, dvRelationshipGetNextClassChildRelationship(_Relationship));
5695 }
5696 dvRelationshipSetNextClassChildRelationship(_Relationship, dvRelationshipNull);
5697 if(dvClassGetLastChildRelationship(Class) == _Relationship) {
5698 dvClassSetLastChildRelationship(Class, pRelationship);
5699 }
5700 dvRelationshipSetParentClass(_Relationship, dvClassNull);
5701 }
5702
5703 /*----------------------------------------------------------------------------------------
5704 Add the ParentRelationship to the head of the list on the Class.
5705 ----------------------------------------------------------------------------------------*/
dvClassInsertParentRelationship(dvClass Class,dvRelationship _Relationship)5706 void dvClassInsertParentRelationship(
5707 dvClass Class,
5708 dvRelationship _Relationship)
5709 {
5710 #if defined(DD_DEBUG)
5711 if(Class == dvClassNull) {
5712 utExit("Non-existent Class");
5713 }
5714 if(_Relationship == dvRelationshipNull) {
5715 utExit("Non-existent Relationship");
5716 }
5717 if(dvRelationshipGetChildClass(_Relationship) != dvClassNull) {
5718 utExit("Attempting to add Relationship to Class twice");
5719 }
5720 #endif
5721 dvRelationshipSetNextClassParentRelationship(_Relationship, dvClassGetFirstParentRelationship(Class));
5722 dvClassSetFirstParentRelationship(Class, _Relationship);
5723 if(dvClassGetLastParentRelationship(Class) == dvRelationshipNull) {
5724 dvClassSetLastParentRelationship(Class, _Relationship);
5725 }
5726 dvRelationshipSetChildClass(_Relationship, Class);
5727 }
5728
5729 /*----------------------------------------------------------------------------------------
5730 Add the ParentRelationship to the end of the list on the Class.
5731 ----------------------------------------------------------------------------------------*/
dvClassAppendParentRelationship(dvClass Class,dvRelationship _Relationship)5732 void dvClassAppendParentRelationship(
5733 dvClass Class,
5734 dvRelationship _Relationship)
5735 {
5736 #if defined(DD_DEBUG)
5737 if(Class == dvClassNull) {
5738 utExit("Non-existent Class");
5739 }
5740 if(_Relationship == dvRelationshipNull) {
5741 utExit("Non-existent Relationship");
5742 }
5743 if(dvRelationshipGetChildClass(_Relationship) != dvClassNull) {
5744 utExit("Attempting to add Relationship to Class twice");
5745 }
5746 #endif
5747 if(dvClassGetLastParentRelationship(Class) != dvRelationshipNull) {
5748 dvRelationshipSetNextClassParentRelationship(dvClassGetLastParentRelationship(Class), _Relationship);
5749 } else {
5750 dvClassSetFirstParentRelationship(Class, _Relationship);
5751 }
5752 dvClassSetLastParentRelationship(Class, _Relationship);
5753 dvRelationshipSetNextClassParentRelationship(_Relationship, dvRelationshipNull);
5754 dvRelationshipSetChildClass(_Relationship, Class);
5755 }
5756
5757 /*----------------------------------------------------------------------------------------
5758 Insert the ParentRelationship to the Class after the previous ParentRelationship.
5759 ----------------------------------------------------------------------------------------*/
dvClassInsertAfterParentRelationship(dvClass Class,dvRelationship prevRelationship,dvRelationship _Relationship)5760 void dvClassInsertAfterParentRelationship(
5761 dvClass Class,
5762 dvRelationship prevRelationship,
5763 dvRelationship _Relationship)
5764 {
5765 dvRelationship nextRelationship = dvRelationshipGetNextClassParentRelationship(prevRelationship);
5766
5767 #if defined(DD_DEBUG)
5768 if(Class == dvClassNull) {
5769 utExit("Non-existent Class");
5770 }
5771 if(_Relationship == dvRelationshipNull) {
5772 utExit("Non-existent Relationship");
5773 }
5774 if(dvRelationshipGetChildClass(_Relationship) != dvClassNull) {
5775 utExit("Attempting to add Relationship to Class twice");
5776 }
5777 #endif
5778 dvRelationshipSetNextClassParentRelationship(_Relationship, nextRelationship);
5779 dvRelationshipSetNextClassParentRelationship(prevRelationship, _Relationship);
5780 if(dvClassGetLastParentRelationship(Class) == prevRelationship) {
5781 dvClassSetLastParentRelationship(Class, _Relationship);
5782 }
5783 dvRelationshipSetChildClass(_Relationship, Class);
5784 }
5785
5786 /*----------------------------------------------------------------------------------------
5787 Remove the ParentRelationship from the Class.
5788 ----------------------------------------------------------------------------------------*/
dvClassRemoveParentRelationship(dvClass Class,dvRelationship _Relationship)5789 void dvClassRemoveParentRelationship(
5790 dvClass Class,
5791 dvRelationship _Relationship)
5792 {
5793 dvRelationship pRelationship, nRelationship;
5794
5795 #if defined(DD_DEBUG)
5796 if(_Relationship == dvRelationshipNull) {
5797 utExit("Non-existent Relationship");
5798 }
5799 if(dvRelationshipGetChildClass(_Relationship) != dvClassNull && dvRelationshipGetChildClass(_Relationship) != Class) {
5800 utExit("Delete Relationship from non-owning Class");
5801 }
5802 #endif
5803 pRelationship = dvRelationshipNull;
5804 for(nRelationship = dvClassGetFirstParentRelationship(Class); nRelationship != dvRelationshipNull && nRelationship != _Relationship;
5805 nRelationship = dvRelationshipGetNextClassParentRelationship(nRelationship)) {
5806 pRelationship = nRelationship;
5807 }
5808 if(pRelationship != dvRelationshipNull) {
5809 dvRelationshipSetNextClassParentRelationship(pRelationship, dvRelationshipGetNextClassParentRelationship(_Relationship));
5810 } else {
5811 dvClassSetFirstParentRelationship(Class, dvRelationshipGetNextClassParentRelationship(_Relationship));
5812 }
5813 dvRelationshipSetNextClassParentRelationship(_Relationship, dvRelationshipNull);
5814 if(dvClassGetLastParentRelationship(Class) == _Relationship) {
5815 dvClassSetLastParentRelationship(Class, pRelationship);
5816 }
5817 dvRelationshipSetChildClass(_Relationship, dvClassNull);
5818 }
5819
5820 /*----------------------------------------------------------------------------------------
5821 Add the Union to the head of the list on the Class.
5822 ----------------------------------------------------------------------------------------*/
dvClassInsertUnion(dvClass Class,dvUnion _Union)5823 void dvClassInsertUnion(
5824 dvClass Class,
5825 dvUnion _Union)
5826 {
5827 #if defined(DD_DEBUG)
5828 if(Class == dvClassNull) {
5829 utExit("Non-existent Class");
5830 }
5831 if(_Union == dvUnionNull) {
5832 utExit("Non-existent Union");
5833 }
5834 if(dvUnionGetClass(_Union) != dvClassNull) {
5835 utExit("Attempting to add Union to Class twice");
5836 }
5837 #endif
5838 dvUnionSetNextClassUnion(_Union, dvClassGetFirstUnion(Class));
5839 dvClassSetFirstUnion(Class, _Union);
5840 if(dvClassGetLastUnion(Class) == dvUnionNull) {
5841 dvClassSetLastUnion(Class, _Union);
5842 }
5843 dvUnionSetClass(_Union, Class);
5844 }
5845
5846 /*----------------------------------------------------------------------------------------
5847 Add the Union to the end of the list on the Class.
5848 ----------------------------------------------------------------------------------------*/
dvClassAppendUnion(dvClass Class,dvUnion _Union)5849 void dvClassAppendUnion(
5850 dvClass Class,
5851 dvUnion _Union)
5852 {
5853 #if defined(DD_DEBUG)
5854 if(Class == dvClassNull) {
5855 utExit("Non-existent Class");
5856 }
5857 if(_Union == dvUnionNull) {
5858 utExit("Non-existent Union");
5859 }
5860 if(dvUnionGetClass(_Union) != dvClassNull) {
5861 utExit("Attempting to add Union to Class twice");
5862 }
5863 #endif
5864 if(dvClassGetLastUnion(Class) != dvUnionNull) {
5865 dvUnionSetNextClassUnion(dvClassGetLastUnion(Class), _Union);
5866 } else {
5867 dvClassSetFirstUnion(Class, _Union);
5868 }
5869 dvClassSetLastUnion(Class, _Union);
5870 dvUnionSetNextClassUnion(_Union, dvUnionNull);
5871 dvUnionSetClass(_Union, Class);
5872 }
5873
5874 /*----------------------------------------------------------------------------------------
5875 Insert the Union to the Class after the previous Union.
5876 ----------------------------------------------------------------------------------------*/
dvClassInsertAfterUnion(dvClass Class,dvUnion prevUnion,dvUnion _Union)5877 void dvClassInsertAfterUnion(
5878 dvClass Class,
5879 dvUnion prevUnion,
5880 dvUnion _Union)
5881 {
5882 dvUnion nextUnion = dvUnionGetNextClassUnion(prevUnion);
5883
5884 #if defined(DD_DEBUG)
5885 if(Class == dvClassNull) {
5886 utExit("Non-existent Class");
5887 }
5888 if(_Union == dvUnionNull) {
5889 utExit("Non-existent Union");
5890 }
5891 if(dvUnionGetClass(_Union) != dvClassNull) {
5892 utExit("Attempting to add Union to Class twice");
5893 }
5894 #endif
5895 dvUnionSetNextClassUnion(_Union, nextUnion);
5896 dvUnionSetNextClassUnion(prevUnion, _Union);
5897 if(dvClassGetLastUnion(Class) == prevUnion) {
5898 dvClassSetLastUnion(Class, _Union);
5899 }
5900 dvUnionSetClass(_Union, Class);
5901 }
5902
5903 /*----------------------------------------------------------------------------------------
5904 Remove the Union from the Class.
5905 ----------------------------------------------------------------------------------------*/
dvClassRemoveUnion(dvClass Class,dvUnion _Union)5906 void dvClassRemoveUnion(
5907 dvClass Class,
5908 dvUnion _Union)
5909 {
5910 dvUnion pUnion, nUnion;
5911
5912 #if defined(DD_DEBUG)
5913 if(_Union == dvUnionNull) {
5914 utExit("Non-existent Union");
5915 }
5916 if(dvUnionGetClass(_Union) != dvClassNull && dvUnionGetClass(_Union) != Class) {
5917 utExit("Delete Union from non-owning Class");
5918 }
5919 #endif
5920 pUnion = dvUnionNull;
5921 for(nUnion = dvClassGetFirstUnion(Class); nUnion != dvUnionNull && nUnion != _Union;
5922 nUnion = dvUnionGetNextClassUnion(nUnion)) {
5923 pUnion = nUnion;
5924 }
5925 if(pUnion != dvUnionNull) {
5926 dvUnionSetNextClassUnion(pUnion, dvUnionGetNextClassUnion(_Union));
5927 } else {
5928 dvClassSetFirstUnion(Class, dvUnionGetNextClassUnion(_Union));
5929 }
5930 dvUnionSetNextClassUnion(_Union, dvUnionNull);
5931 if(dvClassGetLastUnion(Class) == _Union) {
5932 dvClassSetLastUnion(Class, pUnion);
5933 }
5934 dvUnionSetClass(_Union, dvClassNull);
5935 }
5936
5937 #if defined(DD_DEBUG)
5938 /*----------------------------------------------------------------------------------------
5939 Write out all the fields of an object.
5940 ----------------------------------------------------------------------------------------*/
dvShowClass(dvClass Class)5941 void dvShowClass(
5942 dvClass Class)
5943 {
5944 utDatabaseShowObject("dv", "Class", dvClass2Index(Class));
5945 }
5946 #endif
5947
5948 /*----------------------------------------------------------------------------------------
5949 Default constructor wrapper for the database manager.
5950 ----------------------------------------------------------------------------------------*/
allocProperty(void)5951 static uint64 allocProperty(void)
5952 {
5953 dvProperty Property = dvPropertyAlloc();
5954
5955 return dvProperty2Index(Property);
5956 }
5957
5958 /*----------------------------------------------------------------------------------------
5959 Allocate the field arrays of Property.
5960 ----------------------------------------------------------------------------------------*/
allocPropertys(void)5961 static void allocPropertys(void)
5962 {
5963 dvSetAllocatedProperty(2);
5964 dvSetUsedProperty(0);
5965 dvPropertys.Sym = utNewA(utSym, (dvAllocatedProperty()));
5966 dvPropertys.Type = utNewA(dvPropertyType, (dvAllocatedProperty()));
5967 dvPropertys.Array = utNewA(uint8, (dvAllocatedProperty() + 7) >> 3);
5968 dvPropertys.Cascade = utNewA(uint8, (dvAllocatedProperty() + 7) >> 3);
5969 dvPropertys.Sparse = utNewA(uint8, (dvAllocatedProperty() + 7) >> 3);
5970 dvPropertys.Expanded = utNewA(uint8, (dvAllocatedProperty() + 7) >> 3);
5971 dvPropertys.FieldNumber = utNewA(uint32, (dvAllocatedProperty()));
5972 dvPropertys.FirstElementProp = utNewA(dvProperty, (dvAllocatedProperty()));
5973 dvPropertys.NumElementsProp = utNewA(dvProperty, (dvAllocatedProperty()));
5974 dvPropertys.Hidden = utNewA(uint8, (dvAllocatedProperty() + 7) >> 3);
5975 dvPropertys.InitializerIndex = utNewA(uint32, (dvAllocatedProperty()));
5976 dvPropertys.NumInitializer = utNewA(uint32, (dvAllocatedProperty()));
5977 dvSetUsedPropertyInitializer(0);
5978 dvSetAllocatedPropertyInitializer(2);
5979 dvSetFreePropertyInitializer(0);
5980 dvPropertys.Initializer = utNewA(char, dvAllocatedPropertyInitializer());
5981 dvPropertys.FixedSize = utNewA(uint8, (dvAllocatedProperty() + 7) >> 3);
5982 dvPropertys.IndexIndex = utNewA(uint32, (dvAllocatedProperty()));
5983 dvPropertys.NumIndex = utNewA(uint32, (dvAllocatedProperty()));
5984 dvSetUsedPropertyIndex(0);
5985 dvSetAllocatedPropertyIndex(2);
5986 dvSetFreePropertyIndex(0);
5987 dvPropertys.Index = utNewA(char, dvAllocatedPropertyIndex());
5988 dvPropertys.Line = utNewA(uint32, (dvAllocatedProperty()));
5989 dvPropertys.Class = utNewA(dvClass, (dvAllocatedProperty()));
5990 dvPropertys.NextClassProperty = utNewA(dvProperty, (dvAllocatedProperty()));
5991 dvPropertys.PrevClassProperty = utNewA(dvProperty, (dvAllocatedProperty()));
5992 dvPropertys.NextTableClassProperty = utNewA(dvProperty, (dvAllocatedProperty()));
5993 dvPropertys.FirstCase = utNewA(dvCase, (dvAllocatedProperty()));
5994 dvPropertys.LastCase = utNewA(dvCase, (dvAllocatedProperty()));
5995 dvPropertys.FirstKey = utNewA(dvKey, (dvAllocatedProperty()));
5996 dvPropertys.LastKey = utNewA(dvKey, (dvAllocatedProperty()));
5997 dvPropertys.Sparsegroup = utNewA(dvSparsegroup, (dvAllocatedProperty()));
5998 dvPropertys.NextSparsegroupProperty = utNewA(dvProperty, (dvAllocatedProperty()));
5999 dvPropertys.Relationship = utNewA(dvRelationship, (dvAllocatedProperty()));
6000 dvPropertys.NextRelationshipProperty = utNewA(dvProperty, (dvAllocatedProperty()));
6001 dvPropertys.Union = utNewA(dvUnion, (dvAllocatedProperty()));
6002 dvPropertys.NextUnionProperty = utNewA(dvProperty, (dvAllocatedProperty()));
6003 dvPropertys.union1 = utNewA(dvPropertyUnion1, dvAllocatedProperty());
6004 }
6005
6006 /*----------------------------------------------------------------------------------------
6007 Realloc the arrays of properties for class Property.
6008 ----------------------------------------------------------------------------------------*/
reallocPropertys(uint32 newSize)6009 static void reallocPropertys(
6010 uint32 newSize)
6011 {
6012 utResizeArray(dvPropertys.Sym, (newSize));
6013 utResizeArray(dvPropertys.Type, (newSize));
6014 utResizeArray(dvPropertys.Array, (newSize + 7) >> 3);
6015 utResizeArray(dvPropertys.Cascade, (newSize + 7) >> 3);
6016 utResizeArray(dvPropertys.Sparse, (newSize + 7) >> 3);
6017 utResizeArray(dvPropertys.Expanded, (newSize + 7) >> 3);
6018 utResizeArray(dvPropertys.FieldNumber, (newSize));
6019 utResizeArray(dvPropertys.FirstElementProp, (newSize));
6020 utResizeArray(dvPropertys.NumElementsProp, (newSize));
6021 utResizeArray(dvPropertys.Hidden, (newSize + 7) >> 3);
6022 utResizeArray(dvPropertys.InitializerIndex, (newSize));
6023 utResizeArray(dvPropertys.NumInitializer, (newSize));
6024 utResizeArray(dvPropertys.FixedSize, (newSize + 7) >> 3);
6025 utResizeArray(dvPropertys.IndexIndex, (newSize));
6026 utResizeArray(dvPropertys.NumIndex, (newSize));
6027 utResizeArray(dvPropertys.Line, (newSize));
6028 utResizeArray(dvPropertys.Class, (newSize));
6029 utResizeArray(dvPropertys.NextClassProperty, (newSize));
6030 utResizeArray(dvPropertys.PrevClassProperty, (newSize));
6031 utResizeArray(dvPropertys.NextTableClassProperty, (newSize));
6032 utResizeArray(dvPropertys.FirstCase, (newSize));
6033 utResizeArray(dvPropertys.LastCase, (newSize));
6034 utResizeArray(dvPropertys.FirstKey, (newSize));
6035 utResizeArray(dvPropertys.LastKey, (newSize));
6036 utResizeArray(dvPropertys.Sparsegroup, (newSize));
6037 utResizeArray(dvPropertys.NextSparsegroupProperty, (newSize));
6038 utResizeArray(dvPropertys.Relationship, (newSize));
6039 utResizeArray(dvPropertys.NextRelationshipProperty, (newSize));
6040 utResizeArray(dvPropertys.Union, (newSize));
6041 utResizeArray(dvPropertys.NextUnionProperty, (newSize));
6042 utResizeArray(dvPropertys.union1, newSize);
6043 dvSetAllocatedProperty(newSize);
6044 }
6045
6046 /*----------------------------------------------------------------------------------------
6047 Allocate more Propertys.
6048 ----------------------------------------------------------------------------------------*/
dvPropertyAllocMore(void)6049 void dvPropertyAllocMore(void)
6050 {
6051 reallocPropertys((uint32)(dvAllocatedProperty() + (dvAllocatedProperty() >> 1)));
6052 }
6053
6054 /*----------------------------------------------------------------------------------------
6055 Compact the Property.Initializer heap to free memory.
6056 ----------------------------------------------------------------------------------------*/
dvCompactPropertyInitializers(void)6057 void dvCompactPropertyInitializers(void)
6058 {
6059 uint32 elementSize = sizeof(char);
6060 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6061 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6062 char *toPtr = dvPropertys.Initializer;
6063 char *fromPtr = toPtr;
6064 dvProperty Property;
6065 uint32 size;
6066
6067 while(fromPtr < dvPropertys.Initializer + dvUsedPropertyInitializer()) {
6068 Property = *(dvProperty *)(void *)fromPtr;
6069 if(Property != dvPropertyNull) {
6070 /* Need to move it to toPtr */
6071 size = utMax(dvPropertyGetNumInitializer(Property) + usedHeaderSize, freeHeaderSize);
6072 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
6073 dvPropertySetInitializerIndex(Property, toPtr - dvPropertys.Initializer + usedHeaderSize);
6074 toPtr += size;
6075 } else {
6076 /* Just skip it */
6077 size = *(uint32 *)(void *)(((dvProperty *)(void *)fromPtr) + 1);
6078 }
6079 fromPtr += size;
6080 }
6081 dvSetUsedPropertyInitializer(toPtr - dvPropertys.Initializer);
6082 dvSetFreePropertyInitializer(0);
6083 }
6084
6085 /*----------------------------------------------------------------------------------------
6086 Allocate more memory for the Property.Initializer heap.
6087 ----------------------------------------------------------------------------------------*/
allocMorePropertyInitializers(uint32 spaceNeeded)6088 static void allocMorePropertyInitializers(
6089 uint32 spaceNeeded)
6090 {
6091 uint32 freeSpace = dvAllocatedPropertyInitializer() - dvUsedPropertyInitializer();
6092
6093 if((dvFreePropertyInitializer() << 2) > dvUsedPropertyInitializer()) {
6094 dvCompactPropertyInitializers();
6095 freeSpace = dvAllocatedPropertyInitializer() - dvUsedPropertyInitializer();
6096 }
6097 if(freeSpace < spaceNeeded) {
6098 dvSetAllocatedPropertyInitializer(dvAllocatedPropertyInitializer() + spaceNeeded - freeSpace +
6099 (dvAllocatedPropertyInitializer() >> 1));
6100 utResizeArray(dvPropertys.Initializer, dvAllocatedPropertyInitializer());
6101 }
6102 }
6103
6104 /*----------------------------------------------------------------------------------------
6105 Allocate memory for a new Property.Initializer array.
6106 ----------------------------------------------------------------------------------------*/
dvPropertyAllocInitializers(dvProperty Property,uint32 numInitializers)6107 void dvPropertyAllocInitializers(
6108 dvProperty Property,
6109 uint32 numInitializers)
6110 {
6111 uint32 freeSpace = dvAllocatedPropertyInitializer() - dvUsedPropertyInitializer();
6112 uint32 elementSize = sizeof(char);
6113 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6114 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6115 uint32 spaceNeeded = utMax(numInitializers + usedHeaderSize, freeHeaderSize);
6116
6117 #if defined(DD_DEBUG)
6118 utAssert(dvPropertyGetNumInitializer(Property) == 0);
6119 #endif
6120 if(numInitializers == 0) {
6121 return;
6122 }
6123 if(freeSpace < spaceNeeded) {
6124 allocMorePropertyInitializers(spaceNeeded);
6125 }
6126 dvPropertySetInitializerIndex(Property, dvUsedPropertyInitializer() + usedHeaderSize);
6127 dvPropertySetNumInitializer(Property, numInitializers);
6128 *(dvProperty *)(void *)(dvPropertys.Initializer + dvUsedPropertyInitializer()) = Property;
6129 memset(dvPropertys.Initializer + dvPropertyGetInitializerIndex(Property), 0, ((numInitializers))*sizeof(char));
6130 dvSetUsedPropertyInitializer(dvUsedPropertyInitializer() + spaceNeeded);
6131 }
6132
6133 /*----------------------------------------------------------------------------------------
6134 Wrapper around dvPropertyGetInitializers for the database manager.
6135 ----------------------------------------------------------------------------------------*/
getPropertyInitializers(uint64 objectNumber,uint32 * numValues)6136 static void *getPropertyInitializers(
6137 uint64 objectNumber,
6138 uint32 *numValues)
6139 {
6140 dvProperty Property = dvIndex2Property((uint32)objectNumber);
6141
6142 *numValues = dvPropertyGetNumInitializer(Property);
6143 return dvPropertyGetInitializers(Property);
6144 }
6145
6146 /*----------------------------------------------------------------------------------------
6147 Wrapper around dvPropertyAllocInitializers for the database manager.
6148 ----------------------------------------------------------------------------------------*/
allocPropertyInitializers(uint64 objectNumber,uint32 numValues)6149 static void *allocPropertyInitializers(
6150 uint64 objectNumber,
6151 uint32 numValues)
6152 {
6153 dvProperty Property = dvIndex2Property((uint32)objectNumber);
6154
6155 dvPropertySetInitializerIndex(Property, 0);
6156 dvPropertySetNumInitializer(Property, 0);
6157 if(numValues == 0) {
6158 return NULL;
6159 }
6160 dvPropertyAllocInitializers(Property, numValues);
6161 return dvPropertyGetInitializers(Property);
6162 }
6163
6164 /*----------------------------------------------------------------------------------------
6165 Free memory used by the Property.Initializer array.
6166 ----------------------------------------------------------------------------------------*/
dvPropertyFreeInitializers(dvProperty Property)6167 void dvPropertyFreeInitializers(
6168 dvProperty Property)
6169 {
6170 uint32 elementSize = sizeof(char);
6171 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6172 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6173 uint32 size = utMax(dvPropertyGetNumInitializer(Property) + usedHeaderSize, freeHeaderSize);
6174 char *dataPtr = dvPropertyGetInitializers(Property) - usedHeaderSize;
6175
6176 if(dvPropertyGetNumInitializer(Property) == 0) {
6177 return;
6178 }
6179 *(dvProperty *)(void *)(dataPtr) = dvPropertyNull;
6180 *(uint32 *)(void *)(((dvProperty *)(void *)dataPtr) + 1) = size;
6181 dvPropertySetNumInitializer(Property, 0);
6182 dvSetFreePropertyInitializer(dvFreePropertyInitializer() + size);
6183 }
6184
6185 /*----------------------------------------------------------------------------------------
6186 Resize the Property.Initializer array.
6187 ----------------------------------------------------------------------------------------*/
dvPropertyResizeInitializers(dvProperty Property,uint32 numInitializers)6188 void dvPropertyResizeInitializers(
6189 dvProperty Property,
6190 uint32 numInitializers)
6191 {
6192 uint32 freeSpace;
6193 uint32 elementSize = sizeof(char);
6194 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6195 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6196 uint32 newSize = utMax(numInitializers + usedHeaderSize, freeHeaderSize);
6197 uint32 oldSize = utMax(dvPropertyGetNumInitializer(Property) + usedHeaderSize, freeHeaderSize);
6198 char *dataPtr;
6199
6200 if(numInitializers == 0) {
6201 if(dvPropertyGetNumInitializer(Property) != 0) {
6202 dvPropertyFreeInitializers(Property);
6203 }
6204 return;
6205 }
6206 if(dvPropertyGetNumInitializer(Property) == 0) {
6207 dvPropertyAllocInitializers(Property, numInitializers);
6208 return;
6209 }
6210 freeSpace = dvAllocatedPropertyInitializer() - dvUsedPropertyInitializer();
6211 if(freeSpace < newSize) {
6212 allocMorePropertyInitializers(newSize);
6213 }
6214 dataPtr = dvPropertyGetInitializers(Property) - usedHeaderSize;
6215 memcpy((void *)(dvPropertys.Initializer + dvUsedPropertyInitializer()), dataPtr,
6216 elementSize*utMin(oldSize, newSize));
6217 if(newSize > oldSize) {
6218 memset(dvPropertys.Initializer + dvUsedPropertyInitializer() + oldSize, 0, ((newSize - oldSize))*sizeof(char));
6219 }
6220 *(dvProperty *)(void *)dataPtr = dvPropertyNull;
6221 *(uint32 *)(void *)(((dvProperty *)(void *)dataPtr) + 1) = oldSize;
6222 dvSetFreePropertyInitializer(dvFreePropertyInitializer() + oldSize);
6223 dvPropertySetInitializerIndex(Property, dvUsedPropertyInitializer() + usedHeaderSize);
6224 dvPropertySetNumInitializer(Property, numInitializers);
6225 dvSetUsedPropertyInitializer(dvUsedPropertyInitializer() + newSize);
6226 }
6227
6228 /*----------------------------------------------------------------------------------------
6229 Compact the Property.Index heap to free memory.
6230 ----------------------------------------------------------------------------------------*/
dvCompactPropertyIndexs(void)6231 void dvCompactPropertyIndexs(void)
6232 {
6233 uint32 elementSize = sizeof(char);
6234 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6235 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6236 char *toPtr = dvPropertys.Index;
6237 char *fromPtr = toPtr;
6238 dvProperty Property;
6239 uint32 size;
6240
6241 while(fromPtr < dvPropertys.Index + dvUsedPropertyIndex()) {
6242 Property = *(dvProperty *)(void *)fromPtr;
6243 if(Property != dvPropertyNull) {
6244 /* Need to move it to toPtr */
6245 size = utMax(dvPropertyGetNumIndex(Property) + usedHeaderSize, freeHeaderSize);
6246 memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
6247 dvPropertySetIndexIndex(Property, toPtr - dvPropertys.Index + usedHeaderSize);
6248 toPtr += size;
6249 } else {
6250 /* Just skip it */
6251 size = *(uint32 *)(void *)(((dvProperty *)(void *)fromPtr) + 1);
6252 }
6253 fromPtr += size;
6254 }
6255 dvSetUsedPropertyIndex(toPtr - dvPropertys.Index);
6256 dvSetFreePropertyIndex(0);
6257 }
6258
6259 /*----------------------------------------------------------------------------------------
6260 Allocate more memory for the Property.Index heap.
6261 ----------------------------------------------------------------------------------------*/
allocMorePropertyIndexs(uint32 spaceNeeded)6262 static void allocMorePropertyIndexs(
6263 uint32 spaceNeeded)
6264 {
6265 uint32 freeSpace = dvAllocatedPropertyIndex() - dvUsedPropertyIndex();
6266
6267 if((dvFreePropertyIndex() << 2) > dvUsedPropertyIndex()) {
6268 dvCompactPropertyIndexs();
6269 freeSpace = dvAllocatedPropertyIndex() - dvUsedPropertyIndex();
6270 }
6271 if(freeSpace < spaceNeeded) {
6272 dvSetAllocatedPropertyIndex(dvAllocatedPropertyIndex() + spaceNeeded - freeSpace +
6273 (dvAllocatedPropertyIndex() >> 1));
6274 utResizeArray(dvPropertys.Index, dvAllocatedPropertyIndex());
6275 }
6276 }
6277
6278 /*----------------------------------------------------------------------------------------
6279 Allocate memory for a new Property.Index array.
6280 ----------------------------------------------------------------------------------------*/
dvPropertyAllocIndexs(dvProperty Property,uint32 numIndexs)6281 void dvPropertyAllocIndexs(
6282 dvProperty Property,
6283 uint32 numIndexs)
6284 {
6285 uint32 freeSpace = dvAllocatedPropertyIndex() - dvUsedPropertyIndex();
6286 uint32 elementSize = sizeof(char);
6287 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6288 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6289 uint32 spaceNeeded = utMax(numIndexs + usedHeaderSize, freeHeaderSize);
6290
6291 #if defined(DD_DEBUG)
6292 utAssert(dvPropertyGetNumIndex(Property) == 0);
6293 #endif
6294 if(numIndexs == 0) {
6295 return;
6296 }
6297 if(freeSpace < spaceNeeded) {
6298 allocMorePropertyIndexs(spaceNeeded);
6299 }
6300 dvPropertySetIndexIndex(Property, dvUsedPropertyIndex() + usedHeaderSize);
6301 dvPropertySetNumIndex(Property, numIndexs);
6302 *(dvProperty *)(void *)(dvPropertys.Index + dvUsedPropertyIndex()) = Property;
6303 memset(dvPropertys.Index + dvPropertyGetIndexIndex(Property), 0, ((numIndexs))*sizeof(char));
6304 dvSetUsedPropertyIndex(dvUsedPropertyIndex() + spaceNeeded);
6305 }
6306
6307 /*----------------------------------------------------------------------------------------
6308 Wrapper around dvPropertyGetIndexs for the database manager.
6309 ----------------------------------------------------------------------------------------*/
getPropertyIndexs(uint64 objectNumber,uint32 * numValues)6310 static void *getPropertyIndexs(
6311 uint64 objectNumber,
6312 uint32 *numValues)
6313 {
6314 dvProperty Property = dvIndex2Property((uint32)objectNumber);
6315
6316 *numValues = dvPropertyGetNumIndex(Property);
6317 return dvPropertyGetIndexs(Property);
6318 }
6319
6320 /*----------------------------------------------------------------------------------------
6321 Wrapper around dvPropertyAllocIndexs for the database manager.
6322 ----------------------------------------------------------------------------------------*/
allocPropertyIndexs(uint64 objectNumber,uint32 numValues)6323 static void *allocPropertyIndexs(
6324 uint64 objectNumber,
6325 uint32 numValues)
6326 {
6327 dvProperty Property = dvIndex2Property((uint32)objectNumber);
6328
6329 dvPropertySetIndexIndex(Property, 0);
6330 dvPropertySetNumIndex(Property, 0);
6331 if(numValues == 0) {
6332 return NULL;
6333 }
6334 dvPropertyAllocIndexs(Property, numValues);
6335 return dvPropertyGetIndexs(Property);
6336 }
6337
6338 /*----------------------------------------------------------------------------------------
6339 Free memory used by the Property.Index array.
6340 ----------------------------------------------------------------------------------------*/
dvPropertyFreeIndexs(dvProperty Property)6341 void dvPropertyFreeIndexs(
6342 dvProperty Property)
6343 {
6344 uint32 elementSize = sizeof(char);
6345 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6346 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6347 uint32 size = utMax(dvPropertyGetNumIndex(Property) + usedHeaderSize, freeHeaderSize);
6348 char *dataPtr = dvPropertyGetIndexs(Property) - usedHeaderSize;
6349
6350 if(dvPropertyGetNumIndex(Property) == 0) {
6351 return;
6352 }
6353 *(dvProperty *)(void *)(dataPtr) = dvPropertyNull;
6354 *(uint32 *)(void *)(((dvProperty *)(void *)dataPtr) + 1) = size;
6355 dvPropertySetNumIndex(Property, 0);
6356 dvSetFreePropertyIndex(dvFreePropertyIndex() + size);
6357 }
6358
6359 /*----------------------------------------------------------------------------------------
6360 Resize the Property.Index array.
6361 ----------------------------------------------------------------------------------------*/
dvPropertyResizeIndexs(dvProperty Property,uint32 numIndexs)6362 void dvPropertyResizeIndexs(
6363 dvProperty Property,
6364 uint32 numIndexs)
6365 {
6366 uint32 freeSpace;
6367 uint32 elementSize = sizeof(char);
6368 uint32 usedHeaderSize = (sizeof(dvProperty) + elementSize - 1)/elementSize;
6369 uint32 freeHeaderSize = (sizeof(dvProperty) + sizeof(uint32) + elementSize - 1)/elementSize;
6370 uint32 newSize = utMax(numIndexs + usedHeaderSize, freeHeaderSize);
6371 uint32 oldSize = utMax(dvPropertyGetNumIndex(Property) + usedHeaderSize, freeHeaderSize);
6372 char *dataPtr;
6373
6374 if(numIndexs == 0) {
6375 if(dvPropertyGetNumIndex(Property) != 0) {
6376 dvPropertyFreeIndexs(Property);
6377 }
6378 return;
6379 }
6380 if(dvPropertyGetNumIndex(Property) == 0) {
6381 dvPropertyAllocIndexs(Property, numIndexs);
6382 return;
6383 }
6384 freeSpace = dvAllocatedPropertyIndex() - dvUsedPropertyIndex();
6385 if(freeSpace < newSize) {
6386 allocMorePropertyIndexs(newSize);
6387 }
6388 dataPtr = dvPropertyGetIndexs(Property) - usedHeaderSize;
6389 memcpy((void *)(dvPropertys.Index + dvUsedPropertyIndex()), dataPtr,
6390 elementSize*utMin(oldSize, newSize));
6391 if(newSize > oldSize) {
6392 memset(dvPropertys.Index + dvUsedPropertyIndex() + oldSize, 0, ((newSize - oldSize))*sizeof(char));
6393 }
6394 *(dvProperty *)(void *)dataPtr = dvPropertyNull;
6395 *(uint32 *)(void *)(((dvProperty *)(void *)dataPtr) + 1) = oldSize;
6396 dvSetFreePropertyIndex(dvFreePropertyIndex() + oldSize);
6397 dvPropertySetIndexIndex(Property, dvUsedPropertyIndex() + usedHeaderSize);
6398 dvPropertySetNumIndex(Property, numIndexs);
6399 dvSetUsedPropertyIndex(dvUsedPropertyIndex() + newSize);
6400 }
6401
6402 /*----------------------------------------------------------------------------------------
6403 Copy the properties of Property.
6404 ----------------------------------------------------------------------------------------*/
dvPropertyCopyProps(dvProperty oldProperty,dvProperty newProperty)6405 void dvPropertyCopyProps(
6406 dvProperty oldProperty,
6407 dvProperty newProperty)
6408 {
6409 dvPropertySetType(newProperty, dvPropertyGetType(oldProperty));
6410 dvPropertySetArray(newProperty, dvPropertyArray(oldProperty));
6411 dvPropertySetCascade(newProperty, dvPropertyCascade(oldProperty));
6412 dvPropertySetSparse(newProperty, dvPropertySparse(oldProperty));
6413 dvPropertySetExpanded(newProperty, dvPropertyExpanded(oldProperty));
6414 dvPropertySetFieldNumber(newProperty, dvPropertyGetFieldNumber(oldProperty));
6415 dvPropertySetHidden(newProperty, dvPropertyHidden(oldProperty));
6416 dvPropertySetFixedSize(newProperty, dvPropertyFixedSize(oldProperty));
6417 dvPropertySetLine(newProperty, dvPropertyGetLine(oldProperty));
6418 }
6419
6420 /*----------------------------------------------------------------------------------------
6421 Return the integer equivalent for the bit fields in Property.
6422 ----------------------------------------------------------------------------------------*/
dvPropertyGetBitfield(dvProperty _Property)6423 uint32 dvPropertyGetBitfield(
6424 dvProperty _Property)
6425 {
6426 uint32 bitfield = 0;
6427 uint8 xLevel = 0;
6428
6429 bitfield |= dvPropertyArray(_Property) << xLevel++;
6430 bitfield |= dvPropertyCascade(_Property) << xLevel++;
6431 bitfield |= dvPropertySparse(_Property) << xLevel++;
6432 bitfield |= dvPropertyExpanded(_Property) << xLevel++;
6433 bitfield |= dvPropertyHidden(_Property) << xLevel++;
6434 bitfield |= dvPropertyFixedSize(_Property) << xLevel++;
6435 return bitfield;
6436 }
6437
6438 /*----------------------------------------------------------------------------------------
6439 Set bit fields in Property using bitfield.
6440 ----------------------------------------------------------------------------------------*/
dvPropertySetBitfield(dvProperty _Property,uint32 bitfield)6441 void dvPropertySetBitfield(
6442 dvProperty _Property,
6443 uint32 bitfield)
6444 {
6445 dvPropertySetArray(_Property, bitfield & 1);
6446 bitfield >>= 1;
6447 dvPropertySetCascade(_Property, bitfield & 1);
6448 bitfield >>= 1;
6449 dvPropertySetSparse(_Property, bitfield & 1);
6450 bitfield >>= 1;
6451 dvPropertySetExpanded(_Property, bitfield & 1);
6452 bitfield >>= 1;
6453 dvPropertySetHidden(_Property, bitfield & 1);
6454 bitfield >>= 1;
6455 dvPropertySetFixedSize(_Property, bitfield & 1);
6456 bitfield >>= 1;
6457 }
6458
6459 /*----------------------------------------------------------------------------------------
6460 Add the Case to the head of the list on the Property.
6461 ----------------------------------------------------------------------------------------*/
dvPropertyInsertCase(dvProperty Property,dvCase _Case)6462 void dvPropertyInsertCase(
6463 dvProperty Property,
6464 dvCase _Case)
6465 {
6466 #if defined(DD_DEBUG)
6467 if(Property == dvPropertyNull) {
6468 utExit("Non-existent Property");
6469 }
6470 if(_Case == dvCaseNull) {
6471 utExit("Non-existent Case");
6472 }
6473 if(dvCaseGetProperty(_Case) != dvPropertyNull) {
6474 utExit("Attempting to add Case to Property twice");
6475 }
6476 #endif
6477 dvCaseSetNextPropertyCase(_Case, dvPropertyGetFirstCase(Property));
6478 dvPropertySetFirstCase(Property, _Case);
6479 if(dvPropertyGetLastCase(Property) == dvCaseNull) {
6480 dvPropertySetLastCase(Property, _Case);
6481 }
6482 dvCaseSetProperty(_Case, Property);
6483 }
6484
6485 /*----------------------------------------------------------------------------------------
6486 Add the Case to the end of the list on the Property.
6487 ----------------------------------------------------------------------------------------*/
dvPropertyAppendCase(dvProperty Property,dvCase _Case)6488 void dvPropertyAppendCase(
6489 dvProperty Property,
6490 dvCase _Case)
6491 {
6492 #if defined(DD_DEBUG)
6493 if(Property == dvPropertyNull) {
6494 utExit("Non-existent Property");
6495 }
6496 if(_Case == dvCaseNull) {
6497 utExit("Non-existent Case");
6498 }
6499 if(dvCaseGetProperty(_Case) != dvPropertyNull) {
6500 utExit("Attempting to add Case to Property twice");
6501 }
6502 #endif
6503 if(dvPropertyGetLastCase(Property) != dvCaseNull) {
6504 dvCaseSetNextPropertyCase(dvPropertyGetLastCase(Property), _Case);
6505 } else {
6506 dvPropertySetFirstCase(Property, _Case);
6507 }
6508 dvPropertySetLastCase(Property, _Case);
6509 dvCaseSetNextPropertyCase(_Case, dvCaseNull);
6510 dvCaseSetProperty(_Case, Property);
6511 }
6512
6513 /*----------------------------------------------------------------------------------------
6514 Insert the Case to the Property after the previous Case.
6515 ----------------------------------------------------------------------------------------*/
dvPropertyInsertAfterCase(dvProperty Property,dvCase prevCase,dvCase _Case)6516 void dvPropertyInsertAfterCase(
6517 dvProperty Property,
6518 dvCase prevCase,
6519 dvCase _Case)
6520 {
6521 dvCase nextCase = dvCaseGetNextPropertyCase(prevCase);
6522
6523 #if defined(DD_DEBUG)
6524 if(Property == dvPropertyNull) {
6525 utExit("Non-existent Property");
6526 }
6527 if(_Case == dvCaseNull) {
6528 utExit("Non-existent Case");
6529 }
6530 if(dvCaseGetProperty(_Case) != dvPropertyNull) {
6531 utExit("Attempting to add Case to Property twice");
6532 }
6533 #endif
6534 dvCaseSetNextPropertyCase(_Case, nextCase);
6535 dvCaseSetNextPropertyCase(prevCase, _Case);
6536 if(dvPropertyGetLastCase(Property) == prevCase) {
6537 dvPropertySetLastCase(Property, _Case);
6538 }
6539 dvCaseSetProperty(_Case, Property);
6540 }
6541
6542 /*----------------------------------------------------------------------------------------
6543 Remove the Case from the Property.
6544 ----------------------------------------------------------------------------------------*/
dvPropertyRemoveCase(dvProperty Property,dvCase _Case)6545 void dvPropertyRemoveCase(
6546 dvProperty Property,
6547 dvCase _Case)
6548 {
6549 dvCase pCase, nCase;
6550
6551 #if defined(DD_DEBUG)
6552 if(_Case == dvCaseNull) {
6553 utExit("Non-existent Case");
6554 }
6555 if(dvCaseGetProperty(_Case) != dvPropertyNull && dvCaseGetProperty(_Case) != Property) {
6556 utExit("Delete Case from non-owning Property");
6557 }
6558 #endif
6559 pCase = dvCaseNull;
6560 for(nCase = dvPropertyGetFirstCase(Property); nCase != dvCaseNull && nCase != _Case;
6561 nCase = dvCaseGetNextPropertyCase(nCase)) {
6562 pCase = nCase;
6563 }
6564 if(pCase != dvCaseNull) {
6565 dvCaseSetNextPropertyCase(pCase, dvCaseGetNextPropertyCase(_Case));
6566 } else {
6567 dvPropertySetFirstCase(Property, dvCaseGetNextPropertyCase(_Case));
6568 }
6569 dvCaseSetNextPropertyCase(_Case, dvCaseNull);
6570 if(dvPropertyGetLastCase(Property) == _Case) {
6571 dvPropertySetLastCase(Property, pCase);
6572 }
6573 dvCaseSetProperty(_Case, dvPropertyNull);
6574 }
6575
6576 /*----------------------------------------------------------------------------------------
6577 Add the Key to the head of the list on the Property.
6578 ----------------------------------------------------------------------------------------*/
dvPropertyInsertKey(dvProperty Property,dvKey _Key)6579 void dvPropertyInsertKey(
6580 dvProperty Property,
6581 dvKey _Key)
6582 {
6583 #if defined(DD_DEBUG)
6584 if(Property == dvPropertyNull) {
6585 utExit("Non-existent Property");
6586 }
6587 if(_Key == dvKeyNull) {
6588 utExit("Non-existent Key");
6589 }
6590 if(dvKeyGetProperty(_Key) != dvPropertyNull) {
6591 utExit("Attempting to add Key to Property twice");
6592 }
6593 #endif
6594 dvKeySetNextPropertyKey(_Key, dvPropertyGetFirstKey(Property));
6595 dvPropertySetFirstKey(Property, _Key);
6596 if(dvPropertyGetLastKey(Property) == dvKeyNull) {
6597 dvPropertySetLastKey(Property, _Key);
6598 }
6599 dvKeySetProperty(_Key, Property);
6600 }
6601
6602 /*----------------------------------------------------------------------------------------
6603 Add the Key to the end of the list on the Property.
6604 ----------------------------------------------------------------------------------------*/
dvPropertyAppendKey(dvProperty Property,dvKey _Key)6605 void dvPropertyAppendKey(
6606 dvProperty Property,
6607 dvKey _Key)
6608 {
6609 #if defined(DD_DEBUG)
6610 if(Property == dvPropertyNull) {
6611 utExit("Non-existent Property");
6612 }
6613 if(_Key == dvKeyNull) {
6614 utExit("Non-existent Key");
6615 }
6616 if(dvKeyGetProperty(_Key) != dvPropertyNull) {
6617 utExit("Attempting to add Key to Property twice");
6618 }
6619 #endif
6620 if(dvPropertyGetLastKey(Property) != dvKeyNull) {
6621 dvKeySetNextPropertyKey(dvPropertyGetLastKey(Property), _Key);
6622 } else {
6623 dvPropertySetFirstKey(Property, _Key);
6624 }
6625 dvPropertySetLastKey(Property, _Key);
6626 dvKeySetNextPropertyKey(_Key, dvKeyNull);
6627 dvKeySetProperty(_Key, Property);
6628 }
6629
6630 /*----------------------------------------------------------------------------------------
6631 Insert the Key to the Property after the previous Key.
6632 ----------------------------------------------------------------------------------------*/
dvPropertyInsertAfterKey(dvProperty Property,dvKey prevKey,dvKey _Key)6633 void dvPropertyInsertAfterKey(
6634 dvProperty Property,
6635 dvKey prevKey,
6636 dvKey _Key)
6637 {
6638 dvKey nextKey = dvKeyGetNextPropertyKey(prevKey);
6639
6640 #if defined(DD_DEBUG)
6641 if(Property == dvPropertyNull) {
6642 utExit("Non-existent Property");
6643 }
6644 if(_Key == dvKeyNull) {
6645 utExit("Non-existent Key");
6646 }
6647 if(dvKeyGetProperty(_Key) != dvPropertyNull) {
6648 utExit("Attempting to add Key to Property twice");
6649 }
6650 #endif
6651 dvKeySetNextPropertyKey(_Key, nextKey);
6652 dvKeySetNextPropertyKey(prevKey, _Key);
6653 if(dvPropertyGetLastKey(Property) == prevKey) {
6654 dvPropertySetLastKey(Property, _Key);
6655 }
6656 dvKeySetProperty(_Key, Property);
6657 }
6658
6659 /*----------------------------------------------------------------------------------------
6660 Remove the Key from the Property.
6661 ----------------------------------------------------------------------------------------*/
dvPropertyRemoveKey(dvProperty Property,dvKey _Key)6662 void dvPropertyRemoveKey(
6663 dvProperty Property,
6664 dvKey _Key)
6665 {
6666 dvKey pKey, nKey;
6667
6668 #if defined(DD_DEBUG)
6669 if(_Key == dvKeyNull) {
6670 utExit("Non-existent Key");
6671 }
6672 if(dvKeyGetProperty(_Key) != dvPropertyNull && dvKeyGetProperty(_Key) != Property) {
6673 utExit("Delete Key from non-owning Property");
6674 }
6675 #endif
6676 pKey = dvKeyNull;
6677 for(nKey = dvPropertyGetFirstKey(Property); nKey != dvKeyNull && nKey != _Key;
6678 nKey = dvKeyGetNextPropertyKey(nKey)) {
6679 pKey = nKey;
6680 }
6681 if(pKey != dvKeyNull) {
6682 dvKeySetNextPropertyKey(pKey, dvKeyGetNextPropertyKey(_Key));
6683 } else {
6684 dvPropertySetFirstKey(Property, dvKeyGetNextPropertyKey(_Key));
6685 }
6686 dvKeySetNextPropertyKey(_Key, dvKeyNull);
6687 if(dvPropertyGetLastKey(Property) == _Key) {
6688 dvPropertySetLastKey(Property, pKey);
6689 }
6690 dvKeySetProperty(_Key, dvPropertyNull);
6691 }
6692
6693 #if defined(DD_DEBUG)
6694 /*----------------------------------------------------------------------------------------
6695 Write out all the fields of an object.
6696 ----------------------------------------------------------------------------------------*/
dvShowProperty(dvProperty Property)6697 void dvShowProperty(
6698 dvProperty Property)
6699 {
6700 utDatabaseShowObject("dv", "Property", dvProperty2Index(Property));
6701 }
6702 #endif
6703
6704 /*----------------------------------------------------------------------------------------
6705 Destroy Sparsegroup including everything in it. Remove from parents.
6706 ----------------------------------------------------------------------------------------*/
dvSparsegroupDestroy(dvSparsegroup Sparsegroup)6707 void dvSparsegroupDestroy(
6708 dvSparsegroup Sparsegroup)
6709 {
6710 dvClass owningClass = dvSparsegroupGetClass(Sparsegroup);
6711 dvRelationship owningRelationship = dvSparsegroupGetRelationship(Sparsegroup);
6712
6713 if(dvSparsegroupDestructorCallback != NULL) {
6714 dvSparsegroupDestructorCallback(Sparsegroup);
6715 }
6716 if(owningClass != dvClassNull) {
6717 dvClassRemoveSparsegroup(owningClass, Sparsegroup);
6718 #if defined(DD_DEBUG)
6719 } else {
6720 utExit("Sparsegroup without owning Class");
6721 #endif
6722 }
6723 if(owningRelationship != dvRelationshipNull) {
6724 dvRelationshipSetParentSparsegroup(owningRelationship, dvSparsegroupNull);
6725 }
6726 if(owningRelationship != dvRelationshipNull) {
6727 dvRelationshipSetChildSparsegroup(owningRelationship, dvSparsegroupNull);
6728 }
6729 dvSparsegroupFree(Sparsegroup);
6730 }
6731
6732 /*----------------------------------------------------------------------------------------
6733 Default constructor wrapper for the database manager.
6734 ----------------------------------------------------------------------------------------*/
allocSparsegroup(void)6735 static uint64 allocSparsegroup(void)
6736 {
6737 dvSparsegroup Sparsegroup = dvSparsegroupAlloc();
6738
6739 return dvSparsegroup2Index(Sparsegroup);
6740 }
6741
6742 /*----------------------------------------------------------------------------------------
6743 Destructor wrapper for the database manager.
6744 ----------------------------------------------------------------------------------------*/
destroySparsegroup(uint64 objectIndex)6745 static void destroySparsegroup(
6746 uint64 objectIndex)
6747 {
6748 dvSparsegroupDestroy(dvIndex2Sparsegroup((uint32)objectIndex));
6749 }
6750
6751 /*----------------------------------------------------------------------------------------
6752 Allocate the field arrays of Sparsegroup.
6753 ----------------------------------------------------------------------------------------*/
allocSparsegroups(void)6754 static void allocSparsegroups(void)
6755 {
6756 dvSetAllocatedSparsegroup(2);
6757 dvSetUsedSparsegroup(0);
6758 dvSetFirstFreeSparsegroup(dvSparsegroupNull);
6759 dvSparsegroups.Sym = utNewA(utSym, (dvAllocatedSparsegroup()));
6760 dvSparsegroups.Class = utNewA(dvClass, (dvAllocatedSparsegroup()));
6761 dvSparsegroups.NextClassSparsegroup = utNewA(dvSparsegroup, (dvAllocatedSparsegroup()));
6762 dvSparsegroups.PrevClassSparsegroup = utNewA(dvSparsegroup, (dvAllocatedSparsegroup()));
6763 dvSparsegroups.NextTableClassSparsegroup = utNewA(dvSparsegroup, (dvAllocatedSparsegroup()));
6764 dvSparsegroups.FirstProperty = utNewA(dvProperty, (dvAllocatedSparsegroup()));
6765 dvSparsegroups.LastProperty = utNewA(dvProperty, (dvAllocatedSparsegroup()));
6766 dvSparsegroups.Relationship = utNewA(dvRelationship, (dvAllocatedSparsegroup()));
6767 }
6768
6769 /*----------------------------------------------------------------------------------------
6770 Realloc the arrays of properties for class Sparsegroup.
6771 ----------------------------------------------------------------------------------------*/
reallocSparsegroups(uint32 newSize)6772 static void reallocSparsegroups(
6773 uint32 newSize)
6774 {
6775 utResizeArray(dvSparsegroups.Sym, (newSize));
6776 utResizeArray(dvSparsegroups.Class, (newSize));
6777 utResizeArray(dvSparsegroups.NextClassSparsegroup, (newSize));
6778 utResizeArray(dvSparsegroups.PrevClassSparsegroup, (newSize));
6779 utResizeArray(dvSparsegroups.NextTableClassSparsegroup, (newSize));
6780 utResizeArray(dvSparsegroups.FirstProperty, (newSize));
6781 utResizeArray(dvSparsegroups.LastProperty, (newSize));
6782 utResizeArray(dvSparsegroups.Relationship, (newSize));
6783 dvSetAllocatedSparsegroup(newSize);
6784 }
6785
6786 /*----------------------------------------------------------------------------------------
6787 Allocate more Sparsegroups.
6788 ----------------------------------------------------------------------------------------*/
dvSparsegroupAllocMore(void)6789 void dvSparsegroupAllocMore(void)
6790 {
6791 reallocSparsegroups((uint32)(dvAllocatedSparsegroup() + (dvAllocatedSparsegroup() >> 1)));
6792 }
6793
6794 /*----------------------------------------------------------------------------------------
6795 Copy the properties of Sparsegroup.
6796 ----------------------------------------------------------------------------------------*/
dvSparsegroupCopyProps(dvSparsegroup oldSparsegroup,dvSparsegroup newSparsegroup)6797 void dvSparsegroupCopyProps(
6798 dvSparsegroup oldSparsegroup,
6799 dvSparsegroup newSparsegroup)
6800 {
6801 }
6802
6803 /*----------------------------------------------------------------------------------------
6804 Add the Property to the head of the list on the Sparsegroup.
6805 ----------------------------------------------------------------------------------------*/
dvSparsegroupInsertProperty(dvSparsegroup Sparsegroup,dvProperty _Property)6806 void dvSparsegroupInsertProperty(
6807 dvSparsegroup Sparsegroup,
6808 dvProperty _Property)
6809 {
6810 #if defined(DD_DEBUG)
6811 if(Sparsegroup == dvSparsegroupNull) {
6812 utExit("Non-existent Sparsegroup");
6813 }
6814 if(_Property == dvPropertyNull) {
6815 utExit("Non-existent Property");
6816 }
6817 if(dvPropertyGetSparsegroup(_Property) != dvSparsegroupNull) {
6818 utExit("Attempting to add Property to Sparsegroup twice");
6819 }
6820 #endif
6821 dvPropertySetNextSparsegroupProperty(_Property, dvSparsegroupGetFirstProperty(Sparsegroup));
6822 dvSparsegroupSetFirstProperty(Sparsegroup, _Property);
6823 if(dvSparsegroupGetLastProperty(Sparsegroup) == dvPropertyNull) {
6824 dvSparsegroupSetLastProperty(Sparsegroup, _Property);
6825 }
6826 dvPropertySetSparsegroup(_Property, Sparsegroup);
6827 }
6828
6829 /*----------------------------------------------------------------------------------------
6830 Add the Property to the end of the list on the Sparsegroup.
6831 ----------------------------------------------------------------------------------------*/
dvSparsegroupAppendProperty(dvSparsegroup Sparsegroup,dvProperty _Property)6832 void dvSparsegroupAppendProperty(
6833 dvSparsegroup Sparsegroup,
6834 dvProperty _Property)
6835 {
6836 #if defined(DD_DEBUG)
6837 if(Sparsegroup == dvSparsegroupNull) {
6838 utExit("Non-existent Sparsegroup");
6839 }
6840 if(_Property == dvPropertyNull) {
6841 utExit("Non-existent Property");
6842 }
6843 if(dvPropertyGetSparsegroup(_Property) != dvSparsegroupNull) {
6844 utExit("Attempting to add Property to Sparsegroup twice");
6845 }
6846 #endif
6847 if(dvSparsegroupGetLastProperty(Sparsegroup) != dvPropertyNull) {
6848 dvPropertySetNextSparsegroupProperty(dvSparsegroupGetLastProperty(Sparsegroup), _Property);
6849 } else {
6850 dvSparsegroupSetFirstProperty(Sparsegroup, _Property);
6851 }
6852 dvSparsegroupSetLastProperty(Sparsegroup, _Property);
6853 dvPropertySetNextSparsegroupProperty(_Property, dvPropertyNull);
6854 dvPropertySetSparsegroup(_Property, Sparsegroup);
6855 }
6856
6857 /*----------------------------------------------------------------------------------------
6858 Insert the Property to the Sparsegroup after the previous Property.
6859 ----------------------------------------------------------------------------------------*/
dvSparsegroupInsertAfterProperty(dvSparsegroup Sparsegroup,dvProperty prevProperty,dvProperty _Property)6860 void dvSparsegroupInsertAfterProperty(
6861 dvSparsegroup Sparsegroup,
6862 dvProperty prevProperty,
6863 dvProperty _Property)
6864 {
6865 dvProperty nextProperty = dvPropertyGetNextSparsegroupProperty(prevProperty);
6866
6867 #if defined(DD_DEBUG)
6868 if(Sparsegroup == dvSparsegroupNull) {
6869 utExit("Non-existent Sparsegroup");
6870 }
6871 if(_Property == dvPropertyNull) {
6872 utExit("Non-existent Property");
6873 }
6874 if(dvPropertyGetSparsegroup(_Property) != dvSparsegroupNull) {
6875 utExit("Attempting to add Property to Sparsegroup twice");
6876 }
6877 #endif
6878 dvPropertySetNextSparsegroupProperty(_Property, nextProperty);
6879 dvPropertySetNextSparsegroupProperty(prevProperty, _Property);
6880 if(dvSparsegroupGetLastProperty(Sparsegroup) == prevProperty) {
6881 dvSparsegroupSetLastProperty(Sparsegroup, _Property);
6882 }
6883 dvPropertySetSparsegroup(_Property, Sparsegroup);
6884 }
6885
6886 /*----------------------------------------------------------------------------------------
6887 Remove the Property from the Sparsegroup.
6888 ----------------------------------------------------------------------------------------*/
dvSparsegroupRemoveProperty(dvSparsegroup Sparsegroup,dvProperty _Property)6889 void dvSparsegroupRemoveProperty(
6890 dvSparsegroup Sparsegroup,
6891 dvProperty _Property)
6892 {
6893 dvProperty pProperty, nProperty;
6894
6895 #if defined(DD_DEBUG)
6896 if(_Property == dvPropertyNull) {
6897 utExit("Non-existent Property");
6898 }
6899 if(dvPropertyGetSparsegroup(_Property) != dvSparsegroupNull && dvPropertyGetSparsegroup(_Property) != Sparsegroup) {
6900 utExit("Delete Property from non-owning Sparsegroup");
6901 }
6902 #endif
6903 pProperty = dvPropertyNull;
6904 for(nProperty = dvSparsegroupGetFirstProperty(Sparsegroup); nProperty != dvPropertyNull && nProperty != _Property;
6905 nProperty = dvPropertyGetNextSparsegroupProperty(nProperty)) {
6906 pProperty = nProperty;
6907 }
6908 if(pProperty != dvPropertyNull) {
6909 dvPropertySetNextSparsegroupProperty(pProperty, dvPropertyGetNextSparsegroupProperty(_Property));
6910 } else {
6911 dvSparsegroupSetFirstProperty(Sparsegroup, dvPropertyGetNextSparsegroupProperty(_Property));
6912 }
6913 dvPropertySetNextSparsegroupProperty(_Property, dvPropertyNull);
6914 if(dvSparsegroupGetLastProperty(Sparsegroup) == _Property) {
6915 dvSparsegroupSetLastProperty(Sparsegroup, pProperty);
6916 }
6917 dvPropertySetSparsegroup(_Property, dvSparsegroupNull);
6918 }
6919
6920 #if defined(DD_DEBUG)
6921 /*----------------------------------------------------------------------------------------
6922 Write out all the fields of an object.
6923 ----------------------------------------------------------------------------------------*/
dvShowSparsegroup(dvSparsegroup Sparsegroup)6924 void dvShowSparsegroup(
6925 dvSparsegroup Sparsegroup)
6926 {
6927 utDatabaseShowObject("dv", "Sparsegroup", dvSparsegroup2Index(Sparsegroup));
6928 }
6929 #endif
6930
6931 /*----------------------------------------------------------------------------------------
6932 Default constructor wrapper for the database manager.
6933 ----------------------------------------------------------------------------------------*/
allocRelationship(void)6934 static uint64 allocRelationship(void)
6935 {
6936 dvRelationship Relationship = dvRelationshipAlloc();
6937
6938 return dvRelationship2Index(Relationship);
6939 }
6940
6941 /*----------------------------------------------------------------------------------------
6942 Allocate the field arrays of Relationship.
6943 ----------------------------------------------------------------------------------------*/
allocRelationships(void)6944 static void allocRelationships(void)
6945 {
6946 dvSetAllocatedRelationship(2);
6947 dvSetUsedRelationship(0);
6948 dvRelationships.Type = utNewA(dvRelationshipType, (dvAllocatedRelationship()));
6949 dvRelationships.ParentLabelSym = utNewA(utSym, (dvAllocatedRelationship()));
6950 dvRelationships.ChildLabelSym = utNewA(utSym, (dvAllocatedRelationship()));
6951 dvRelationships.Mandatory = utNewA(uint8, (dvAllocatedRelationship() + 7) >> 3);
6952 dvRelationships.Cascade = utNewA(uint8, (dvAllocatedRelationship() + 7) >> 3);
6953 dvRelationships.AccessChild = utNewA(uint8, (dvAllocatedRelationship() + 7) >> 3);
6954 dvRelationships.AccessParent = utNewA(uint8, (dvAllocatedRelationship() + 7) >> 3);
6955 dvRelationships.SharedParent = utNewA(uint8, (dvAllocatedRelationship() + 7) >> 3);
6956 dvRelationships.Sparse = utNewA(uint8, (dvAllocatedRelationship() + 7) >> 3);
6957 dvRelationships.Expanded = utNewA(uint8, (dvAllocatedRelationship() + 7) >> 3);
6958 dvRelationships.Schema = utNewA(dvSchema, (dvAllocatedRelationship()));
6959 dvRelationships.NextSchemaRelationship = utNewA(dvRelationship, (dvAllocatedRelationship()));
6960 dvRelationships.ParentClass = utNewA(dvClass, (dvAllocatedRelationship()));
6961 dvRelationships.NextClassChildRelationship = utNewA(dvRelationship, (dvAllocatedRelationship()));
6962 dvRelationships.ChildClass = utNewA(dvClass, (dvAllocatedRelationship()));
6963 dvRelationships.NextClassParentRelationship = utNewA(dvRelationship, (dvAllocatedRelationship()));
6964 dvRelationships.FirstProperty = utNewA(dvProperty, (dvAllocatedRelationship()));
6965 dvRelationships.LastProperty = utNewA(dvProperty, (dvAllocatedRelationship()));
6966 dvRelationships.FirstKey = utNewA(dvKey, (dvAllocatedRelationship()));
6967 dvRelationships.LastKey = utNewA(dvKey, (dvAllocatedRelationship()));
6968 dvRelationships.ParentSparsegroup = utNewA(dvSparsegroup, (dvAllocatedRelationship()));
6969 dvRelationships.ChildSparsegroup = utNewA(dvSparsegroup, (dvAllocatedRelationship()));
6970 }
6971
6972 /*----------------------------------------------------------------------------------------
6973 Realloc the arrays of properties for class Relationship.
6974 ----------------------------------------------------------------------------------------*/
reallocRelationships(uint32 newSize)6975 static void reallocRelationships(
6976 uint32 newSize)
6977 {
6978 utResizeArray(dvRelationships.Type, (newSize));
6979 utResizeArray(dvRelationships.ParentLabelSym, (newSize));
6980 utResizeArray(dvRelationships.ChildLabelSym, (newSize));
6981 utResizeArray(dvRelationships.Mandatory, (newSize + 7) >> 3);
6982 utResizeArray(dvRelationships.Cascade, (newSize + 7) >> 3);
6983 utResizeArray(dvRelationships.AccessChild, (newSize + 7) >> 3);
6984 utResizeArray(dvRelationships.AccessParent, (newSize + 7) >> 3);
6985 utResizeArray(dvRelationships.SharedParent, (newSize + 7) >> 3);
6986 utResizeArray(dvRelationships.Sparse, (newSize + 7) >> 3);
6987 utResizeArray(dvRelationships.Expanded, (newSize + 7) >> 3);
6988 utResizeArray(dvRelationships.Schema, (newSize));
6989 utResizeArray(dvRelationships.NextSchemaRelationship, (newSize));
6990 utResizeArray(dvRelationships.ParentClass, (newSize));
6991 utResizeArray(dvRelationships.NextClassChildRelationship, (newSize));
6992 utResizeArray(dvRelationships.ChildClass, (newSize));
6993 utResizeArray(dvRelationships.NextClassParentRelationship, (newSize));
6994 utResizeArray(dvRelationships.FirstProperty, (newSize));
6995 utResizeArray(dvRelationships.LastProperty, (newSize));
6996 utResizeArray(dvRelationships.FirstKey, (newSize));
6997 utResizeArray(dvRelationships.LastKey, (newSize));
6998 utResizeArray(dvRelationships.ParentSparsegroup, (newSize));
6999 utResizeArray(dvRelationships.ChildSparsegroup, (newSize));
7000 dvSetAllocatedRelationship(newSize);
7001 }
7002
7003 /*----------------------------------------------------------------------------------------
7004 Allocate more Relationships.
7005 ----------------------------------------------------------------------------------------*/
dvRelationshipAllocMore(void)7006 void dvRelationshipAllocMore(void)
7007 {
7008 reallocRelationships((uint32)(dvAllocatedRelationship() + (dvAllocatedRelationship() >> 1)));
7009 }
7010
7011 /*----------------------------------------------------------------------------------------
7012 Copy the properties of Relationship.
7013 ----------------------------------------------------------------------------------------*/
dvRelationshipCopyProps(dvRelationship oldRelationship,dvRelationship newRelationship)7014 void dvRelationshipCopyProps(
7015 dvRelationship oldRelationship,
7016 dvRelationship newRelationship)
7017 {
7018 dvRelationshipSetType(newRelationship, dvRelationshipGetType(oldRelationship));
7019 dvRelationshipSetParentLabelSym(newRelationship, dvRelationshipGetParentLabelSym(oldRelationship));
7020 dvRelationshipSetChildLabelSym(newRelationship, dvRelationshipGetChildLabelSym(oldRelationship));
7021 dvRelationshipSetMandatory(newRelationship, dvRelationshipMandatory(oldRelationship));
7022 dvRelationshipSetCascade(newRelationship, dvRelationshipCascade(oldRelationship));
7023 dvRelationshipSetAccessChild(newRelationship, dvRelationshipAccessChild(oldRelationship));
7024 dvRelationshipSetAccessParent(newRelationship, dvRelationshipAccessParent(oldRelationship));
7025 dvRelationshipSetSharedParent(newRelationship, dvRelationshipSharedParent(oldRelationship));
7026 dvRelationshipSetSparse(newRelationship, dvRelationshipSparse(oldRelationship));
7027 dvRelationshipSetExpanded(newRelationship, dvRelationshipExpanded(oldRelationship));
7028 }
7029
7030 /*----------------------------------------------------------------------------------------
7031 Return the integer equivalent for the bit fields in Relationship.
7032 ----------------------------------------------------------------------------------------*/
dvRelationshipGetBitfield(dvRelationship _Relationship)7033 uint32 dvRelationshipGetBitfield(
7034 dvRelationship _Relationship)
7035 {
7036 uint32 bitfield = 0;
7037 uint8 xLevel = 0;
7038
7039 bitfield |= dvRelationshipMandatory(_Relationship) << xLevel++;
7040 bitfield |= dvRelationshipCascade(_Relationship) << xLevel++;
7041 bitfield |= dvRelationshipAccessChild(_Relationship) << xLevel++;
7042 bitfield |= dvRelationshipAccessParent(_Relationship) << xLevel++;
7043 bitfield |= dvRelationshipSharedParent(_Relationship) << xLevel++;
7044 bitfield |= dvRelationshipSparse(_Relationship) << xLevel++;
7045 bitfield |= dvRelationshipExpanded(_Relationship) << xLevel++;
7046 return bitfield;
7047 }
7048
7049 /*----------------------------------------------------------------------------------------
7050 Set bit fields in Relationship using bitfield.
7051 ----------------------------------------------------------------------------------------*/
dvRelationshipSetBitfield(dvRelationship _Relationship,uint32 bitfield)7052 void dvRelationshipSetBitfield(
7053 dvRelationship _Relationship,
7054 uint32 bitfield)
7055 {
7056 dvRelationshipSetMandatory(_Relationship, bitfield & 1);
7057 bitfield >>= 1;
7058 dvRelationshipSetCascade(_Relationship, bitfield & 1);
7059 bitfield >>= 1;
7060 dvRelationshipSetAccessChild(_Relationship, bitfield & 1);
7061 bitfield >>= 1;
7062 dvRelationshipSetAccessParent(_Relationship, bitfield & 1);
7063 bitfield >>= 1;
7064 dvRelationshipSetSharedParent(_Relationship, bitfield & 1);
7065 bitfield >>= 1;
7066 dvRelationshipSetSparse(_Relationship, bitfield & 1);
7067 bitfield >>= 1;
7068 dvRelationshipSetExpanded(_Relationship, bitfield & 1);
7069 bitfield >>= 1;
7070 }
7071
7072 /*----------------------------------------------------------------------------------------
7073 Add the Property to the head of the list on the Relationship.
7074 ----------------------------------------------------------------------------------------*/
dvRelationshipInsertProperty(dvRelationship Relationship,dvProperty _Property)7075 void dvRelationshipInsertProperty(
7076 dvRelationship Relationship,
7077 dvProperty _Property)
7078 {
7079 #if defined(DD_DEBUG)
7080 if(Relationship == dvRelationshipNull) {
7081 utExit("Non-existent Relationship");
7082 }
7083 if(_Property == dvPropertyNull) {
7084 utExit("Non-existent Property");
7085 }
7086 if(dvPropertyGetRelationship(_Property) != dvRelationshipNull) {
7087 utExit("Attempting to add Property to Relationship twice");
7088 }
7089 #endif
7090 dvPropertySetNextRelationshipProperty(_Property, dvRelationshipGetFirstProperty(Relationship));
7091 dvRelationshipSetFirstProperty(Relationship, _Property);
7092 if(dvRelationshipGetLastProperty(Relationship) == dvPropertyNull) {
7093 dvRelationshipSetLastProperty(Relationship, _Property);
7094 }
7095 dvPropertySetRelationship(_Property, Relationship);
7096 }
7097
7098 /*----------------------------------------------------------------------------------------
7099 Add the Property to the end of the list on the Relationship.
7100 ----------------------------------------------------------------------------------------*/
dvRelationshipAppendProperty(dvRelationship Relationship,dvProperty _Property)7101 void dvRelationshipAppendProperty(
7102 dvRelationship Relationship,
7103 dvProperty _Property)
7104 {
7105 #if defined(DD_DEBUG)
7106 if(Relationship == dvRelationshipNull) {
7107 utExit("Non-existent Relationship");
7108 }
7109 if(_Property == dvPropertyNull) {
7110 utExit("Non-existent Property");
7111 }
7112 if(dvPropertyGetRelationship(_Property) != dvRelationshipNull) {
7113 utExit("Attempting to add Property to Relationship twice");
7114 }
7115 #endif
7116 if(dvRelationshipGetLastProperty(Relationship) != dvPropertyNull) {
7117 dvPropertySetNextRelationshipProperty(dvRelationshipGetLastProperty(Relationship), _Property);
7118 } else {
7119 dvRelationshipSetFirstProperty(Relationship, _Property);
7120 }
7121 dvRelationshipSetLastProperty(Relationship, _Property);
7122 dvPropertySetNextRelationshipProperty(_Property, dvPropertyNull);
7123 dvPropertySetRelationship(_Property, Relationship);
7124 }
7125
7126 /*----------------------------------------------------------------------------------------
7127 Insert the Property to the Relationship after the previous Property.
7128 ----------------------------------------------------------------------------------------*/
dvRelationshipInsertAfterProperty(dvRelationship Relationship,dvProperty prevProperty,dvProperty _Property)7129 void dvRelationshipInsertAfterProperty(
7130 dvRelationship Relationship,
7131 dvProperty prevProperty,
7132 dvProperty _Property)
7133 {
7134 dvProperty nextProperty = dvPropertyGetNextRelationshipProperty(prevProperty);
7135
7136 #if defined(DD_DEBUG)
7137 if(Relationship == dvRelationshipNull) {
7138 utExit("Non-existent Relationship");
7139 }
7140 if(_Property == dvPropertyNull) {
7141 utExit("Non-existent Property");
7142 }
7143 if(dvPropertyGetRelationship(_Property) != dvRelationshipNull) {
7144 utExit("Attempting to add Property to Relationship twice");
7145 }
7146 #endif
7147 dvPropertySetNextRelationshipProperty(_Property, nextProperty);
7148 dvPropertySetNextRelationshipProperty(prevProperty, _Property);
7149 if(dvRelationshipGetLastProperty(Relationship) == prevProperty) {
7150 dvRelationshipSetLastProperty(Relationship, _Property);
7151 }
7152 dvPropertySetRelationship(_Property, Relationship);
7153 }
7154
7155 /*----------------------------------------------------------------------------------------
7156 Remove the Property from the Relationship.
7157 ----------------------------------------------------------------------------------------*/
dvRelationshipRemoveProperty(dvRelationship Relationship,dvProperty _Property)7158 void dvRelationshipRemoveProperty(
7159 dvRelationship Relationship,
7160 dvProperty _Property)
7161 {
7162 dvProperty pProperty, nProperty;
7163
7164 #if defined(DD_DEBUG)
7165 if(_Property == dvPropertyNull) {
7166 utExit("Non-existent Property");
7167 }
7168 if(dvPropertyGetRelationship(_Property) != dvRelationshipNull && dvPropertyGetRelationship(_Property) != Relationship) {
7169 utExit("Delete Property from non-owning Relationship");
7170 }
7171 #endif
7172 pProperty = dvPropertyNull;
7173 for(nProperty = dvRelationshipGetFirstProperty(Relationship); nProperty != dvPropertyNull && nProperty != _Property;
7174 nProperty = dvPropertyGetNextRelationshipProperty(nProperty)) {
7175 pProperty = nProperty;
7176 }
7177 if(pProperty != dvPropertyNull) {
7178 dvPropertySetNextRelationshipProperty(pProperty, dvPropertyGetNextRelationshipProperty(_Property));
7179 } else {
7180 dvRelationshipSetFirstProperty(Relationship, dvPropertyGetNextRelationshipProperty(_Property));
7181 }
7182 dvPropertySetNextRelationshipProperty(_Property, dvPropertyNull);
7183 if(dvRelationshipGetLastProperty(Relationship) == _Property) {
7184 dvRelationshipSetLastProperty(Relationship, pProperty);
7185 }
7186 dvPropertySetRelationship(_Property, dvRelationshipNull);
7187 }
7188
7189 /*----------------------------------------------------------------------------------------
7190 Add the Key to the head of the list on the Relationship.
7191 ----------------------------------------------------------------------------------------*/
dvRelationshipInsertKey(dvRelationship Relationship,dvKey _Key)7192 void dvRelationshipInsertKey(
7193 dvRelationship Relationship,
7194 dvKey _Key)
7195 {
7196 #if defined(DD_DEBUG)
7197 if(Relationship == dvRelationshipNull) {
7198 utExit("Non-existent Relationship");
7199 }
7200 if(_Key == dvKeyNull) {
7201 utExit("Non-existent Key");
7202 }
7203 if(dvKeyGetRelationship(_Key) != dvRelationshipNull) {
7204 utExit("Attempting to add Key to Relationship twice");
7205 }
7206 #endif
7207 dvKeySetNextRelationshipKey(_Key, dvRelationshipGetFirstKey(Relationship));
7208 dvRelationshipSetFirstKey(Relationship, _Key);
7209 if(dvRelationshipGetLastKey(Relationship) == dvKeyNull) {
7210 dvRelationshipSetLastKey(Relationship, _Key);
7211 }
7212 dvKeySetRelationship(_Key, Relationship);
7213 }
7214
7215 /*----------------------------------------------------------------------------------------
7216 Add the Key to the end of the list on the Relationship.
7217 ----------------------------------------------------------------------------------------*/
dvRelationshipAppendKey(dvRelationship Relationship,dvKey _Key)7218 void dvRelationshipAppendKey(
7219 dvRelationship Relationship,
7220 dvKey _Key)
7221 {
7222 #if defined(DD_DEBUG)
7223 if(Relationship == dvRelationshipNull) {
7224 utExit("Non-existent Relationship");
7225 }
7226 if(_Key == dvKeyNull) {
7227 utExit("Non-existent Key");
7228 }
7229 if(dvKeyGetRelationship(_Key) != dvRelationshipNull) {
7230 utExit("Attempting to add Key to Relationship twice");
7231 }
7232 #endif
7233 if(dvRelationshipGetLastKey(Relationship) != dvKeyNull) {
7234 dvKeySetNextRelationshipKey(dvRelationshipGetLastKey(Relationship), _Key);
7235 } else {
7236 dvRelationshipSetFirstKey(Relationship, _Key);
7237 }
7238 dvRelationshipSetLastKey(Relationship, _Key);
7239 dvKeySetNextRelationshipKey(_Key, dvKeyNull);
7240 dvKeySetRelationship(_Key, Relationship);
7241 }
7242
7243 /*----------------------------------------------------------------------------------------
7244 Insert the Key to the Relationship after the previous Key.
7245 ----------------------------------------------------------------------------------------*/
dvRelationshipInsertAfterKey(dvRelationship Relationship,dvKey prevKey,dvKey _Key)7246 void dvRelationshipInsertAfterKey(
7247 dvRelationship Relationship,
7248 dvKey prevKey,
7249 dvKey _Key)
7250 {
7251 dvKey nextKey = dvKeyGetNextRelationshipKey(prevKey);
7252
7253 #if defined(DD_DEBUG)
7254 if(Relationship == dvRelationshipNull) {
7255 utExit("Non-existent Relationship");
7256 }
7257 if(_Key == dvKeyNull) {
7258 utExit("Non-existent Key");
7259 }
7260 if(dvKeyGetRelationship(_Key) != dvRelationshipNull) {
7261 utExit("Attempting to add Key to Relationship twice");
7262 }
7263 #endif
7264 dvKeySetNextRelationshipKey(_Key, nextKey);
7265 dvKeySetNextRelationshipKey(prevKey, _Key);
7266 if(dvRelationshipGetLastKey(Relationship) == prevKey) {
7267 dvRelationshipSetLastKey(Relationship, _Key);
7268 }
7269 dvKeySetRelationship(_Key, Relationship);
7270 }
7271
7272 /*----------------------------------------------------------------------------------------
7273 Remove the Key from the Relationship.
7274 ----------------------------------------------------------------------------------------*/
dvRelationshipRemoveKey(dvRelationship Relationship,dvKey _Key)7275 void dvRelationshipRemoveKey(
7276 dvRelationship Relationship,
7277 dvKey _Key)
7278 {
7279 dvKey pKey, nKey;
7280
7281 #if defined(DD_DEBUG)
7282 if(_Key == dvKeyNull) {
7283 utExit("Non-existent Key");
7284 }
7285 if(dvKeyGetRelationship(_Key) != dvRelationshipNull && dvKeyGetRelationship(_Key) != Relationship) {
7286 utExit("Delete Key from non-owning Relationship");
7287 }
7288 #endif
7289 pKey = dvKeyNull;
7290 for(nKey = dvRelationshipGetFirstKey(Relationship); nKey != dvKeyNull && nKey != _Key;
7291 nKey = dvKeyGetNextRelationshipKey(nKey)) {
7292 pKey = nKey;
7293 }
7294 if(pKey != dvKeyNull) {
7295 dvKeySetNextRelationshipKey(pKey, dvKeyGetNextRelationshipKey(_Key));
7296 } else {
7297 dvRelationshipSetFirstKey(Relationship, dvKeyGetNextRelationshipKey(_Key));
7298 }
7299 dvKeySetNextRelationshipKey(_Key, dvKeyNull);
7300 if(dvRelationshipGetLastKey(Relationship) == _Key) {
7301 dvRelationshipSetLastKey(Relationship, pKey);
7302 }
7303 dvKeySetRelationship(_Key, dvRelationshipNull);
7304 }
7305
7306 #if defined(DD_DEBUG)
7307 /*----------------------------------------------------------------------------------------
7308 Write out all the fields of an object.
7309 ----------------------------------------------------------------------------------------*/
dvShowRelationship(dvRelationship Relationship)7310 void dvShowRelationship(
7311 dvRelationship Relationship)
7312 {
7313 utDatabaseShowObject("dv", "Relationship", dvRelationship2Index(Relationship));
7314 }
7315 #endif
7316
7317 /*----------------------------------------------------------------------------------------
7318 Destroy Key including everything in it. Remove from parents.
7319 ----------------------------------------------------------------------------------------*/
dvKeyDestroy(dvKey Key)7320 void dvKeyDestroy(
7321 dvKey Key)
7322 {
7323 dvRelationship owningRelationship = dvKeyGetRelationship(Key);
7324 dvProperty owningProperty = dvKeyGetProperty(Key);
7325
7326 if(dvKeyDestructorCallback != NULL) {
7327 dvKeyDestructorCallback(Key);
7328 }
7329 if(owningRelationship != dvRelationshipNull) {
7330 dvRelationshipRemoveKey(owningRelationship, Key);
7331 #if defined(DD_DEBUG)
7332 } else {
7333 utExit("Key without owning Relationship");
7334 #endif
7335 }
7336 if(owningProperty != dvPropertyNull) {
7337 dvPropertyRemoveKey(owningProperty, Key);
7338 #if defined(DD_DEBUG)
7339 } else {
7340 utExit("Key without owning Property");
7341 #endif
7342 }
7343 dvKeyFree(Key);
7344 }
7345
7346 /*----------------------------------------------------------------------------------------
7347 Default constructor wrapper for the database manager.
7348 ----------------------------------------------------------------------------------------*/
allocKey(void)7349 static uint64 allocKey(void)
7350 {
7351 dvKey Key = dvKeyAlloc();
7352
7353 return dvKey2Index(Key);
7354 }
7355
7356 /*----------------------------------------------------------------------------------------
7357 Destructor wrapper for the database manager.
7358 ----------------------------------------------------------------------------------------*/
destroyKey(uint64 objectIndex)7359 static void destroyKey(
7360 uint64 objectIndex)
7361 {
7362 dvKeyDestroy(dvIndex2Key((uint32)objectIndex));
7363 }
7364
7365 /*----------------------------------------------------------------------------------------
7366 Allocate the field arrays of Key.
7367 ----------------------------------------------------------------------------------------*/
allocKeys(void)7368 static void allocKeys(void)
7369 {
7370 dvSetAllocatedKey(2);
7371 dvSetUsedKey(0);
7372 dvSetFirstFreeKey(dvKeyNull);
7373 dvKeys.PropertySym = utNewA(utSym, (dvAllocatedKey()));
7374 dvKeys.LineNum = utNewA(uint32, (dvAllocatedKey()));
7375 dvKeys.Property = utNewA(dvProperty, (dvAllocatedKey()));
7376 dvKeys.NextPropertyKey = utNewA(dvKey, (dvAllocatedKey()));
7377 dvKeys.Relationship = utNewA(dvRelationship, (dvAllocatedKey()));
7378 dvKeys.NextRelationshipKey = utNewA(dvKey, (dvAllocatedKey()));
7379 }
7380
7381 /*----------------------------------------------------------------------------------------
7382 Realloc the arrays of properties for class Key.
7383 ----------------------------------------------------------------------------------------*/
reallocKeys(uint32 newSize)7384 static void reallocKeys(
7385 uint32 newSize)
7386 {
7387 utResizeArray(dvKeys.PropertySym, (newSize));
7388 utResizeArray(dvKeys.LineNum, (newSize));
7389 utResizeArray(dvKeys.Property, (newSize));
7390 utResizeArray(dvKeys.NextPropertyKey, (newSize));
7391 utResizeArray(dvKeys.Relationship, (newSize));
7392 utResizeArray(dvKeys.NextRelationshipKey, (newSize));
7393 dvSetAllocatedKey(newSize);
7394 }
7395
7396 /*----------------------------------------------------------------------------------------
7397 Allocate more Keys.
7398 ----------------------------------------------------------------------------------------*/
dvKeyAllocMore(void)7399 void dvKeyAllocMore(void)
7400 {
7401 reallocKeys((uint32)(dvAllocatedKey() + (dvAllocatedKey() >> 1)));
7402 }
7403
7404 /*----------------------------------------------------------------------------------------
7405 Copy the properties of Key.
7406 ----------------------------------------------------------------------------------------*/
dvKeyCopyProps(dvKey oldKey,dvKey newKey)7407 void dvKeyCopyProps(
7408 dvKey oldKey,
7409 dvKey newKey)
7410 {
7411 dvKeySetPropertySym(newKey, dvKeyGetPropertySym(oldKey));
7412 dvKeySetLineNum(newKey, dvKeyGetLineNum(oldKey));
7413 }
7414
7415 #if defined(DD_DEBUG)
7416 /*----------------------------------------------------------------------------------------
7417 Write out all the fields of an object.
7418 ----------------------------------------------------------------------------------------*/
dvShowKey(dvKey Key)7419 void dvShowKey(
7420 dvKey Key)
7421 {
7422 utDatabaseShowObject("dv", "Key", dvKey2Index(Key));
7423 }
7424 #endif
7425
7426 /*----------------------------------------------------------------------------------------
7427 Destroy Union including everything in it. Remove from parents.
7428 ----------------------------------------------------------------------------------------*/
dvUnionDestroy(dvUnion Union)7429 void dvUnionDestroy(
7430 dvUnion Union)
7431 {
7432 dvClass owningClass = dvUnionGetClass(Union);
7433
7434 if(dvUnionDestructorCallback != NULL) {
7435 dvUnionDestructorCallback(Union);
7436 }
7437 if(owningClass != dvClassNull) {
7438 dvClassRemoveUnion(owningClass, Union);
7439 #if defined(DD_DEBUG)
7440 } else {
7441 utExit("Union without owning Class");
7442 #endif
7443 }
7444 dvUnionFree(Union);
7445 }
7446
7447 /*----------------------------------------------------------------------------------------
7448 Default constructor wrapper for the database manager.
7449 ----------------------------------------------------------------------------------------*/
allocUnion(void)7450 static uint64 allocUnion(void)
7451 {
7452 dvUnion Union = dvUnionAlloc();
7453
7454 return dvUnion2Index(Union);
7455 }
7456
7457 /*----------------------------------------------------------------------------------------
7458 Destructor wrapper for the database manager.
7459 ----------------------------------------------------------------------------------------*/
destroyUnion(uint64 objectIndex)7460 static void destroyUnion(
7461 uint64 objectIndex)
7462 {
7463 dvUnionDestroy(dvIndex2Union((uint32)objectIndex));
7464 }
7465
7466 /*----------------------------------------------------------------------------------------
7467 Allocate the field arrays of Union.
7468 ----------------------------------------------------------------------------------------*/
allocUnions(void)7469 static void allocUnions(void)
7470 {
7471 dvSetAllocatedUnion(2);
7472 dvSetUsedUnion(0);
7473 dvSetFirstFreeUnion(dvUnionNull);
7474 dvUnions.PropertySym = utNewA(utSym, (dvAllocatedUnion()));
7475 dvUnions.TypeProperty = utNewA(dvProperty, (dvAllocatedUnion()));
7476 dvUnions.Line = utNewA(uint32, (dvAllocatedUnion()));
7477 dvUnions.Number = utNewA(uint16, (dvAllocatedUnion()));
7478 dvUnions.FieldNumber = utNewA(uint32, (dvAllocatedUnion()));
7479 dvUnions.NumCases = utNewA(uint16, (dvAllocatedUnion()));
7480 dvUnions.Class = utNewA(dvClass, (dvAllocatedUnion()));
7481 dvUnions.NextClassUnion = utNewA(dvUnion, (dvAllocatedUnion()));
7482 dvUnions.FirstProperty = utNewA(dvProperty, (dvAllocatedUnion()));
7483 dvUnions.LastProperty = utNewA(dvProperty, (dvAllocatedUnion()));
7484 }
7485
7486 /*----------------------------------------------------------------------------------------
7487 Realloc the arrays of properties for class Union.
7488 ----------------------------------------------------------------------------------------*/
reallocUnions(uint32 newSize)7489 static void reallocUnions(
7490 uint32 newSize)
7491 {
7492 utResizeArray(dvUnions.PropertySym, (newSize));
7493 utResizeArray(dvUnions.TypeProperty, (newSize));
7494 utResizeArray(dvUnions.Line, (newSize));
7495 utResizeArray(dvUnions.Number, (newSize));
7496 utResizeArray(dvUnions.FieldNumber, (newSize));
7497 utResizeArray(dvUnions.NumCases, (newSize));
7498 utResizeArray(dvUnions.Class, (newSize));
7499 utResizeArray(dvUnions.NextClassUnion, (newSize));
7500 utResizeArray(dvUnions.FirstProperty, (newSize));
7501 utResizeArray(dvUnions.LastProperty, (newSize));
7502 dvSetAllocatedUnion(newSize);
7503 }
7504
7505 /*----------------------------------------------------------------------------------------
7506 Allocate more Unions.
7507 ----------------------------------------------------------------------------------------*/
dvUnionAllocMore(void)7508 void dvUnionAllocMore(void)
7509 {
7510 reallocUnions((uint32)(dvAllocatedUnion() + (dvAllocatedUnion() >> 1)));
7511 }
7512
7513 /*----------------------------------------------------------------------------------------
7514 Copy the properties of Union.
7515 ----------------------------------------------------------------------------------------*/
dvUnionCopyProps(dvUnion oldUnion,dvUnion newUnion)7516 void dvUnionCopyProps(
7517 dvUnion oldUnion,
7518 dvUnion newUnion)
7519 {
7520 dvUnionSetPropertySym(newUnion, dvUnionGetPropertySym(oldUnion));
7521 dvUnionSetLine(newUnion, dvUnionGetLine(oldUnion));
7522 dvUnionSetNumber(newUnion, dvUnionGetNumber(oldUnion));
7523 dvUnionSetFieldNumber(newUnion, dvUnionGetFieldNumber(oldUnion));
7524 dvUnionSetNumCases(newUnion, dvUnionGetNumCases(oldUnion));
7525 }
7526
7527 /*----------------------------------------------------------------------------------------
7528 Add the Property to the head of the list on the Union.
7529 ----------------------------------------------------------------------------------------*/
dvUnionInsertProperty(dvUnion Union,dvProperty _Property)7530 void dvUnionInsertProperty(
7531 dvUnion Union,
7532 dvProperty _Property)
7533 {
7534 #if defined(DD_DEBUG)
7535 if(Union == dvUnionNull) {
7536 utExit("Non-existent Union");
7537 }
7538 if(_Property == dvPropertyNull) {
7539 utExit("Non-existent Property");
7540 }
7541 if(dvPropertyGetUnion(_Property) != dvUnionNull) {
7542 utExit("Attempting to add Property to Union twice");
7543 }
7544 #endif
7545 dvPropertySetNextUnionProperty(_Property, dvUnionGetFirstProperty(Union));
7546 dvUnionSetFirstProperty(Union, _Property);
7547 if(dvUnionGetLastProperty(Union) == dvPropertyNull) {
7548 dvUnionSetLastProperty(Union, _Property);
7549 }
7550 dvPropertySetUnion(_Property, Union);
7551 }
7552
7553 /*----------------------------------------------------------------------------------------
7554 Add the Property to the end of the list on the Union.
7555 ----------------------------------------------------------------------------------------*/
dvUnionAppendProperty(dvUnion Union,dvProperty _Property)7556 void dvUnionAppendProperty(
7557 dvUnion Union,
7558 dvProperty _Property)
7559 {
7560 #if defined(DD_DEBUG)
7561 if(Union == dvUnionNull) {
7562 utExit("Non-existent Union");
7563 }
7564 if(_Property == dvPropertyNull) {
7565 utExit("Non-existent Property");
7566 }
7567 if(dvPropertyGetUnion(_Property) != dvUnionNull) {
7568 utExit("Attempting to add Property to Union twice");
7569 }
7570 #endif
7571 if(dvUnionGetLastProperty(Union) != dvPropertyNull) {
7572 dvPropertySetNextUnionProperty(dvUnionGetLastProperty(Union), _Property);
7573 } else {
7574 dvUnionSetFirstProperty(Union, _Property);
7575 }
7576 dvUnionSetLastProperty(Union, _Property);
7577 dvPropertySetNextUnionProperty(_Property, dvPropertyNull);
7578 dvPropertySetUnion(_Property, Union);
7579 }
7580
7581 /*----------------------------------------------------------------------------------------
7582 Insert the Property to the Union after the previous Property.
7583 ----------------------------------------------------------------------------------------*/
dvUnionInsertAfterProperty(dvUnion Union,dvProperty prevProperty,dvProperty _Property)7584 void dvUnionInsertAfterProperty(
7585 dvUnion Union,
7586 dvProperty prevProperty,
7587 dvProperty _Property)
7588 {
7589 dvProperty nextProperty = dvPropertyGetNextUnionProperty(prevProperty);
7590
7591 #if defined(DD_DEBUG)
7592 if(Union == dvUnionNull) {
7593 utExit("Non-existent Union");
7594 }
7595 if(_Property == dvPropertyNull) {
7596 utExit("Non-existent Property");
7597 }
7598 if(dvPropertyGetUnion(_Property) != dvUnionNull) {
7599 utExit("Attempting to add Property to Union twice");
7600 }
7601 #endif
7602 dvPropertySetNextUnionProperty(_Property, nextProperty);
7603 dvPropertySetNextUnionProperty(prevProperty, _Property);
7604 if(dvUnionGetLastProperty(Union) == prevProperty) {
7605 dvUnionSetLastProperty(Union, _Property);
7606 }
7607 dvPropertySetUnion(_Property, Union);
7608 }
7609
7610 /*----------------------------------------------------------------------------------------
7611 Remove the Property from the Union.
7612 ----------------------------------------------------------------------------------------*/
dvUnionRemoveProperty(dvUnion Union,dvProperty _Property)7613 void dvUnionRemoveProperty(
7614 dvUnion Union,
7615 dvProperty _Property)
7616 {
7617 dvProperty pProperty, nProperty;
7618
7619 #if defined(DD_DEBUG)
7620 if(_Property == dvPropertyNull) {
7621 utExit("Non-existent Property");
7622 }
7623 if(dvPropertyGetUnion(_Property) != dvUnionNull && dvPropertyGetUnion(_Property) != Union) {
7624 utExit("Delete Property from non-owning Union");
7625 }
7626 #endif
7627 pProperty = dvPropertyNull;
7628 for(nProperty = dvUnionGetFirstProperty(Union); nProperty != dvPropertyNull && nProperty != _Property;
7629 nProperty = dvPropertyGetNextUnionProperty(nProperty)) {
7630 pProperty = nProperty;
7631 }
7632 if(pProperty != dvPropertyNull) {
7633 dvPropertySetNextUnionProperty(pProperty, dvPropertyGetNextUnionProperty(_Property));
7634 } else {
7635 dvUnionSetFirstProperty(Union, dvPropertyGetNextUnionProperty(_Property));
7636 }
7637 dvPropertySetNextUnionProperty(_Property, dvPropertyNull);
7638 if(dvUnionGetLastProperty(Union) == _Property) {
7639 dvUnionSetLastProperty(Union, pProperty);
7640 }
7641 dvPropertySetUnion(_Property, dvUnionNull);
7642 }
7643
7644 #if defined(DD_DEBUG)
7645 /*----------------------------------------------------------------------------------------
7646 Write out all the fields of an object.
7647 ----------------------------------------------------------------------------------------*/
dvShowUnion(dvUnion Union)7648 void dvShowUnion(
7649 dvUnion Union)
7650 {
7651 utDatabaseShowObject("dv", "Union", dvUnion2Index(Union));
7652 }
7653 #endif
7654
7655 /*----------------------------------------------------------------------------------------
7656 Destroy Case including everything in it. Remove from parents.
7657 ----------------------------------------------------------------------------------------*/
dvCaseDestroy(dvCase Case)7658 void dvCaseDestroy(
7659 dvCase Case)
7660 {
7661 dvEntry owningEntry = dvCaseGetEntry(Case);
7662 dvProperty owningProperty = dvCaseGetProperty(Case);
7663
7664 if(dvCaseDestructorCallback != NULL) {
7665 dvCaseDestructorCallback(Case);
7666 }
7667 if(owningEntry != dvEntryNull) {
7668 dvEntryRemoveCase(owningEntry, Case);
7669 #if defined(DD_DEBUG)
7670 } else {
7671 utExit("Case without owning Entry");
7672 #endif
7673 }
7674 if(owningProperty != dvPropertyNull) {
7675 dvPropertyRemoveCase(owningProperty, Case);
7676 #if defined(DD_DEBUG)
7677 } else {
7678 utExit("Case without owning Property");
7679 #endif
7680 }
7681 dvCaseFree(Case);
7682 }
7683
7684 /*----------------------------------------------------------------------------------------
7685 Default constructor wrapper for the database manager.
7686 ----------------------------------------------------------------------------------------*/
allocCase(void)7687 static uint64 allocCase(void)
7688 {
7689 dvCase Case = dvCaseAlloc();
7690
7691 return dvCase2Index(Case);
7692 }
7693
7694 /*----------------------------------------------------------------------------------------
7695 Destructor wrapper for the database manager.
7696 ----------------------------------------------------------------------------------------*/
destroyCase(uint64 objectIndex)7697 static void destroyCase(
7698 uint64 objectIndex)
7699 {
7700 dvCaseDestroy(dvIndex2Case((uint32)objectIndex));
7701 }
7702
7703 /*----------------------------------------------------------------------------------------
7704 Allocate the field arrays of Case.
7705 ----------------------------------------------------------------------------------------*/
allocCases(void)7706 static void allocCases(void)
7707 {
7708 dvSetAllocatedCase(2);
7709 dvSetUsedCase(0);
7710 dvSetFirstFreeCase(dvCaseNull);
7711 dvCases.EntrySym = utNewA(utSym, (dvAllocatedCase()));
7712 dvCases.Entry = utNewA(dvEntry, (dvAllocatedCase()));
7713 dvCases.NextEntryCase = utNewA(dvCase, (dvAllocatedCase()));
7714 dvCases.Property = utNewA(dvProperty, (dvAllocatedCase()));
7715 dvCases.NextPropertyCase = utNewA(dvCase, (dvAllocatedCase()));
7716 }
7717
7718 /*----------------------------------------------------------------------------------------
7719 Realloc the arrays of properties for class Case.
7720 ----------------------------------------------------------------------------------------*/
reallocCases(uint32 newSize)7721 static void reallocCases(
7722 uint32 newSize)
7723 {
7724 utResizeArray(dvCases.EntrySym, (newSize));
7725 utResizeArray(dvCases.Entry, (newSize));
7726 utResizeArray(dvCases.NextEntryCase, (newSize));
7727 utResizeArray(dvCases.Property, (newSize));
7728 utResizeArray(dvCases.NextPropertyCase, (newSize));
7729 dvSetAllocatedCase(newSize);
7730 }
7731
7732 /*----------------------------------------------------------------------------------------
7733 Allocate more Cases.
7734 ----------------------------------------------------------------------------------------*/
dvCaseAllocMore(void)7735 void dvCaseAllocMore(void)
7736 {
7737 reallocCases((uint32)(dvAllocatedCase() + (dvAllocatedCase() >> 1)));
7738 }
7739
7740 /*----------------------------------------------------------------------------------------
7741 Copy the properties of Case.
7742 ----------------------------------------------------------------------------------------*/
dvCaseCopyProps(dvCase oldCase,dvCase newCase)7743 void dvCaseCopyProps(
7744 dvCase oldCase,
7745 dvCase newCase)
7746 {
7747 dvCaseSetEntrySym(newCase, dvCaseGetEntrySym(oldCase));
7748 }
7749
7750 #if defined(DD_DEBUG)
7751 /*----------------------------------------------------------------------------------------
7752 Write out all the fields of an object.
7753 ----------------------------------------------------------------------------------------*/
dvShowCase(dvCase Case)7754 void dvShowCase(
7755 dvCase Case)
7756 {
7757 utDatabaseShowObject("dv", "Case", dvCase2Index(Case));
7758 }
7759 #endif
7760
7761 /*----------------------------------------------------------------------------------------
7762 Free memory used by the dv database.
7763 ----------------------------------------------------------------------------------------*/
dvDatabaseStop(void)7764 void dvDatabaseStop(void)
7765 {
7766 utFree(dvRoots.FirstModpath);
7767 utFree(dvRoots.LastModpath);
7768 utFree(dvRoots.ModpathTableIndex);
7769 utFree(dvRoots.NumModpathTable);
7770 utFree(dvRoots.ModpathTable);
7771 utFree(dvRoots.NumModpath);
7772 utFree(dvRoots.FirstModule);
7773 utFree(dvRoots.LastModule);
7774 utFree(dvRoots.ModuleTableIndex);
7775 utFree(dvRoots.NumModuleTable);
7776 utFree(dvRoots.ModuleTable);
7777 utFree(dvRoots.NumModule);
7778 utFree(dvModpaths.Sym);
7779 utFree(dvModpaths.Root);
7780 utFree(dvModpaths.NextRootModpath);
7781 utFree(dvModpaths.PrevRootModpath);
7782 utFree(dvModpaths.NextTableRootModpath);
7783 utFree(dvModules.Sym);
7784 utFree(dvModules.PrefixSym);
7785 utFree(dvModules.Persistent);
7786 utFree(dvModules.UndoRedo);
7787 utFree(dvModules.HasSparseData);
7788 utFree(dvModules.NumFields);
7789 utFree(dvModules.NumClasses);
7790 utFree(dvModules.NumEnums);
7791 utFree(dvModules.NextRootModule);
7792 utFree(dvModules.PrevRootModule);
7793 utFree(dvModules.NextTableRootModule);
7794 utFree(dvModules.FirstClass);
7795 utFree(dvModules.LastClass);
7796 utFree(dvModules.ClassTableIndex);
7797 utFree(dvModules.NumClassTable);
7798 utFree(dvModules.ClassTable);
7799 utFree(dvModules.NumClass);
7800 utFree(dvModules.FirstEnum);
7801 utFree(dvModules.LastEnum);
7802 utFree(dvModules.EnumTableIndex);
7803 utFree(dvModules.NumEnumTable);
7804 utFree(dvModules.EnumTable);
7805 utFree(dvModules.NumEnum);
7806 utFree(dvModules.FirstTypedef);
7807 utFree(dvModules.LastTypedef);
7808 utFree(dvModules.TypedefTableIndex);
7809 utFree(dvModules.NumTypedefTable);
7810 utFree(dvModules.TypedefTable);
7811 utFree(dvModules.NumTypedef);
7812 utFree(dvModules.FirstSchema);
7813 utFree(dvModules.LastSchema);
7814 utFree(dvModules.SchemaTableIndex);
7815 utFree(dvModules.NumSchemaTable);
7816 utFree(dvModules.SchemaTable);
7817 utFree(dvModules.NumSchema);
7818 utFree(dvModules.FirstImportLink);
7819 utFree(dvModules.LastImportLink);
7820 utFree(dvModules.FirstExportLink);
7821 utFree(dvModules.LastExportLink);
7822 utFree(dvLinks.ImportModule);
7823 utFree(dvLinks.NextModuleImportLink);
7824 utFree(dvLinks.ExportModule);
7825 utFree(dvLinks.NextModuleExportLink);
7826 utFree(dvSchemas.Sym);
7827 utFree(dvSchemas.Module);
7828 utFree(dvSchemas.NextModuleSchema);
7829 utFree(dvSchemas.PrevModuleSchema);
7830 utFree(dvSchemas.NextTableModuleSchema);
7831 utFree(dvSchemas.FirstRelationship);
7832 utFree(dvSchemas.LastRelationship);
7833 utFree(dvEnums.Sym);
7834 utFree(dvEnums.PrefixSym);
7835 utFree(dvEnums.NumEntries);
7836 utFree(dvEnums.Module);
7837 utFree(dvEnums.NextModuleEnum);
7838 utFree(dvEnums.PrevModuleEnum);
7839 utFree(dvEnums.NextTableModuleEnum);
7840 utFree(dvEnums.FirstEntry);
7841 utFree(dvEnums.LastEntry);
7842 utFree(dvEnums.EntryTableIndex);
7843 utFree(dvEnums.NumEntryTable);
7844 utFree(dvEnums.EntryTable);
7845 utFree(dvEnums.NumEntry);
7846 utFree(dvEntrys.Sym);
7847 utFree(dvEntrys.Value);
7848 utFree(dvEntrys.Enum);
7849 utFree(dvEntrys.NextEnumEntry);
7850 utFree(dvEntrys.PrevEnumEntry);
7851 utFree(dvEntrys.NextTableEnumEntry);
7852 utFree(dvEntrys.FirstCase);
7853 utFree(dvEntrys.LastCase);
7854 utFree(dvTypedefs.Sym);
7855 utFree(dvTypedefs.InitializerIndex);
7856 utFree(dvTypedefs.NumInitializer);
7857 utFree(dvTypedefs.Initializer);
7858 utFree(dvTypedefs.Module);
7859 utFree(dvTypedefs.NextModuleTypedef);
7860 utFree(dvTypedefs.PrevModuleTypedef);
7861 utFree(dvTypedefs.NextTableModuleTypedef);
7862 utFree(dvClasss.Sym);
7863 utFree(dvClasss.MemoryStyle);
7864 utFree(dvClasss.ReferenceSize);
7865 utFree(dvClasss.GenerateArrayClass);
7866 utFree(dvClasss.GenerateAttributes);
7867 utFree(dvClasss.Sparse);
7868 utFree(dvClasss.NumFields);
7869 utFree(dvClasss.Number);
7870 utFree(dvClasss.Module);
7871 utFree(dvClasss.NextModuleClass);
7872 utFree(dvClasss.PrevModuleClass);
7873 utFree(dvClasss.NextTableModuleClass);
7874 utFree(dvClasss.FirstProperty);
7875 utFree(dvClasss.LastProperty);
7876 utFree(dvClasss.PropertyTableIndex);
7877 utFree(dvClasss.NumPropertyTable);
7878 utFree(dvClasss.PropertyTable);
7879 utFree(dvClasss.NumProperty);
7880 utFree(dvClasss.FreeListProperty);
7881 utFree(dvClasss.FirstSparsegroup);
7882 utFree(dvClasss.LastSparsegroup);
7883 utFree(dvClasss.SparsegroupTableIndex);
7884 utFree(dvClasss.NumSparsegroupTable);
7885 utFree(dvClasss.SparsegroupTable);
7886 utFree(dvClasss.NumSparsegroup);
7887 utFree(dvClasss.BaseClass);
7888 utFree(dvClasss.FirstDerivedClass);
7889 utFree(dvClasss.NextClassDerivedClass);
7890 utFree(dvClasss.LastDerivedClass);
7891 utFree(dvClasss.FirstChildRelationship);
7892 utFree(dvClasss.LastChildRelationship);
7893 utFree(dvClasss.FirstParentRelationship);
7894 utFree(dvClasss.LastParentRelationship);
7895 utFree(dvClasss.FirstUnion);
7896 utFree(dvClasss.LastUnion);
7897 utFree(dvPropertys.Sym);
7898 utFree(dvPropertys.Type);
7899 utFree(dvPropertys.Array);
7900 utFree(dvPropertys.Cascade);
7901 utFree(dvPropertys.Sparse);
7902 utFree(dvPropertys.Expanded);
7903 utFree(dvPropertys.FieldNumber);
7904 utFree(dvPropertys.FirstElementProp);
7905 utFree(dvPropertys.NumElementsProp);
7906 utFree(dvPropertys.Hidden);
7907 utFree(dvPropertys.InitializerIndex);
7908 utFree(dvPropertys.NumInitializer);
7909 utFree(dvPropertys.Initializer);
7910 utFree(dvPropertys.FixedSize);
7911 utFree(dvPropertys.IndexIndex);
7912 utFree(dvPropertys.NumIndex);
7913 utFree(dvPropertys.Index);
7914 utFree(dvPropertys.Line);
7915 utFree(dvPropertys.Class);
7916 utFree(dvPropertys.NextClassProperty);
7917 utFree(dvPropertys.PrevClassProperty);
7918 utFree(dvPropertys.NextTableClassProperty);
7919 utFree(dvPropertys.FirstCase);
7920 utFree(dvPropertys.LastCase);
7921 utFree(dvPropertys.FirstKey);
7922 utFree(dvPropertys.LastKey);
7923 utFree(dvPropertys.Sparsegroup);
7924 utFree(dvPropertys.NextSparsegroupProperty);
7925 utFree(dvPropertys.Relationship);
7926 utFree(dvPropertys.NextRelationshipProperty);
7927 utFree(dvPropertys.Union);
7928 utFree(dvPropertys.NextUnionProperty);
7929 utFree(dvPropertys.union1);
7930 utFree(dvSparsegroups.Sym);
7931 utFree(dvSparsegroups.Class);
7932 utFree(dvSparsegroups.NextClassSparsegroup);
7933 utFree(dvSparsegroups.PrevClassSparsegroup);
7934 utFree(dvSparsegroups.NextTableClassSparsegroup);
7935 utFree(dvSparsegroups.FirstProperty);
7936 utFree(dvSparsegroups.LastProperty);
7937 utFree(dvSparsegroups.Relationship);
7938 utFree(dvRelationships.Type);
7939 utFree(dvRelationships.ParentLabelSym);
7940 utFree(dvRelationships.ChildLabelSym);
7941 utFree(dvRelationships.Mandatory);
7942 utFree(dvRelationships.Cascade);
7943 utFree(dvRelationships.AccessChild);
7944 utFree(dvRelationships.AccessParent);
7945 utFree(dvRelationships.SharedParent);
7946 utFree(dvRelationships.Sparse);
7947 utFree(dvRelationships.Expanded);
7948 utFree(dvRelationships.Schema);
7949 utFree(dvRelationships.NextSchemaRelationship);
7950 utFree(dvRelationships.ParentClass);
7951 utFree(dvRelationships.NextClassChildRelationship);
7952 utFree(dvRelationships.ChildClass);
7953 utFree(dvRelationships.NextClassParentRelationship);
7954 utFree(dvRelationships.FirstProperty);
7955 utFree(dvRelationships.LastProperty);
7956 utFree(dvRelationships.FirstKey);
7957 utFree(dvRelationships.LastKey);
7958 utFree(dvRelationships.ParentSparsegroup);
7959 utFree(dvRelationships.ChildSparsegroup);
7960 utFree(dvKeys.PropertySym);
7961 utFree(dvKeys.LineNum);
7962 utFree(dvKeys.Property);
7963 utFree(dvKeys.NextPropertyKey);
7964 utFree(dvKeys.Relationship);
7965 utFree(dvKeys.NextRelationshipKey);
7966 utFree(dvUnions.PropertySym);
7967 utFree(dvUnions.TypeProperty);
7968 utFree(dvUnions.Line);
7969 utFree(dvUnions.Number);
7970 utFree(dvUnions.FieldNumber);
7971 utFree(dvUnions.NumCases);
7972 utFree(dvUnions.Class);
7973 utFree(dvUnions.NextClassUnion);
7974 utFree(dvUnions.FirstProperty);
7975 utFree(dvUnions.LastProperty);
7976 utFree(dvCases.EntrySym);
7977 utFree(dvCases.Entry);
7978 utFree(dvCases.NextEntryCase);
7979 utFree(dvCases.Property);
7980 utFree(dvCases.NextPropertyCase);
7981 utUnregisterModule(dvModuleID);
7982 }
7983
7984 /*----------------------------------------------------------------------------------------
7985 Allocate memory used by the dv database.
7986 ----------------------------------------------------------------------------------------*/
dvDatabaseStart(void)7987 void dvDatabaseStart(void)
7988 {
7989 if(!utInitialized()) {
7990 utStart();
7991 }
7992 dvRootData.hash = 0x85ebc91d;
7993 dvModuleID = utRegisterModule("dv", false, dvHash(), 15, 215, 3, sizeof(struct dvRootType_),
7994 &dvRootData, dvDatabaseStart, dvDatabaseStop);
7995 utRegisterEnum("RelationshipType", 8);
7996 utRegisterEntry("LINKED_LIST", 0);
7997 utRegisterEntry("DOUBLY_LINKED", 1);
7998 utRegisterEntry("TAIL_LINKED", 2);
7999 utRegisterEntry("POINTER", 3);
8000 utRegisterEntry("ARRAY", 4);
8001 utRegisterEntry("HEAP", 5);
8002 utRegisterEntry("HASHED", 6);
8003 utRegisterEntry("UNBOUND", 7);
8004 utRegisterEnum("PropertyType", 12);
8005 utRegisterEntry("INT", 0);
8006 utRegisterEntry("UINT", 1);
8007 utRegisterEntry("FLOAT", 2);
8008 utRegisterEntry("DOUBLE", 3);
8009 utRegisterEntry("BIT", 4);
8010 utRegisterEntry("BOOL", 5);
8011 utRegisterEntry("CHAR", 6);
8012 utRegisterEntry("ENUM", 7);
8013 utRegisterEntry("TYPEDEF", 8);
8014 utRegisterEntry("POINTER", 9);
8015 utRegisterEntry("SYM", 10);
8016 utRegisterEntry("UNBOUND", 11);
8017 utRegisterEnum("MemoryStyle", 2);
8018 utRegisterEntry("CREATE_ONLY", 0);
8019 utRegisterEntry("FREE_LIST", 1);
8020 utRegisterClass("Root", 12, &dvRootData.usedRoot, &dvRootData.allocatedRoot,
8021 NULL, 65535, 4, allocRoot, NULL);
8022 utRegisterField("FirstModpath", &dvRoots.FirstModpath, sizeof(dvModpath), UT_POINTER, "Modpath");
8023 utRegisterField("LastModpath", &dvRoots.LastModpath, sizeof(dvModpath), UT_POINTER, "Modpath");
8024 utRegisterField("ModpathTableIndex", &dvRoots.ModpathTableIndex, sizeof(uint32), UT_UINT, NULL);
8025 utSetFieldHidden();
8026 utRegisterField("NumModpathTable", &dvRoots.NumModpathTable, sizeof(uint32), UT_UINT, NULL);
8027 utSetFieldHidden();
8028 utRegisterField("ModpathTable", &dvRoots.ModpathTable, sizeof(dvModpath), UT_POINTER, "Modpath");
8029 utRegisterArray(&dvRootData.usedRootModpathTable, &dvRootData.allocatedRootModpathTable,
8030 getRootModpathTables, allocRootModpathTables, dvCompactRootModpathTables);
8031 utRegisterField("NumModpath", &dvRoots.NumModpath, sizeof(uint32), UT_UINT, NULL);
8032 utRegisterField("FirstModule", &dvRoots.FirstModule, sizeof(dvModule), UT_POINTER, "Module");
8033 utRegisterField("LastModule", &dvRoots.LastModule, sizeof(dvModule), UT_POINTER, "Module");
8034 utRegisterField("ModuleTableIndex", &dvRoots.ModuleTableIndex, sizeof(uint32), UT_UINT, NULL);
8035 utSetFieldHidden();
8036 utRegisterField("NumModuleTable", &dvRoots.NumModuleTable, sizeof(uint32), UT_UINT, NULL);
8037 utSetFieldHidden();
8038 utRegisterField("ModuleTable", &dvRoots.ModuleTable, sizeof(dvModule), UT_POINTER, "Module");
8039 utRegisterArray(&dvRootData.usedRootModuleTable, &dvRootData.allocatedRootModuleTable,
8040 getRootModuleTables, allocRootModuleTables, dvCompactRootModuleTables);
8041 utRegisterField("NumModule", &dvRoots.NumModule, sizeof(uint32), UT_UINT, NULL);
8042 utRegisterClass("Modpath", 5, &dvRootData.usedModpath, &dvRootData.allocatedModpath,
8043 NULL, 65535, 4, allocModpath, NULL);
8044 utRegisterField("Sym", &dvModpaths.Sym, sizeof(utSym), UT_SYM, NULL);
8045 utRegisterField("Root", &dvModpaths.Root, sizeof(dvRoot), UT_POINTER, "Root");
8046 utRegisterField("NextRootModpath", &dvModpaths.NextRootModpath, sizeof(dvModpath), UT_POINTER, "Modpath");
8047 utRegisterField("PrevRootModpath", &dvModpaths.PrevRootModpath, sizeof(dvModpath), UT_POINTER, "Modpath");
8048 utRegisterField("NextTableRootModpath", &dvModpaths.NextTableRootModpath, sizeof(dvModpath), UT_POINTER, "Modpath");
8049 utRegisterClass("Module", 39, &dvRootData.usedModule, &dvRootData.allocatedModule,
8050 NULL, 65535, 4, allocModule, NULL);
8051 utRegisterField("Sym", &dvModules.Sym, sizeof(utSym), UT_SYM, NULL);
8052 utRegisterField("PrefixSym", &dvModules.PrefixSym, sizeof(utSym), UT_SYM, NULL);
8053 utRegisterField("Persistent", &dvModules.Persistent, sizeof(uint8), UT_BIT, NULL);
8054 utRegisterField("UndoRedo", &dvModules.UndoRedo, sizeof(uint8), UT_BIT, NULL);
8055 utRegisterField("HasSparseData", &dvModules.HasSparseData, sizeof(uint8), UT_BIT, NULL);
8056 utRegisterField("NumFields", &dvModules.NumFields, sizeof(uint16), UT_UINT, NULL);
8057 utRegisterField("NumClasses", &dvModules.NumClasses, sizeof(uint32), UT_UINT, NULL);
8058 utRegisterField("NumEnums", &dvModules.NumEnums, sizeof(uint32), UT_UINT, NULL);
8059 utRegisterField("NextRootModule", &dvModules.NextRootModule, sizeof(dvModule), UT_POINTER, "Module");
8060 utRegisterField("PrevRootModule", &dvModules.PrevRootModule, sizeof(dvModule), UT_POINTER, "Module");
8061 utRegisterField("NextTableRootModule", &dvModules.NextTableRootModule, sizeof(dvModule), UT_POINTER, "Module");
8062 utRegisterField("FirstClass", &dvModules.FirstClass, sizeof(dvClass), UT_POINTER, "Class");
8063 utRegisterField("LastClass", &dvModules.LastClass, sizeof(dvClass), UT_POINTER, "Class");
8064 utRegisterField("ClassTableIndex", &dvModules.ClassTableIndex, sizeof(uint32), UT_UINT, NULL);
8065 utSetFieldHidden();
8066 utRegisterField("NumClassTable", &dvModules.NumClassTable, sizeof(uint32), UT_UINT, NULL);
8067 utSetFieldHidden();
8068 utRegisterField("ClassTable", &dvModules.ClassTable, sizeof(dvClass), UT_POINTER, "Class");
8069 utRegisterArray(&dvRootData.usedModuleClassTable, &dvRootData.allocatedModuleClassTable,
8070 getModuleClassTables, allocModuleClassTables, dvCompactModuleClassTables);
8071 utRegisterField("NumClass", &dvModules.NumClass, sizeof(uint32), UT_UINT, NULL);
8072 utRegisterField("FirstEnum", &dvModules.FirstEnum, sizeof(dvEnum), UT_POINTER, "Enum");
8073 utRegisterField("LastEnum", &dvModules.LastEnum, sizeof(dvEnum), UT_POINTER, "Enum");
8074 utRegisterField("EnumTableIndex", &dvModules.EnumTableIndex, sizeof(uint32), UT_UINT, NULL);
8075 utSetFieldHidden();
8076 utRegisterField("NumEnumTable", &dvModules.NumEnumTable, sizeof(uint32), UT_UINT, NULL);
8077 utSetFieldHidden();
8078 utRegisterField("EnumTable", &dvModules.EnumTable, sizeof(dvEnum), UT_POINTER, "Enum");
8079 utRegisterArray(&dvRootData.usedModuleEnumTable, &dvRootData.allocatedModuleEnumTable,
8080 getModuleEnumTables, allocModuleEnumTables, dvCompactModuleEnumTables);
8081 utRegisterField("NumEnum", &dvModules.NumEnum, sizeof(uint32), UT_UINT, NULL);
8082 utRegisterField("FirstTypedef", &dvModules.FirstTypedef, sizeof(dvTypedef), UT_POINTER, "Typedef");
8083 utRegisterField("LastTypedef", &dvModules.LastTypedef, sizeof(dvTypedef), UT_POINTER, "Typedef");
8084 utRegisterField("TypedefTableIndex", &dvModules.TypedefTableIndex, sizeof(uint32), UT_UINT, NULL);
8085 utSetFieldHidden();
8086 utRegisterField("NumTypedefTable", &dvModules.NumTypedefTable, sizeof(uint32), UT_UINT, NULL);
8087 utSetFieldHidden();
8088 utRegisterField("TypedefTable", &dvModules.TypedefTable, sizeof(dvTypedef), UT_POINTER, "Typedef");
8089 utRegisterArray(&dvRootData.usedModuleTypedefTable, &dvRootData.allocatedModuleTypedefTable,
8090 getModuleTypedefTables, allocModuleTypedefTables, dvCompactModuleTypedefTables);
8091 utRegisterField("NumTypedef", &dvModules.NumTypedef, sizeof(uint32), UT_UINT, NULL);
8092 utRegisterField("FirstSchema", &dvModules.FirstSchema, sizeof(dvSchema), UT_POINTER, "Schema");
8093 utRegisterField("LastSchema", &dvModules.LastSchema, sizeof(dvSchema), UT_POINTER, "Schema");
8094 utRegisterField("SchemaTableIndex", &dvModules.SchemaTableIndex, sizeof(uint32), UT_UINT, NULL);
8095 utSetFieldHidden();
8096 utRegisterField("NumSchemaTable", &dvModules.NumSchemaTable, sizeof(uint32), UT_UINT, NULL);
8097 utSetFieldHidden();
8098 utRegisterField("SchemaTable", &dvModules.SchemaTable, sizeof(dvSchema), UT_POINTER, "Schema");
8099 utRegisterArray(&dvRootData.usedModuleSchemaTable, &dvRootData.allocatedModuleSchemaTable,
8100 getModuleSchemaTables, allocModuleSchemaTables, dvCompactModuleSchemaTables);
8101 utRegisterField("NumSchema", &dvModules.NumSchema, sizeof(uint32), UT_UINT, NULL);
8102 utRegisterField("FirstImportLink", &dvModules.FirstImportLink, sizeof(dvLink), UT_POINTER, "Link");
8103 utRegisterField("LastImportLink", &dvModules.LastImportLink, sizeof(dvLink), UT_POINTER, "Link");
8104 utRegisterField("FirstExportLink", &dvModules.FirstExportLink, sizeof(dvLink), UT_POINTER, "Link");
8105 utRegisterField("LastExportLink", &dvModules.LastExportLink, sizeof(dvLink), UT_POINTER, "Link");
8106 utRegisterClass("Link", 4, &dvRootData.usedLink, &dvRootData.allocatedLink,
8107 NULL, 65535, 4, allocLink, NULL);
8108 utRegisterField("ImportModule", &dvLinks.ImportModule, sizeof(dvModule), UT_POINTER, "Module");
8109 utRegisterField("NextModuleImportLink", &dvLinks.NextModuleImportLink, sizeof(dvLink), UT_POINTER, "Link");
8110 utRegisterField("ExportModule", &dvLinks.ExportModule, sizeof(dvModule), UT_POINTER, "Module");
8111 utRegisterField("NextModuleExportLink", &dvLinks.NextModuleExportLink, sizeof(dvLink), UT_POINTER, "Link");
8112 utRegisterClass("Schema", 7, &dvRootData.usedSchema, &dvRootData.allocatedSchema,
8113 NULL, 65535, 4, allocSchema, NULL);
8114 utRegisterField("Sym", &dvSchemas.Sym, sizeof(utSym), UT_SYM, NULL);
8115 utRegisterField("Module", &dvSchemas.Module, sizeof(dvModule), UT_POINTER, "Module");
8116 utRegisterField("NextModuleSchema", &dvSchemas.NextModuleSchema, sizeof(dvSchema), UT_POINTER, "Schema");
8117 utRegisterField("PrevModuleSchema", &dvSchemas.PrevModuleSchema, sizeof(dvSchema), UT_POINTER, "Schema");
8118 utRegisterField("NextTableModuleSchema", &dvSchemas.NextTableModuleSchema, sizeof(dvSchema), UT_POINTER, "Schema");
8119 utRegisterField("FirstRelationship", &dvSchemas.FirstRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8120 utRegisterField("LastRelationship", &dvSchemas.LastRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8121 utRegisterClass("Enum", 13, &dvRootData.usedEnum, &dvRootData.allocatedEnum,
8122 NULL, 65535, 4, allocEnum, NULL);
8123 utRegisterField("Sym", &dvEnums.Sym, sizeof(utSym), UT_SYM, NULL);
8124 utRegisterField("PrefixSym", &dvEnums.PrefixSym, sizeof(utSym), UT_SYM, NULL);
8125 utRegisterField("NumEntries", &dvEnums.NumEntries, sizeof(uint16), UT_UINT, NULL);
8126 utRegisterField("Module", &dvEnums.Module, sizeof(dvModule), UT_POINTER, "Module");
8127 utRegisterField("NextModuleEnum", &dvEnums.NextModuleEnum, sizeof(dvEnum), UT_POINTER, "Enum");
8128 utRegisterField("PrevModuleEnum", &dvEnums.PrevModuleEnum, sizeof(dvEnum), UT_POINTER, "Enum");
8129 utRegisterField("NextTableModuleEnum", &dvEnums.NextTableModuleEnum, sizeof(dvEnum), UT_POINTER, "Enum");
8130 utRegisterField("FirstEntry", &dvEnums.FirstEntry, sizeof(dvEntry), UT_POINTER, "Entry");
8131 utRegisterField("LastEntry", &dvEnums.LastEntry, sizeof(dvEntry), UT_POINTER, "Entry");
8132 utRegisterField("EntryTableIndex", &dvEnums.EntryTableIndex, sizeof(uint32), UT_UINT, NULL);
8133 utSetFieldHidden();
8134 utRegisterField("NumEntryTable", &dvEnums.NumEntryTable, sizeof(uint32), UT_UINT, NULL);
8135 utSetFieldHidden();
8136 utRegisterField("EntryTable", &dvEnums.EntryTable, sizeof(dvEntry), UT_POINTER, "Entry");
8137 utRegisterArray(&dvRootData.usedEnumEntryTable, &dvRootData.allocatedEnumEntryTable,
8138 getEnumEntryTables, allocEnumEntryTables, dvCompactEnumEntryTables);
8139 utRegisterField("NumEntry", &dvEnums.NumEntry, sizeof(uint32), UT_UINT, NULL);
8140 utRegisterClass("Entry", 8, &dvRootData.usedEntry, &dvRootData.allocatedEntry,
8141 NULL, 65535, 4, allocEntry, NULL);
8142 utRegisterField("Sym", &dvEntrys.Sym, sizeof(utSym), UT_SYM, NULL);
8143 utRegisterField("Value", &dvEntrys.Value, sizeof(uint32), UT_UINT, NULL);
8144 utRegisterField("Enum", &dvEntrys.Enum, sizeof(dvEnum), UT_POINTER, "Enum");
8145 utRegisterField("NextEnumEntry", &dvEntrys.NextEnumEntry, sizeof(dvEntry), UT_POINTER, "Entry");
8146 utRegisterField("PrevEnumEntry", &dvEntrys.PrevEnumEntry, sizeof(dvEntry), UT_POINTER, "Entry");
8147 utRegisterField("NextTableEnumEntry", &dvEntrys.NextTableEnumEntry, sizeof(dvEntry), UT_POINTER, "Entry");
8148 utRegisterField("FirstCase", &dvEntrys.FirstCase, sizeof(dvCase), UT_POINTER, "Case");
8149 utRegisterField("LastCase", &dvEntrys.LastCase, sizeof(dvCase), UT_POINTER, "Case");
8150 utRegisterClass("Typedef", 8, &dvRootData.usedTypedef, &dvRootData.allocatedTypedef,
8151 NULL, 65535, 4, allocTypedef, NULL);
8152 utRegisterField("Sym", &dvTypedefs.Sym, sizeof(utSym), UT_SYM, NULL);
8153 utRegisterField("InitializerIndex", &dvTypedefs.InitializerIndex, sizeof(uint32), UT_UINT, NULL);
8154 utSetFieldHidden();
8155 utRegisterField("NumInitializer", &dvTypedefs.NumInitializer, sizeof(uint32), UT_UINT, NULL);
8156 utSetFieldHidden();
8157 utRegisterField("Initializer", &dvTypedefs.Initializer, sizeof(char), UT_CHAR, NULL);
8158 utRegisterArray(&dvRootData.usedTypedefInitializer, &dvRootData.allocatedTypedefInitializer,
8159 getTypedefInitializers, allocTypedefInitializers, dvCompactTypedefInitializers);
8160 utRegisterField("Module", &dvTypedefs.Module, sizeof(dvModule), UT_POINTER, "Module");
8161 utRegisterField("NextModuleTypedef", &dvTypedefs.NextModuleTypedef, sizeof(dvTypedef), UT_POINTER, "Typedef");
8162 utRegisterField("PrevModuleTypedef", &dvTypedefs.PrevModuleTypedef, sizeof(dvTypedef), UT_POINTER, "Typedef");
8163 utRegisterField("NextTableModuleTypedef", &dvTypedefs.NextTableModuleTypedef, sizeof(dvTypedef), UT_POINTER, "Typedef");
8164 utRegisterClass("Class", 35, &dvRootData.usedClass, &dvRootData.allocatedClass,
8165 NULL, 65535, 4, allocClass, NULL);
8166 utRegisterField("Sym", &dvClasss.Sym, sizeof(utSym), UT_SYM, NULL);
8167 utRegisterField("MemoryStyle", &dvClasss.MemoryStyle, sizeof(dvMemoryStyle), UT_ENUM, "MemoryStyle");
8168 utRegisterField("ReferenceSize", &dvClasss.ReferenceSize, sizeof(uint8), UT_UINT, NULL);
8169 utRegisterField("GenerateArrayClass", &dvClasss.GenerateArrayClass, sizeof(uint8), UT_BIT, NULL);
8170 utRegisterField("GenerateAttributes", &dvClasss.GenerateAttributes, sizeof(uint8), UT_BIT, NULL);
8171 utRegisterField("Sparse", &dvClasss.Sparse, sizeof(uint8), UT_BIT, NULL);
8172 utRegisterField("NumFields", &dvClasss.NumFields, sizeof(uint16), UT_UINT, NULL);
8173 utRegisterField("Number", &dvClasss.Number, sizeof(uint16), UT_UINT, NULL);
8174 utRegisterField("Module", &dvClasss.Module, sizeof(dvModule), UT_POINTER, "Module");
8175 utRegisterField("NextModuleClass", &dvClasss.NextModuleClass, sizeof(dvClass), UT_POINTER, "Class");
8176 utRegisterField("PrevModuleClass", &dvClasss.PrevModuleClass, sizeof(dvClass), UT_POINTER, "Class");
8177 utRegisterField("NextTableModuleClass", &dvClasss.NextTableModuleClass, sizeof(dvClass), UT_POINTER, "Class");
8178 utRegisterField("FirstProperty", &dvClasss.FirstProperty, sizeof(dvProperty), UT_POINTER, "Property");
8179 utRegisterField("LastProperty", &dvClasss.LastProperty, sizeof(dvProperty), UT_POINTER, "Property");
8180 utRegisterField("PropertyTableIndex", &dvClasss.PropertyTableIndex, sizeof(uint32), UT_UINT, NULL);
8181 utSetFieldHidden();
8182 utRegisterField("NumPropertyTable", &dvClasss.NumPropertyTable, sizeof(uint32), UT_UINT, NULL);
8183 utSetFieldHidden();
8184 utRegisterField("PropertyTable", &dvClasss.PropertyTable, sizeof(dvProperty), UT_POINTER, "Property");
8185 utRegisterArray(&dvRootData.usedClassPropertyTable, &dvRootData.allocatedClassPropertyTable,
8186 getClassPropertyTables, allocClassPropertyTables, dvCompactClassPropertyTables);
8187 utRegisterField("NumProperty", &dvClasss.NumProperty, sizeof(uint32), UT_UINT, NULL);
8188 utRegisterField("FreeListProperty", &dvClasss.FreeListProperty, sizeof(dvProperty), UT_POINTER, "Property");
8189 utRegisterField("FirstSparsegroup", &dvClasss.FirstSparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8190 utRegisterField("LastSparsegroup", &dvClasss.LastSparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8191 utRegisterField("SparsegroupTableIndex", &dvClasss.SparsegroupTableIndex, sizeof(uint32), UT_UINT, NULL);
8192 utSetFieldHidden();
8193 utRegisterField("NumSparsegroupTable", &dvClasss.NumSparsegroupTable, sizeof(uint32), UT_UINT, NULL);
8194 utSetFieldHidden();
8195 utRegisterField("SparsegroupTable", &dvClasss.SparsegroupTable, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8196 utRegisterArray(&dvRootData.usedClassSparsegroupTable, &dvRootData.allocatedClassSparsegroupTable,
8197 getClassSparsegroupTables, allocClassSparsegroupTables, dvCompactClassSparsegroupTables);
8198 utRegisterField("NumSparsegroup", &dvClasss.NumSparsegroup, sizeof(uint32), UT_UINT, NULL);
8199 utRegisterField("BaseClass", &dvClasss.BaseClass, sizeof(dvClass), UT_POINTER, "Class");
8200 utRegisterField("FirstDerivedClass", &dvClasss.FirstDerivedClass, sizeof(dvClass), UT_POINTER, "Class");
8201 utRegisterField("NextClassDerivedClass", &dvClasss.NextClassDerivedClass, sizeof(dvClass), UT_POINTER, "Class");
8202 utRegisterField("LastDerivedClass", &dvClasss.LastDerivedClass, sizeof(dvClass), UT_POINTER, "Class");
8203 utRegisterField("FirstChildRelationship", &dvClasss.FirstChildRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8204 utRegisterField("LastChildRelationship", &dvClasss.LastChildRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8205 utRegisterField("FirstParentRelationship", &dvClasss.FirstParentRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8206 utRegisterField("LastParentRelationship", &dvClasss.LastParentRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8207 utRegisterField("FirstUnion", &dvClasss.FirstUnion, sizeof(dvUnion), UT_POINTER, "Union");
8208 utRegisterField("LastUnion", &dvClasss.LastUnion, sizeof(dvUnion), UT_POINTER, "Union");
8209 utRegisterClass("Property", 33, &dvRootData.usedProperty, &dvRootData.allocatedProperty,
8210 NULL, 65535, 4, allocProperty, NULL);
8211 utRegisterField("Sym", &dvPropertys.Sym, sizeof(utSym), UT_SYM, NULL);
8212 utRegisterField("Type", &dvPropertys.Type, sizeof(dvPropertyType), UT_ENUM, "PropertyType");
8213 utRegisterField("Array", &dvPropertys.Array, sizeof(uint8), UT_BIT, NULL);
8214 utRegisterField("Cascade", &dvPropertys.Cascade, sizeof(uint8), UT_BIT, NULL);
8215 utRegisterField("Sparse", &dvPropertys.Sparse, sizeof(uint8), UT_BIT, NULL);
8216 utRegisterField("Expanded", &dvPropertys.Expanded, sizeof(uint8), UT_BIT, NULL);
8217 utRegisterField("FieldNumber", &dvPropertys.FieldNumber, sizeof(uint32), UT_UINT, NULL);
8218 utRegisterField("FirstElementProp", &dvPropertys.FirstElementProp, sizeof(dvProperty), UT_POINTER, "Property");
8219 utRegisterField("NumElementsProp", &dvPropertys.NumElementsProp, sizeof(dvProperty), UT_POINTER, "Property");
8220 utRegisterField("Hidden", &dvPropertys.Hidden, sizeof(uint8), UT_BIT, NULL);
8221 utRegisterField("InitializerIndex", &dvPropertys.InitializerIndex, sizeof(uint32), UT_UINT, NULL);
8222 utSetFieldHidden();
8223 utRegisterField("NumInitializer", &dvPropertys.NumInitializer, sizeof(uint32), UT_UINT, NULL);
8224 utSetFieldHidden();
8225 utRegisterField("Initializer", &dvPropertys.Initializer, sizeof(char), UT_CHAR, NULL);
8226 utRegisterArray(&dvRootData.usedPropertyInitializer, &dvRootData.allocatedPropertyInitializer,
8227 getPropertyInitializers, allocPropertyInitializers, dvCompactPropertyInitializers);
8228 utRegisterField("FixedSize", &dvPropertys.FixedSize, sizeof(uint8), UT_BIT, NULL);
8229 utRegisterField("IndexIndex", &dvPropertys.IndexIndex, sizeof(uint32), UT_UINT, NULL);
8230 utSetFieldHidden();
8231 utRegisterField("NumIndex", &dvPropertys.NumIndex, sizeof(uint32), UT_UINT, NULL);
8232 utSetFieldHidden();
8233 utRegisterField("Index", &dvPropertys.Index, sizeof(char), UT_CHAR, NULL);
8234 utRegisterArray(&dvRootData.usedPropertyIndex, &dvRootData.allocatedPropertyIndex,
8235 getPropertyIndexs, allocPropertyIndexs, dvCompactPropertyIndexs);
8236 utRegisterField("Line", &dvPropertys.Line, sizeof(uint32), UT_UINT, NULL);
8237 utRegisterField("Class", &dvPropertys.Class, sizeof(dvClass), UT_POINTER, "Class");
8238 utRegisterField("NextClassProperty", &dvPropertys.NextClassProperty, sizeof(dvProperty), UT_POINTER, "Property");
8239 utRegisterField("PrevClassProperty", &dvPropertys.PrevClassProperty, sizeof(dvProperty), UT_POINTER, "Property");
8240 utRegisterField("NextTableClassProperty", &dvPropertys.NextTableClassProperty, sizeof(dvProperty), UT_POINTER, "Property");
8241 utRegisterField("FirstCase", &dvPropertys.FirstCase, sizeof(dvCase), UT_POINTER, "Case");
8242 utRegisterField("LastCase", &dvPropertys.LastCase, sizeof(dvCase), UT_POINTER, "Case");
8243 utRegisterField("FirstKey", &dvPropertys.FirstKey, sizeof(dvKey), UT_POINTER, "Key");
8244 utRegisterField("LastKey", &dvPropertys.LastKey, sizeof(dvKey), UT_POINTER, "Key");
8245 utRegisterField("Sparsegroup", &dvPropertys.Sparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8246 utRegisterField("NextSparsegroupProperty", &dvPropertys.NextSparsegroupProperty, sizeof(dvProperty), UT_POINTER, "Property");
8247 utRegisterField("Relationship", &dvPropertys.Relationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8248 utRegisterField("NextRelationshipProperty", &dvPropertys.NextRelationshipProperty, sizeof(dvProperty), UT_POINTER, "Property");
8249 utRegisterField("Union", &dvPropertys.Union, sizeof(dvUnion), UT_POINTER, "Union");
8250 utRegisterField("NextUnionProperty", &dvPropertys.NextUnionProperty, sizeof(dvProperty), UT_POINTER, "Property");
8251 utRegisterField("union1", &dvPropertys.union1, sizeof(dvPropertyUnion1), UT_UNION, "Type");
8252 utRegisterUnion("Type", 6);
8253 utRegisterUnionCase(7, UT_POINTER, sizeof(dvEnum));
8254 utRegisterUnionCase(8, UT_POINTER, sizeof(dvTypedef));
8255 utRegisterUnionCase(9, UT_POINTER, sizeof(dvClass));
8256 utRegisterUnionCase(10, UT_SYM, sizeof(utSym));
8257 utRegisterUnionCase(0, UT_UINT, sizeof(uint8));
8258 utRegisterUnionCase(1, UT_UINT, sizeof(uint8));
8259 utRegisterClass("Sparsegroup", 8, &dvRootData.usedSparsegroup, &dvRootData.allocatedSparsegroup,
8260 &dvRootData.firstFreeSparsegroup, 165, 4, allocSparsegroup, destroySparsegroup);
8261 utRegisterField("Sym", &dvSparsegroups.Sym, sizeof(utSym), UT_SYM, NULL);
8262 utRegisterField("Class", &dvSparsegroups.Class, sizeof(dvClass), UT_POINTER, "Class");
8263 utRegisterField("NextClassSparsegroup", &dvSparsegroups.NextClassSparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8264 utRegisterField("PrevClassSparsegroup", &dvSparsegroups.PrevClassSparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8265 utRegisterField("NextTableClassSparsegroup", &dvSparsegroups.NextTableClassSparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8266 utRegisterField("FirstProperty", &dvSparsegroups.FirstProperty, sizeof(dvProperty), UT_POINTER, "Property");
8267 utRegisterField("LastProperty", &dvSparsegroups.LastProperty, sizeof(dvProperty), UT_POINTER, "Property");
8268 utRegisterField("Relationship", &dvSparsegroups.Relationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8269 utRegisterClass("Relationship", 22, &dvRootData.usedRelationship, &dvRootData.allocatedRelationship,
8270 NULL, 65535, 4, allocRelationship, NULL);
8271 utRegisterField("Type", &dvRelationships.Type, sizeof(dvRelationshipType), UT_ENUM, "RelationshipType");
8272 utRegisterField("ParentLabelSym", &dvRelationships.ParentLabelSym, sizeof(utSym), UT_SYM, NULL);
8273 utRegisterField("ChildLabelSym", &dvRelationships.ChildLabelSym, sizeof(utSym), UT_SYM, NULL);
8274 utRegisterField("Mandatory", &dvRelationships.Mandatory, sizeof(uint8), UT_BIT, NULL);
8275 utRegisterField("Cascade", &dvRelationships.Cascade, sizeof(uint8), UT_BIT, NULL);
8276 utRegisterField("AccessChild", &dvRelationships.AccessChild, sizeof(uint8), UT_BIT, NULL);
8277 utRegisterField("AccessParent", &dvRelationships.AccessParent, sizeof(uint8), UT_BIT, NULL);
8278 utRegisterField("SharedParent", &dvRelationships.SharedParent, sizeof(uint8), UT_BIT, NULL);
8279 utRegisterField("Sparse", &dvRelationships.Sparse, sizeof(uint8), UT_BIT, NULL);
8280 utRegisterField("Expanded", &dvRelationships.Expanded, sizeof(uint8), UT_BIT, NULL);
8281 utRegisterField("Schema", &dvRelationships.Schema, sizeof(dvSchema), UT_POINTER, "Schema");
8282 utRegisterField("NextSchemaRelationship", &dvRelationships.NextSchemaRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8283 utRegisterField("ParentClass", &dvRelationships.ParentClass, sizeof(dvClass), UT_POINTER, "Class");
8284 utRegisterField("NextClassChildRelationship", &dvRelationships.NextClassChildRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8285 utRegisterField("ChildClass", &dvRelationships.ChildClass, sizeof(dvClass), UT_POINTER, "Class");
8286 utRegisterField("NextClassParentRelationship", &dvRelationships.NextClassParentRelationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8287 utRegisterField("FirstProperty", &dvRelationships.FirstProperty, sizeof(dvProperty), UT_POINTER, "Property");
8288 utRegisterField("LastProperty", &dvRelationships.LastProperty, sizeof(dvProperty), UT_POINTER, "Property");
8289 utRegisterField("FirstKey", &dvRelationships.FirstKey, sizeof(dvKey), UT_POINTER, "Key");
8290 utRegisterField("LastKey", &dvRelationships.LastKey, sizeof(dvKey), UT_POINTER, "Key");
8291 utRegisterField("ParentSparsegroup", &dvRelationships.ParentSparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8292 utRegisterField("ChildSparsegroup", &dvRelationships.ChildSparsegroup, sizeof(dvSparsegroup), UT_POINTER, "Sparsegroup");
8293 utRegisterClass("Key", 6, &dvRootData.usedKey, &dvRootData.allocatedKey,
8294 &dvRootData.firstFreeKey, 196, 4, allocKey, destroyKey);
8295 utRegisterField("PropertySym", &dvKeys.PropertySym, sizeof(utSym), UT_SYM, NULL);
8296 utRegisterField("LineNum", &dvKeys.LineNum, sizeof(uint32), UT_UINT, NULL);
8297 utRegisterField("Property", &dvKeys.Property, sizeof(dvProperty), UT_POINTER, "Property");
8298 utRegisterField("NextPropertyKey", &dvKeys.NextPropertyKey, sizeof(dvKey), UT_POINTER, "Key");
8299 utRegisterField("Relationship", &dvKeys.Relationship, sizeof(dvRelationship), UT_POINTER, "Relationship");
8300 utRegisterField("NextRelationshipKey", &dvKeys.NextRelationshipKey, sizeof(dvKey), UT_POINTER, "Key");
8301 utRegisterClass("Union", 10, &dvRootData.usedUnion, &dvRootData.allocatedUnion,
8302 &dvRootData.firstFreeUnion, 201, 4, allocUnion, destroyUnion);
8303 utRegisterField("PropertySym", &dvUnions.PropertySym, sizeof(utSym), UT_SYM, NULL);
8304 utRegisterField("TypeProperty", &dvUnions.TypeProperty, sizeof(dvProperty), UT_POINTER, "Property");
8305 utRegisterField("Line", &dvUnions.Line, sizeof(uint32), UT_UINT, NULL);
8306 utRegisterField("Number", &dvUnions.Number, sizeof(uint16), UT_UINT, NULL);
8307 utRegisterField("FieldNumber", &dvUnions.FieldNumber, sizeof(uint32), UT_UINT, NULL);
8308 utRegisterField("NumCases", &dvUnions.NumCases, sizeof(uint16), UT_UINT, NULL);
8309 utRegisterField("Class", &dvUnions.Class, sizeof(dvClass), UT_POINTER, "Class");
8310 utRegisterField("NextClassUnion", &dvUnions.NextClassUnion, sizeof(dvUnion), UT_POINTER, "Union");
8311 utRegisterField("FirstProperty", &dvUnions.FirstProperty, sizeof(dvProperty), UT_POINTER, "Property");
8312 utRegisterField("LastProperty", &dvUnions.LastProperty, sizeof(dvProperty), UT_POINTER, "Property");
8313 utRegisterClass("Case", 5, &dvRootData.usedCase, &dvRootData.allocatedCase,
8314 &dvRootData.firstFreeCase, 211, 4, allocCase, destroyCase);
8315 utRegisterField("EntrySym", &dvCases.EntrySym, sizeof(utSym), UT_SYM, NULL);
8316 utRegisterField("Entry", &dvCases.Entry, sizeof(dvEntry), UT_POINTER, "Entry");
8317 utRegisterField("NextEntryCase", &dvCases.NextEntryCase, sizeof(dvCase), UT_POINTER, "Case");
8318 utRegisterField("Property", &dvCases.Property, sizeof(dvProperty), UT_POINTER, "Property");
8319 utRegisterField("NextPropertyCase", &dvCases.NextPropertyCase, sizeof(dvCase), UT_POINTER, "Case");
8320 allocRoots();
8321 allocModpaths();
8322 allocModules();
8323 allocLinks();
8324 allocSchemas();
8325 allocEnums();
8326 allocEntrys();
8327 allocTypedefs();
8328 allocClasss();
8329 allocPropertys();
8330 allocSparsegroups();
8331 allocRelationships();
8332 allocKeys();
8333 allocUnions();
8334 allocCases();
8335 }
8336
8337 #if defined(DD_DEBUG)
8338 #undef dvRootGetFirstModpath
dvRootGetFirstModpath(dvRoot _Root)8339 dvModpath dvRootGetFirstModpath(
8340 dvRoot _Root)
8341 {
8342 return dvRoots.FirstModpath[dvRoot2Index(_Root)];
8343 }
8344
8345 #undef dvRootSetFirstModpath
dvRootSetFirstModpath(dvRoot _Root,dvModpath value)8346 void dvRootSetFirstModpath(
8347 dvRoot _Root,
8348 dvModpath value)
8349 {
8350 dvRoots.FirstModpath[dvRoot2Index(_Root)] = value;
8351 }
8352
8353 #undef dvRootGetLastModpath
dvRootGetLastModpath(dvRoot _Root)8354 dvModpath dvRootGetLastModpath(
8355 dvRoot _Root)
8356 {
8357 return dvRoots.LastModpath[dvRoot2Index(_Root)];
8358 }
8359
8360 #undef dvRootSetLastModpath
dvRootSetLastModpath(dvRoot _Root,dvModpath value)8361 void dvRootSetLastModpath(
8362 dvRoot _Root,
8363 dvModpath value)
8364 {
8365 dvRoots.LastModpath[dvRoot2Index(_Root)] = value;
8366 }
8367
8368 #undef dvRootGetModpathTableIndex
dvRootGetModpathTableIndex(dvRoot _Root)8369 uint32 dvRootGetModpathTableIndex(
8370 dvRoot _Root)
8371 {
8372 return dvRoots.ModpathTableIndex[dvRoot2Index(_Root)];
8373 }
8374
8375 #undef dvRootSetModpathTableIndex
dvRootSetModpathTableIndex(dvRoot _Root,uint32 value)8376 void dvRootSetModpathTableIndex(
8377 dvRoot _Root,
8378 uint32 value)
8379 {
8380 dvRoots.ModpathTableIndex[dvRoot2Index(_Root)] = value;
8381 }
8382
8383 #undef dvRootGetNumModpathTable
dvRootGetNumModpathTable(dvRoot _Root)8384 uint32 dvRootGetNumModpathTable(
8385 dvRoot _Root)
8386 {
8387 return dvRoots.NumModpathTable[dvRoot2Index(_Root)];
8388 }
8389
8390 #undef dvRootSetNumModpathTable
dvRootSetNumModpathTable(dvRoot _Root,uint32 value)8391 void dvRootSetNumModpathTable(
8392 dvRoot _Root,
8393 uint32 value)
8394 {
8395 dvRoots.NumModpathTable[dvRoot2Index(_Root)] = value;
8396 }
8397
8398 #undef dvRootGetiModpathTable
dvRootGetiModpathTable(dvRoot _Root,uint32 x)8399 dvModpath dvRootGetiModpathTable(
8400 dvRoot _Root,
8401 uint32 x)
8402 {
8403 return (dvRoots.ModpathTable)[dvRootGetModpathTableIndex(_Root) + x];
8404 }
8405
8406 #undef dvRootSetiModpathTable
dvRootSetiModpathTable(dvRoot Root,uint32 x,dvModpath value)8407 void dvRootSetiModpathTable(
8408 dvRoot Root,
8409 uint32 x,
8410 dvModpath value)
8411 {
8412 dvRoots.ModpathTable[dvRootGetModpathTableIndex(Root) + x] = value;
8413 }
8414
8415 #undef dvRootGetModpathTable
dvRootGetModpathTable(dvRoot Root)8416 dvModpath *dvRootGetModpathTable(
8417 dvRoot Root)
8418 {
8419 return dvRoots.ModpathTable + dvRootGetModpathTableIndex(Root);
8420 }
8421
8422 #undef dvRootGetNumModpath
dvRootGetNumModpath(dvRoot _Root)8423 uint32 dvRootGetNumModpath(
8424 dvRoot _Root)
8425 {
8426 return dvRoots.NumModpath[dvRoot2Index(_Root)];
8427 }
8428
8429 #undef dvRootSetNumModpath
dvRootSetNumModpath(dvRoot _Root,uint32 value)8430 void dvRootSetNumModpath(
8431 dvRoot _Root,
8432 uint32 value)
8433 {
8434 dvRoots.NumModpath[dvRoot2Index(_Root)] = value;
8435 }
8436
8437 #undef dvRootGetFirstModule
dvRootGetFirstModule(dvRoot _Root)8438 dvModule dvRootGetFirstModule(
8439 dvRoot _Root)
8440 {
8441 return dvRoots.FirstModule[dvRoot2Index(_Root)];
8442 }
8443
8444 #undef dvRootSetFirstModule
dvRootSetFirstModule(dvRoot _Root,dvModule value)8445 void dvRootSetFirstModule(
8446 dvRoot _Root,
8447 dvModule value)
8448 {
8449 dvRoots.FirstModule[dvRoot2Index(_Root)] = value;
8450 }
8451
8452 #undef dvRootGetLastModule
dvRootGetLastModule(dvRoot _Root)8453 dvModule dvRootGetLastModule(
8454 dvRoot _Root)
8455 {
8456 return dvRoots.LastModule[dvRoot2Index(_Root)];
8457 }
8458
8459 #undef dvRootSetLastModule
dvRootSetLastModule(dvRoot _Root,dvModule value)8460 void dvRootSetLastModule(
8461 dvRoot _Root,
8462 dvModule value)
8463 {
8464 dvRoots.LastModule[dvRoot2Index(_Root)] = value;
8465 }
8466
8467 #undef dvRootGetModuleTableIndex
dvRootGetModuleTableIndex(dvRoot _Root)8468 uint32 dvRootGetModuleTableIndex(
8469 dvRoot _Root)
8470 {
8471 return dvRoots.ModuleTableIndex[dvRoot2Index(_Root)];
8472 }
8473
8474 #undef dvRootSetModuleTableIndex
dvRootSetModuleTableIndex(dvRoot _Root,uint32 value)8475 void dvRootSetModuleTableIndex(
8476 dvRoot _Root,
8477 uint32 value)
8478 {
8479 dvRoots.ModuleTableIndex[dvRoot2Index(_Root)] = value;
8480 }
8481
8482 #undef dvRootGetNumModuleTable
dvRootGetNumModuleTable(dvRoot _Root)8483 uint32 dvRootGetNumModuleTable(
8484 dvRoot _Root)
8485 {
8486 return dvRoots.NumModuleTable[dvRoot2Index(_Root)];
8487 }
8488
8489 #undef dvRootSetNumModuleTable
dvRootSetNumModuleTable(dvRoot _Root,uint32 value)8490 void dvRootSetNumModuleTable(
8491 dvRoot _Root,
8492 uint32 value)
8493 {
8494 dvRoots.NumModuleTable[dvRoot2Index(_Root)] = value;
8495 }
8496
8497 #undef dvRootGetiModuleTable
dvRootGetiModuleTable(dvRoot _Root,uint32 x)8498 dvModule dvRootGetiModuleTable(
8499 dvRoot _Root,
8500 uint32 x)
8501 {
8502 return (dvRoots.ModuleTable)[dvRootGetModuleTableIndex(_Root) + x];
8503 }
8504
8505 #undef dvRootSetiModuleTable
dvRootSetiModuleTable(dvRoot Root,uint32 x,dvModule value)8506 void dvRootSetiModuleTable(
8507 dvRoot Root,
8508 uint32 x,
8509 dvModule value)
8510 {
8511 dvRoots.ModuleTable[dvRootGetModuleTableIndex(Root) + x] = value;
8512 }
8513
8514 #undef dvRootGetModuleTable
dvRootGetModuleTable(dvRoot Root)8515 dvModule *dvRootGetModuleTable(
8516 dvRoot Root)
8517 {
8518 return dvRoots.ModuleTable + dvRootGetModuleTableIndex(Root);
8519 }
8520
8521 #undef dvRootGetNumModule
dvRootGetNumModule(dvRoot _Root)8522 uint32 dvRootGetNumModule(
8523 dvRoot _Root)
8524 {
8525 return dvRoots.NumModule[dvRoot2Index(_Root)];
8526 }
8527
8528 #undef dvRootSetNumModule
dvRootSetNumModule(dvRoot _Root,uint32 value)8529 void dvRootSetNumModule(
8530 dvRoot _Root,
8531 uint32 value)
8532 {
8533 dvRoots.NumModule[dvRoot2Index(_Root)] = value;
8534 }
8535
8536 #undef dvModpathGetName
dvModpathGetName(dvModpath Modpath)8537 char *dvModpathGetName(
8538 dvModpath Modpath)
8539 {
8540 return utSymGetName(dvModpathGetSym(Modpath));
8541 }
8542
8543 #undef dvModuleGetName
dvModuleGetName(dvModule Module)8544 char *dvModuleGetName(
8545 dvModule Module)
8546 {
8547 return utSymGetName(dvModuleGetSym(Module));
8548 }
8549
8550 #undef dvModpathGetSym
dvModpathGetSym(dvModpath _Modpath)8551 utSym dvModpathGetSym(
8552 dvModpath _Modpath)
8553 {
8554 return dvModpaths.Sym[dvModpath2Index(_Modpath)];
8555 }
8556
8557 #undef dvModpathSetSym
dvModpathSetSym(dvModpath _Modpath,utSym value)8558 void dvModpathSetSym(
8559 dvModpath _Modpath,
8560 utSym value)
8561 {
8562 dvModpaths.Sym[dvModpath2Index(_Modpath)] = value;
8563 }
8564
8565 #undef dvModpathGetRoot
dvModpathGetRoot(dvModpath _Modpath)8566 dvRoot dvModpathGetRoot(
8567 dvModpath _Modpath)
8568 {
8569 return dvModpaths.Root[dvModpath2Index(_Modpath)];
8570 }
8571
8572 #undef dvModpathSetRoot
dvModpathSetRoot(dvModpath _Modpath,dvRoot value)8573 void dvModpathSetRoot(
8574 dvModpath _Modpath,
8575 dvRoot value)
8576 {
8577 dvModpaths.Root[dvModpath2Index(_Modpath)] = value;
8578 }
8579
8580 #undef dvModpathGetNextRootModpath
dvModpathGetNextRootModpath(dvModpath _Modpath)8581 dvModpath dvModpathGetNextRootModpath(
8582 dvModpath _Modpath)
8583 {
8584 return dvModpaths.NextRootModpath[dvModpath2Index(_Modpath)];
8585 }
8586
8587 #undef dvModpathSetNextRootModpath
dvModpathSetNextRootModpath(dvModpath _Modpath,dvModpath value)8588 void dvModpathSetNextRootModpath(
8589 dvModpath _Modpath,
8590 dvModpath value)
8591 {
8592 dvModpaths.NextRootModpath[dvModpath2Index(_Modpath)] = value;
8593 }
8594
8595 #undef dvModpathGetPrevRootModpath
dvModpathGetPrevRootModpath(dvModpath _Modpath)8596 dvModpath dvModpathGetPrevRootModpath(
8597 dvModpath _Modpath)
8598 {
8599 return dvModpaths.PrevRootModpath[dvModpath2Index(_Modpath)];
8600 }
8601
8602 #undef dvModpathSetPrevRootModpath
dvModpathSetPrevRootModpath(dvModpath _Modpath,dvModpath value)8603 void dvModpathSetPrevRootModpath(
8604 dvModpath _Modpath,
8605 dvModpath value)
8606 {
8607 dvModpaths.PrevRootModpath[dvModpath2Index(_Modpath)] = value;
8608 }
8609
8610 #undef dvModpathGetNextTableRootModpath
dvModpathGetNextTableRootModpath(dvModpath _Modpath)8611 dvModpath dvModpathGetNextTableRootModpath(
8612 dvModpath _Modpath)
8613 {
8614 return dvModpaths.NextTableRootModpath[dvModpath2Index(_Modpath)];
8615 }
8616
8617 #undef dvModpathSetNextTableRootModpath
dvModpathSetNextTableRootModpath(dvModpath _Modpath,dvModpath value)8618 void dvModpathSetNextTableRootModpath(
8619 dvModpath _Modpath,
8620 dvModpath value)
8621 {
8622 dvModpaths.NextTableRootModpath[dvModpath2Index(_Modpath)] = value;
8623 }
8624
8625 #undef dvModuleGetSym
dvModuleGetSym(dvModule _Module)8626 utSym dvModuleGetSym(
8627 dvModule _Module)
8628 {
8629 return dvModules.Sym[dvModule2Index(_Module)];
8630 }
8631
8632 #undef dvModuleSetSym
dvModuleSetSym(dvModule _Module,utSym value)8633 void dvModuleSetSym(
8634 dvModule _Module,
8635 utSym value)
8636 {
8637 dvModules.Sym[dvModule2Index(_Module)] = value;
8638 }
8639
8640 #undef dvModuleGetPrefixSym
dvModuleGetPrefixSym(dvModule _Module)8641 utSym dvModuleGetPrefixSym(
8642 dvModule _Module)
8643 {
8644 return dvModules.PrefixSym[dvModule2Index(_Module)];
8645 }
8646
8647 #undef dvModuleSetPrefixSym
dvModuleSetPrefixSym(dvModule _Module,utSym value)8648 void dvModuleSetPrefixSym(
8649 dvModule _Module,
8650 utSym value)
8651 {
8652 dvModules.PrefixSym[dvModule2Index(_Module)] = value;
8653 }
8654
8655 #undef dvModulePersistent
dvModulePersistent(dvModule _Module)8656 bool dvModulePersistent(
8657 dvModule _Module)
8658 {
8659 return (dvModules.Persistent[dvModule2Index(_Module) >> 3] >> (dvModule2Index(_Module) & 7)) & 1;
8660 }
8661
8662 #undef dvModuleSetPersistent
dvModuleSetPersistent(dvModule _Module,bool value)8663 void dvModuleSetPersistent(
8664 dvModule _Module,
8665 bool value)
8666 {
8667 uint32 xModule = dvModule2Index(_Module);
8668
8669 dvModules.Persistent[xModule >> 3] = (dvModules.Persistent[xModule >> 3] & ~(1 << (xModule & 7))) |
8670 ((value != 0) << (xModule & 7));
8671 }
8672
8673 #undef dvModuleUndoRedo
dvModuleUndoRedo(dvModule _Module)8674 bool dvModuleUndoRedo(
8675 dvModule _Module)
8676 {
8677 return (dvModules.UndoRedo[dvModule2Index(_Module) >> 3] >> (dvModule2Index(_Module) & 7)) & 1;
8678 }
8679
8680 #undef dvModuleSetUndoRedo
dvModuleSetUndoRedo(dvModule _Module,bool value)8681 void dvModuleSetUndoRedo(
8682 dvModule _Module,
8683 bool value)
8684 {
8685 uint32 xModule = dvModule2Index(_Module);
8686
8687 dvModules.UndoRedo[xModule >> 3] = (dvModules.UndoRedo[xModule >> 3] & ~(1 << (xModule & 7))) |
8688 ((value != 0) << (xModule & 7));
8689 }
8690
8691 #undef dvModuleHasSparseData
dvModuleHasSparseData(dvModule _Module)8692 bool dvModuleHasSparseData(
8693 dvModule _Module)
8694 {
8695 return (dvModules.HasSparseData[dvModule2Index(_Module) >> 3] >> (dvModule2Index(_Module) & 7)) & 1;
8696 }
8697
8698 #undef dvModuleSetHasSparseData
dvModuleSetHasSparseData(dvModule _Module,bool value)8699 void dvModuleSetHasSparseData(
8700 dvModule _Module,
8701 bool value)
8702 {
8703 uint32 xModule = dvModule2Index(_Module);
8704
8705 dvModules.HasSparseData[xModule >> 3] = (dvModules.HasSparseData[xModule >> 3] & ~(1 << (xModule & 7))) |
8706 ((value != 0) << (xModule & 7));
8707 }
8708
8709 #undef dvModuleGetNumFields
dvModuleGetNumFields(dvModule _Module)8710 uint16 dvModuleGetNumFields(
8711 dvModule _Module)
8712 {
8713 return dvModules.NumFields[dvModule2Index(_Module)];
8714 }
8715
8716 #undef dvModuleSetNumFields
dvModuleSetNumFields(dvModule _Module,uint16 value)8717 void dvModuleSetNumFields(
8718 dvModule _Module,
8719 uint16 value)
8720 {
8721 dvModules.NumFields[dvModule2Index(_Module)] = value;
8722 }
8723
8724 #undef dvModuleGetNumClasses
dvModuleGetNumClasses(dvModule _Module)8725 uint32 dvModuleGetNumClasses(
8726 dvModule _Module)
8727 {
8728 return dvModules.NumClasses[dvModule2Index(_Module)];
8729 }
8730
8731 #undef dvModuleSetNumClasses
dvModuleSetNumClasses(dvModule _Module,uint32 value)8732 void dvModuleSetNumClasses(
8733 dvModule _Module,
8734 uint32 value)
8735 {
8736 dvModules.NumClasses[dvModule2Index(_Module)] = value;
8737 }
8738
8739 #undef dvModuleGetNumEnums
dvModuleGetNumEnums(dvModule _Module)8740 uint32 dvModuleGetNumEnums(
8741 dvModule _Module)
8742 {
8743 return dvModules.NumEnums[dvModule2Index(_Module)];
8744 }
8745
8746 #undef dvModuleSetNumEnums
dvModuleSetNumEnums(dvModule _Module,uint32 value)8747 void dvModuleSetNumEnums(
8748 dvModule _Module,
8749 uint32 value)
8750 {
8751 dvModules.NumEnums[dvModule2Index(_Module)] = value;
8752 }
8753
8754 #undef dvModuleGetNextRootModule
dvModuleGetNextRootModule(dvModule _Module)8755 dvModule dvModuleGetNextRootModule(
8756 dvModule _Module)
8757 {
8758 return dvModules.NextRootModule[dvModule2Index(_Module)];
8759 }
8760
8761 #undef dvModuleSetNextRootModule
dvModuleSetNextRootModule(dvModule _Module,dvModule value)8762 void dvModuleSetNextRootModule(
8763 dvModule _Module,
8764 dvModule value)
8765 {
8766 dvModules.NextRootModule[dvModule2Index(_Module)] = value;
8767 }
8768
8769 #undef dvModuleGetPrevRootModule
dvModuleGetPrevRootModule(dvModule _Module)8770 dvModule dvModuleGetPrevRootModule(
8771 dvModule _Module)
8772 {
8773 return dvModules.PrevRootModule[dvModule2Index(_Module)];
8774 }
8775
8776 #undef dvModuleSetPrevRootModule
dvModuleSetPrevRootModule(dvModule _Module,dvModule value)8777 void dvModuleSetPrevRootModule(
8778 dvModule _Module,
8779 dvModule value)
8780 {
8781 dvModules.PrevRootModule[dvModule2Index(_Module)] = value;
8782 }
8783
8784 #undef dvModuleGetNextTableRootModule
dvModuleGetNextTableRootModule(dvModule _Module)8785 dvModule dvModuleGetNextTableRootModule(
8786 dvModule _Module)
8787 {
8788 return dvModules.NextTableRootModule[dvModule2Index(_Module)];
8789 }
8790
8791 #undef dvModuleSetNextTableRootModule
dvModuleSetNextTableRootModule(dvModule _Module,dvModule value)8792 void dvModuleSetNextTableRootModule(
8793 dvModule _Module,
8794 dvModule value)
8795 {
8796 dvModules.NextTableRootModule[dvModule2Index(_Module)] = value;
8797 }
8798
8799 #undef dvModuleGetFirstClass
dvModuleGetFirstClass(dvModule _Module)8800 dvClass dvModuleGetFirstClass(
8801 dvModule _Module)
8802 {
8803 return dvModules.FirstClass[dvModule2Index(_Module)];
8804 }
8805
8806 #undef dvModuleSetFirstClass
dvModuleSetFirstClass(dvModule _Module,dvClass value)8807 void dvModuleSetFirstClass(
8808 dvModule _Module,
8809 dvClass value)
8810 {
8811 dvModules.FirstClass[dvModule2Index(_Module)] = value;
8812 }
8813
8814 #undef dvModuleGetLastClass
dvModuleGetLastClass(dvModule _Module)8815 dvClass dvModuleGetLastClass(
8816 dvModule _Module)
8817 {
8818 return dvModules.LastClass[dvModule2Index(_Module)];
8819 }
8820
8821 #undef dvModuleSetLastClass
dvModuleSetLastClass(dvModule _Module,dvClass value)8822 void dvModuleSetLastClass(
8823 dvModule _Module,
8824 dvClass value)
8825 {
8826 dvModules.LastClass[dvModule2Index(_Module)] = value;
8827 }
8828
8829 #undef dvModuleGetClassTableIndex
dvModuleGetClassTableIndex(dvModule _Module)8830 uint32 dvModuleGetClassTableIndex(
8831 dvModule _Module)
8832 {
8833 return dvModules.ClassTableIndex[dvModule2Index(_Module)];
8834 }
8835
8836 #undef dvModuleSetClassTableIndex
dvModuleSetClassTableIndex(dvModule _Module,uint32 value)8837 void dvModuleSetClassTableIndex(
8838 dvModule _Module,
8839 uint32 value)
8840 {
8841 dvModules.ClassTableIndex[dvModule2Index(_Module)] = value;
8842 }
8843
8844 #undef dvModuleGetNumClassTable
dvModuleGetNumClassTable(dvModule _Module)8845 uint32 dvModuleGetNumClassTable(
8846 dvModule _Module)
8847 {
8848 return dvModules.NumClassTable[dvModule2Index(_Module)];
8849 }
8850
8851 #undef dvModuleSetNumClassTable
dvModuleSetNumClassTable(dvModule _Module,uint32 value)8852 void dvModuleSetNumClassTable(
8853 dvModule _Module,
8854 uint32 value)
8855 {
8856 dvModules.NumClassTable[dvModule2Index(_Module)] = value;
8857 }
8858
8859 #undef dvModuleGetiClassTable
dvModuleGetiClassTable(dvModule _Module,uint32 x)8860 dvClass dvModuleGetiClassTable(
8861 dvModule _Module,
8862 uint32 x)
8863 {
8864 return (dvModules.ClassTable)[dvModuleGetClassTableIndex(_Module) + x];
8865 }
8866
8867 #undef dvModuleSetiClassTable
dvModuleSetiClassTable(dvModule Module,uint32 x,dvClass value)8868 void dvModuleSetiClassTable(
8869 dvModule Module,
8870 uint32 x,
8871 dvClass value)
8872 {
8873 dvModules.ClassTable[dvModuleGetClassTableIndex(Module) + x] = value;
8874 }
8875
8876 #undef dvModuleGetClassTable
dvModuleGetClassTable(dvModule Module)8877 dvClass *dvModuleGetClassTable(
8878 dvModule Module)
8879 {
8880 return dvModules.ClassTable + dvModuleGetClassTableIndex(Module);
8881 }
8882
8883 #undef dvModuleGetNumClass
dvModuleGetNumClass(dvModule _Module)8884 uint32 dvModuleGetNumClass(
8885 dvModule _Module)
8886 {
8887 return dvModules.NumClass[dvModule2Index(_Module)];
8888 }
8889
8890 #undef dvModuleSetNumClass
dvModuleSetNumClass(dvModule _Module,uint32 value)8891 void dvModuleSetNumClass(
8892 dvModule _Module,
8893 uint32 value)
8894 {
8895 dvModules.NumClass[dvModule2Index(_Module)] = value;
8896 }
8897
8898 #undef dvModuleGetFirstEnum
dvModuleGetFirstEnum(dvModule _Module)8899 dvEnum dvModuleGetFirstEnum(
8900 dvModule _Module)
8901 {
8902 return dvModules.FirstEnum[dvModule2Index(_Module)];
8903 }
8904
8905 #undef dvModuleSetFirstEnum
dvModuleSetFirstEnum(dvModule _Module,dvEnum value)8906 void dvModuleSetFirstEnum(
8907 dvModule _Module,
8908 dvEnum value)
8909 {
8910 dvModules.FirstEnum[dvModule2Index(_Module)] = value;
8911 }
8912
8913 #undef dvModuleGetLastEnum
dvModuleGetLastEnum(dvModule _Module)8914 dvEnum dvModuleGetLastEnum(
8915 dvModule _Module)
8916 {
8917 return dvModules.LastEnum[dvModule2Index(_Module)];
8918 }
8919
8920 #undef dvModuleSetLastEnum
dvModuleSetLastEnum(dvModule _Module,dvEnum value)8921 void dvModuleSetLastEnum(
8922 dvModule _Module,
8923 dvEnum value)
8924 {
8925 dvModules.LastEnum[dvModule2Index(_Module)] = value;
8926 }
8927
8928 #undef dvModuleGetEnumTableIndex
dvModuleGetEnumTableIndex(dvModule _Module)8929 uint32 dvModuleGetEnumTableIndex(
8930 dvModule _Module)
8931 {
8932 return dvModules.EnumTableIndex[dvModule2Index(_Module)];
8933 }
8934
8935 #undef dvModuleSetEnumTableIndex
dvModuleSetEnumTableIndex(dvModule _Module,uint32 value)8936 void dvModuleSetEnumTableIndex(
8937 dvModule _Module,
8938 uint32 value)
8939 {
8940 dvModules.EnumTableIndex[dvModule2Index(_Module)] = value;
8941 }
8942
8943 #undef dvModuleGetNumEnumTable
dvModuleGetNumEnumTable(dvModule _Module)8944 uint32 dvModuleGetNumEnumTable(
8945 dvModule _Module)
8946 {
8947 return dvModules.NumEnumTable[dvModule2Index(_Module)];
8948 }
8949
8950 #undef dvModuleSetNumEnumTable
dvModuleSetNumEnumTable(dvModule _Module,uint32 value)8951 void dvModuleSetNumEnumTable(
8952 dvModule _Module,
8953 uint32 value)
8954 {
8955 dvModules.NumEnumTable[dvModule2Index(_Module)] = value;
8956 }
8957
8958 #undef dvModuleGetiEnumTable
dvModuleGetiEnumTable(dvModule _Module,uint32 x)8959 dvEnum dvModuleGetiEnumTable(
8960 dvModule _Module,
8961 uint32 x)
8962 {
8963 return (dvModules.EnumTable)[dvModuleGetEnumTableIndex(_Module) + x];
8964 }
8965
8966 #undef dvModuleSetiEnumTable
dvModuleSetiEnumTable(dvModule Module,uint32 x,dvEnum value)8967 void dvModuleSetiEnumTable(
8968 dvModule Module,
8969 uint32 x,
8970 dvEnum value)
8971 {
8972 dvModules.EnumTable[dvModuleGetEnumTableIndex(Module) + x] = value;
8973 }
8974
8975 #undef dvModuleGetEnumTable
dvModuleGetEnumTable(dvModule Module)8976 dvEnum *dvModuleGetEnumTable(
8977 dvModule Module)
8978 {
8979 return dvModules.EnumTable + dvModuleGetEnumTableIndex(Module);
8980 }
8981
8982 #undef dvModuleGetNumEnum
dvModuleGetNumEnum(dvModule _Module)8983 uint32 dvModuleGetNumEnum(
8984 dvModule _Module)
8985 {
8986 return dvModules.NumEnum[dvModule2Index(_Module)];
8987 }
8988
8989 #undef dvModuleSetNumEnum
dvModuleSetNumEnum(dvModule _Module,uint32 value)8990 void dvModuleSetNumEnum(
8991 dvModule _Module,
8992 uint32 value)
8993 {
8994 dvModules.NumEnum[dvModule2Index(_Module)] = value;
8995 }
8996
8997 #undef dvModuleGetFirstTypedef
dvModuleGetFirstTypedef(dvModule _Module)8998 dvTypedef dvModuleGetFirstTypedef(
8999 dvModule _Module)
9000 {
9001 return dvModules.FirstTypedef[dvModule2Index(_Module)];
9002 }
9003
9004 #undef dvModuleSetFirstTypedef
dvModuleSetFirstTypedef(dvModule _Module,dvTypedef value)9005 void dvModuleSetFirstTypedef(
9006 dvModule _Module,
9007 dvTypedef value)
9008 {
9009 dvModules.FirstTypedef[dvModule2Index(_Module)] = value;
9010 }
9011
9012 #undef dvModuleGetLastTypedef
dvModuleGetLastTypedef(dvModule _Module)9013 dvTypedef dvModuleGetLastTypedef(
9014 dvModule _Module)
9015 {
9016 return dvModules.LastTypedef[dvModule2Index(_Module)];
9017 }
9018
9019 #undef dvModuleSetLastTypedef
dvModuleSetLastTypedef(dvModule _Module,dvTypedef value)9020 void dvModuleSetLastTypedef(
9021 dvModule _Module,
9022 dvTypedef value)
9023 {
9024 dvModules.LastTypedef[dvModule2Index(_Module)] = value;
9025 }
9026
9027 #undef dvModuleGetTypedefTableIndex
dvModuleGetTypedefTableIndex(dvModule _Module)9028 uint32 dvModuleGetTypedefTableIndex(
9029 dvModule _Module)
9030 {
9031 return dvModules.TypedefTableIndex[dvModule2Index(_Module)];
9032 }
9033
9034 #undef dvModuleSetTypedefTableIndex
dvModuleSetTypedefTableIndex(dvModule _Module,uint32 value)9035 void dvModuleSetTypedefTableIndex(
9036 dvModule _Module,
9037 uint32 value)
9038 {
9039 dvModules.TypedefTableIndex[dvModule2Index(_Module)] = value;
9040 }
9041
9042 #undef dvModuleGetNumTypedefTable
dvModuleGetNumTypedefTable(dvModule _Module)9043 uint32 dvModuleGetNumTypedefTable(
9044 dvModule _Module)
9045 {
9046 return dvModules.NumTypedefTable[dvModule2Index(_Module)];
9047 }
9048
9049 #undef dvModuleSetNumTypedefTable
dvModuleSetNumTypedefTable(dvModule _Module,uint32 value)9050 void dvModuleSetNumTypedefTable(
9051 dvModule _Module,
9052 uint32 value)
9053 {
9054 dvModules.NumTypedefTable[dvModule2Index(_Module)] = value;
9055 }
9056
9057 #undef dvModuleGetiTypedefTable
dvModuleGetiTypedefTable(dvModule _Module,uint32 x)9058 dvTypedef dvModuleGetiTypedefTable(
9059 dvModule _Module,
9060 uint32 x)
9061 {
9062 return (dvModules.TypedefTable)[dvModuleGetTypedefTableIndex(_Module) + x];
9063 }
9064
9065 #undef dvModuleSetiTypedefTable
dvModuleSetiTypedefTable(dvModule Module,uint32 x,dvTypedef value)9066 void dvModuleSetiTypedefTable(
9067 dvModule Module,
9068 uint32 x,
9069 dvTypedef value)
9070 {
9071 dvModules.TypedefTable[dvModuleGetTypedefTableIndex(Module) + x] = value;
9072 }
9073
9074 #undef dvModuleGetTypedefTable
dvModuleGetTypedefTable(dvModule Module)9075 dvTypedef *dvModuleGetTypedefTable(
9076 dvModule Module)
9077 {
9078 return dvModules.TypedefTable + dvModuleGetTypedefTableIndex(Module);
9079 }
9080
9081 #undef dvModuleGetNumTypedef
dvModuleGetNumTypedef(dvModule _Module)9082 uint32 dvModuleGetNumTypedef(
9083 dvModule _Module)
9084 {
9085 return dvModules.NumTypedef[dvModule2Index(_Module)];
9086 }
9087
9088 #undef dvModuleSetNumTypedef
dvModuleSetNumTypedef(dvModule _Module,uint32 value)9089 void dvModuleSetNumTypedef(
9090 dvModule _Module,
9091 uint32 value)
9092 {
9093 dvModules.NumTypedef[dvModule2Index(_Module)] = value;
9094 }
9095
9096 #undef dvModuleGetFirstSchema
dvModuleGetFirstSchema(dvModule _Module)9097 dvSchema dvModuleGetFirstSchema(
9098 dvModule _Module)
9099 {
9100 return dvModules.FirstSchema[dvModule2Index(_Module)];
9101 }
9102
9103 #undef dvModuleSetFirstSchema
dvModuleSetFirstSchema(dvModule _Module,dvSchema value)9104 void dvModuleSetFirstSchema(
9105 dvModule _Module,
9106 dvSchema value)
9107 {
9108 dvModules.FirstSchema[dvModule2Index(_Module)] = value;
9109 }
9110
9111 #undef dvModuleGetLastSchema
dvModuleGetLastSchema(dvModule _Module)9112 dvSchema dvModuleGetLastSchema(
9113 dvModule _Module)
9114 {
9115 return dvModules.LastSchema[dvModule2Index(_Module)];
9116 }
9117
9118 #undef dvModuleSetLastSchema
dvModuleSetLastSchema(dvModule _Module,dvSchema value)9119 void dvModuleSetLastSchema(
9120 dvModule _Module,
9121 dvSchema value)
9122 {
9123 dvModules.LastSchema[dvModule2Index(_Module)] = value;
9124 }
9125
9126 #undef dvModuleGetSchemaTableIndex
dvModuleGetSchemaTableIndex(dvModule _Module)9127 uint32 dvModuleGetSchemaTableIndex(
9128 dvModule _Module)
9129 {
9130 return dvModules.SchemaTableIndex[dvModule2Index(_Module)];
9131 }
9132
9133 #undef dvModuleSetSchemaTableIndex
dvModuleSetSchemaTableIndex(dvModule _Module,uint32 value)9134 void dvModuleSetSchemaTableIndex(
9135 dvModule _Module,
9136 uint32 value)
9137 {
9138 dvModules.SchemaTableIndex[dvModule2Index(_Module)] = value;
9139 }
9140
9141 #undef dvModuleGetNumSchemaTable
dvModuleGetNumSchemaTable(dvModule _Module)9142 uint32 dvModuleGetNumSchemaTable(
9143 dvModule _Module)
9144 {
9145 return dvModules.NumSchemaTable[dvModule2Index(_Module)];
9146 }
9147
9148 #undef dvModuleSetNumSchemaTable
dvModuleSetNumSchemaTable(dvModule _Module,uint32 value)9149 void dvModuleSetNumSchemaTable(
9150 dvModule _Module,
9151 uint32 value)
9152 {
9153 dvModules.NumSchemaTable[dvModule2Index(_Module)] = value;
9154 }
9155
9156 #undef dvModuleGetiSchemaTable
dvModuleGetiSchemaTable(dvModule _Module,uint32 x)9157 dvSchema dvModuleGetiSchemaTable(
9158 dvModule _Module,
9159 uint32 x)
9160 {
9161 return (dvModules.SchemaTable)[dvModuleGetSchemaTableIndex(_Module) + x];
9162 }
9163
9164 #undef dvModuleSetiSchemaTable
dvModuleSetiSchemaTable(dvModule Module,uint32 x,dvSchema value)9165 void dvModuleSetiSchemaTable(
9166 dvModule Module,
9167 uint32 x,
9168 dvSchema value)
9169 {
9170 dvModules.SchemaTable[dvModuleGetSchemaTableIndex(Module) + x] = value;
9171 }
9172
9173 #undef dvModuleGetSchemaTable
dvModuleGetSchemaTable(dvModule Module)9174 dvSchema *dvModuleGetSchemaTable(
9175 dvModule Module)
9176 {
9177 return dvModules.SchemaTable + dvModuleGetSchemaTableIndex(Module);
9178 }
9179
9180 #undef dvModuleGetNumSchema
dvModuleGetNumSchema(dvModule _Module)9181 uint32 dvModuleGetNumSchema(
9182 dvModule _Module)
9183 {
9184 return dvModules.NumSchema[dvModule2Index(_Module)];
9185 }
9186
9187 #undef dvModuleSetNumSchema
dvModuleSetNumSchema(dvModule _Module,uint32 value)9188 void dvModuleSetNumSchema(
9189 dvModule _Module,
9190 uint32 value)
9191 {
9192 dvModules.NumSchema[dvModule2Index(_Module)] = value;
9193 }
9194
9195 #undef dvModuleGetFirstImportLink
dvModuleGetFirstImportLink(dvModule _Module)9196 dvLink dvModuleGetFirstImportLink(
9197 dvModule _Module)
9198 {
9199 return dvModules.FirstImportLink[dvModule2Index(_Module)];
9200 }
9201
9202 #undef dvModuleSetFirstImportLink
dvModuleSetFirstImportLink(dvModule _Module,dvLink value)9203 void dvModuleSetFirstImportLink(
9204 dvModule _Module,
9205 dvLink value)
9206 {
9207 dvModules.FirstImportLink[dvModule2Index(_Module)] = value;
9208 }
9209
9210 #undef dvModuleGetLastImportLink
dvModuleGetLastImportLink(dvModule _Module)9211 dvLink dvModuleGetLastImportLink(
9212 dvModule _Module)
9213 {
9214 return dvModules.LastImportLink[dvModule2Index(_Module)];
9215 }
9216
9217 #undef dvModuleSetLastImportLink
dvModuleSetLastImportLink(dvModule _Module,dvLink value)9218 void dvModuleSetLastImportLink(
9219 dvModule _Module,
9220 dvLink value)
9221 {
9222 dvModules.LastImportLink[dvModule2Index(_Module)] = value;
9223 }
9224
9225 #undef dvModuleGetFirstExportLink
dvModuleGetFirstExportLink(dvModule _Module)9226 dvLink dvModuleGetFirstExportLink(
9227 dvModule _Module)
9228 {
9229 return dvModules.FirstExportLink[dvModule2Index(_Module)];
9230 }
9231
9232 #undef dvModuleSetFirstExportLink
dvModuleSetFirstExportLink(dvModule _Module,dvLink value)9233 void dvModuleSetFirstExportLink(
9234 dvModule _Module,
9235 dvLink value)
9236 {
9237 dvModules.FirstExportLink[dvModule2Index(_Module)] = value;
9238 }
9239
9240 #undef dvModuleGetLastExportLink
dvModuleGetLastExportLink(dvModule _Module)9241 dvLink dvModuleGetLastExportLink(
9242 dvModule _Module)
9243 {
9244 return dvModules.LastExportLink[dvModule2Index(_Module)];
9245 }
9246
9247 #undef dvModuleSetLastExportLink
dvModuleSetLastExportLink(dvModule _Module,dvLink value)9248 void dvModuleSetLastExportLink(
9249 dvModule _Module,
9250 dvLink value)
9251 {
9252 dvModules.LastExportLink[dvModule2Index(_Module)] = value;
9253 }
9254
9255 #undef dvClassGetName
dvClassGetName(dvClass Class)9256 char *dvClassGetName(
9257 dvClass Class)
9258 {
9259 return utSymGetName(dvClassGetSym(Class));
9260 }
9261
9262 #undef dvEnumGetName
dvEnumGetName(dvEnum Enum)9263 char *dvEnumGetName(
9264 dvEnum Enum)
9265 {
9266 return utSymGetName(dvEnumGetSym(Enum));
9267 }
9268
9269 #undef dvTypedefGetName
dvTypedefGetName(dvTypedef Typedef)9270 char *dvTypedefGetName(
9271 dvTypedef Typedef)
9272 {
9273 return utSymGetName(dvTypedefGetSym(Typedef));
9274 }
9275
9276 #undef dvSchemaGetName
dvSchemaGetName(dvSchema Schema)9277 char *dvSchemaGetName(
9278 dvSchema Schema)
9279 {
9280 return utSymGetName(dvSchemaGetSym(Schema));
9281 }
9282
9283 #undef dvLinkGetImportModule
dvLinkGetImportModule(dvLink _Link)9284 dvModule dvLinkGetImportModule(
9285 dvLink _Link)
9286 {
9287 return dvLinks.ImportModule[dvLink2Index(_Link)];
9288 }
9289
9290 #undef dvLinkSetImportModule
dvLinkSetImportModule(dvLink _Link,dvModule value)9291 void dvLinkSetImportModule(
9292 dvLink _Link,
9293 dvModule value)
9294 {
9295 dvLinks.ImportModule[dvLink2Index(_Link)] = value;
9296 }
9297
9298 #undef dvLinkGetNextModuleImportLink
dvLinkGetNextModuleImportLink(dvLink _Link)9299 dvLink dvLinkGetNextModuleImportLink(
9300 dvLink _Link)
9301 {
9302 return dvLinks.NextModuleImportLink[dvLink2Index(_Link)];
9303 }
9304
9305 #undef dvLinkSetNextModuleImportLink
dvLinkSetNextModuleImportLink(dvLink _Link,dvLink value)9306 void dvLinkSetNextModuleImportLink(
9307 dvLink _Link,
9308 dvLink value)
9309 {
9310 dvLinks.NextModuleImportLink[dvLink2Index(_Link)] = value;
9311 }
9312
9313 #undef dvLinkGetExportModule
dvLinkGetExportModule(dvLink _Link)9314 dvModule dvLinkGetExportModule(
9315 dvLink _Link)
9316 {
9317 return dvLinks.ExportModule[dvLink2Index(_Link)];
9318 }
9319
9320 #undef dvLinkSetExportModule
dvLinkSetExportModule(dvLink _Link,dvModule value)9321 void dvLinkSetExportModule(
9322 dvLink _Link,
9323 dvModule value)
9324 {
9325 dvLinks.ExportModule[dvLink2Index(_Link)] = value;
9326 }
9327
9328 #undef dvLinkGetNextModuleExportLink
dvLinkGetNextModuleExportLink(dvLink _Link)9329 dvLink dvLinkGetNextModuleExportLink(
9330 dvLink _Link)
9331 {
9332 return dvLinks.NextModuleExportLink[dvLink2Index(_Link)];
9333 }
9334
9335 #undef dvLinkSetNextModuleExportLink
dvLinkSetNextModuleExportLink(dvLink _Link,dvLink value)9336 void dvLinkSetNextModuleExportLink(
9337 dvLink _Link,
9338 dvLink value)
9339 {
9340 dvLinks.NextModuleExportLink[dvLink2Index(_Link)] = value;
9341 }
9342
9343 #undef dvSchemaGetSym
dvSchemaGetSym(dvSchema _Schema)9344 utSym dvSchemaGetSym(
9345 dvSchema _Schema)
9346 {
9347 return dvSchemas.Sym[dvSchema2Index(_Schema)];
9348 }
9349
9350 #undef dvSchemaSetSym
dvSchemaSetSym(dvSchema _Schema,utSym value)9351 void dvSchemaSetSym(
9352 dvSchema _Schema,
9353 utSym value)
9354 {
9355 dvSchemas.Sym[dvSchema2Index(_Schema)] = value;
9356 }
9357
9358 #undef dvSchemaGetModule
dvSchemaGetModule(dvSchema _Schema)9359 dvModule dvSchemaGetModule(
9360 dvSchema _Schema)
9361 {
9362 return dvSchemas.Module[dvSchema2Index(_Schema)];
9363 }
9364
9365 #undef dvSchemaSetModule
dvSchemaSetModule(dvSchema _Schema,dvModule value)9366 void dvSchemaSetModule(
9367 dvSchema _Schema,
9368 dvModule value)
9369 {
9370 dvSchemas.Module[dvSchema2Index(_Schema)] = value;
9371 }
9372
9373 #undef dvSchemaGetNextModuleSchema
dvSchemaGetNextModuleSchema(dvSchema _Schema)9374 dvSchema dvSchemaGetNextModuleSchema(
9375 dvSchema _Schema)
9376 {
9377 return dvSchemas.NextModuleSchema[dvSchema2Index(_Schema)];
9378 }
9379
9380 #undef dvSchemaSetNextModuleSchema
dvSchemaSetNextModuleSchema(dvSchema _Schema,dvSchema value)9381 void dvSchemaSetNextModuleSchema(
9382 dvSchema _Schema,
9383 dvSchema value)
9384 {
9385 dvSchemas.NextModuleSchema[dvSchema2Index(_Schema)] = value;
9386 }
9387
9388 #undef dvSchemaGetPrevModuleSchema
dvSchemaGetPrevModuleSchema(dvSchema _Schema)9389 dvSchema dvSchemaGetPrevModuleSchema(
9390 dvSchema _Schema)
9391 {
9392 return dvSchemas.PrevModuleSchema[dvSchema2Index(_Schema)];
9393 }
9394
9395 #undef dvSchemaSetPrevModuleSchema
dvSchemaSetPrevModuleSchema(dvSchema _Schema,dvSchema value)9396 void dvSchemaSetPrevModuleSchema(
9397 dvSchema _Schema,
9398 dvSchema value)
9399 {
9400 dvSchemas.PrevModuleSchema[dvSchema2Index(_Schema)] = value;
9401 }
9402
9403 #undef dvSchemaGetNextTableModuleSchema
dvSchemaGetNextTableModuleSchema(dvSchema _Schema)9404 dvSchema dvSchemaGetNextTableModuleSchema(
9405 dvSchema _Schema)
9406 {
9407 return dvSchemas.NextTableModuleSchema[dvSchema2Index(_Schema)];
9408 }
9409
9410 #undef dvSchemaSetNextTableModuleSchema
dvSchemaSetNextTableModuleSchema(dvSchema _Schema,dvSchema value)9411 void dvSchemaSetNextTableModuleSchema(
9412 dvSchema _Schema,
9413 dvSchema value)
9414 {
9415 dvSchemas.NextTableModuleSchema[dvSchema2Index(_Schema)] = value;
9416 }
9417
9418 #undef dvSchemaGetFirstRelationship
dvSchemaGetFirstRelationship(dvSchema _Schema)9419 dvRelationship dvSchemaGetFirstRelationship(
9420 dvSchema _Schema)
9421 {
9422 return dvSchemas.FirstRelationship[dvSchema2Index(_Schema)];
9423 }
9424
9425 #undef dvSchemaSetFirstRelationship
dvSchemaSetFirstRelationship(dvSchema _Schema,dvRelationship value)9426 void dvSchemaSetFirstRelationship(
9427 dvSchema _Schema,
9428 dvRelationship value)
9429 {
9430 dvSchemas.FirstRelationship[dvSchema2Index(_Schema)] = value;
9431 }
9432
9433 #undef dvSchemaGetLastRelationship
dvSchemaGetLastRelationship(dvSchema _Schema)9434 dvRelationship dvSchemaGetLastRelationship(
9435 dvSchema _Schema)
9436 {
9437 return dvSchemas.LastRelationship[dvSchema2Index(_Schema)];
9438 }
9439
9440 #undef dvSchemaSetLastRelationship
dvSchemaSetLastRelationship(dvSchema _Schema,dvRelationship value)9441 void dvSchemaSetLastRelationship(
9442 dvSchema _Schema,
9443 dvRelationship value)
9444 {
9445 dvSchemas.LastRelationship[dvSchema2Index(_Schema)] = value;
9446 }
9447
9448 #undef dvEnumGetSym
dvEnumGetSym(dvEnum _Enum)9449 utSym dvEnumGetSym(
9450 dvEnum _Enum)
9451 {
9452 return dvEnums.Sym[dvEnum2Index(_Enum)];
9453 }
9454
9455 #undef dvEnumSetSym
dvEnumSetSym(dvEnum _Enum,utSym value)9456 void dvEnumSetSym(
9457 dvEnum _Enum,
9458 utSym value)
9459 {
9460 dvEnums.Sym[dvEnum2Index(_Enum)] = value;
9461 }
9462
9463 #undef dvEnumGetPrefixSym
dvEnumGetPrefixSym(dvEnum _Enum)9464 utSym dvEnumGetPrefixSym(
9465 dvEnum _Enum)
9466 {
9467 return dvEnums.PrefixSym[dvEnum2Index(_Enum)];
9468 }
9469
9470 #undef dvEnumSetPrefixSym
dvEnumSetPrefixSym(dvEnum _Enum,utSym value)9471 void dvEnumSetPrefixSym(
9472 dvEnum _Enum,
9473 utSym value)
9474 {
9475 dvEnums.PrefixSym[dvEnum2Index(_Enum)] = value;
9476 }
9477
9478 #undef dvEnumGetNumEntries
dvEnumGetNumEntries(dvEnum _Enum)9479 uint16 dvEnumGetNumEntries(
9480 dvEnum _Enum)
9481 {
9482 return dvEnums.NumEntries[dvEnum2Index(_Enum)];
9483 }
9484
9485 #undef dvEnumSetNumEntries
dvEnumSetNumEntries(dvEnum _Enum,uint16 value)9486 void dvEnumSetNumEntries(
9487 dvEnum _Enum,
9488 uint16 value)
9489 {
9490 dvEnums.NumEntries[dvEnum2Index(_Enum)] = value;
9491 }
9492
9493 #undef dvEnumGetModule
dvEnumGetModule(dvEnum _Enum)9494 dvModule dvEnumGetModule(
9495 dvEnum _Enum)
9496 {
9497 return dvEnums.Module[dvEnum2Index(_Enum)];
9498 }
9499
9500 #undef dvEnumSetModule
dvEnumSetModule(dvEnum _Enum,dvModule value)9501 void dvEnumSetModule(
9502 dvEnum _Enum,
9503 dvModule value)
9504 {
9505 dvEnums.Module[dvEnum2Index(_Enum)] = value;
9506 }
9507
9508 #undef dvEnumGetNextModuleEnum
dvEnumGetNextModuleEnum(dvEnum _Enum)9509 dvEnum dvEnumGetNextModuleEnum(
9510 dvEnum _Enum)
9511 {
9512 return dvEnums.NextModuleEnum[dvEnum2Index(_Enum)];
9513 }
9514
9515 #undef dvEnumSetNextModuleEnum
dvEnumSetNextModuleEnum(dvEnum _Enum,dvEnum value)9516 void dvEnumSetNextModuleEnum(
9517 dvEnum _Enum,
9518 dvEnum value)
9519 {
9520 dvEnums.NextModuleEnum[dvEnum2Index(_Enum)] = value;
9521 }
9522
9523 #undef dvEnumGetPrevModuleEnum
dvEnumGetPrevModuleEnum(dvEnum _Enum)9524 dvEnum dvEnumGetPrevModuleEnum(
9525 dvEnum _Enum)
9526 {
9527 return dvEnums.PrevModuleEnum[dvEnum2Index(_Enum)];
9528 }
9529
9530 #undef dvEnumSetPrevModuleEnum
dvEnumSetPrevModuleEnum(dvEnum _Enum,dvEnum value)9531 void dvEnumSetPrevModuleEnum(
9532 dvEnum _Enum,
9533 dvEnum value)
9534 {
9535 dvEnums.PrevModuleEnum[dvEnum2Index(_Enum)] = value;
9536 }
9537
9538 #undef dvEnumGetNextTableModuleEnum
dvEnumGetNextTableModuleEnum(dvEnum _Enum)9539 dvEnum dvEnumGetNextTableModuleEnum(
9540 dvEnum _Enum)
9541 {
9542 return dvEnums.NextTableModuleEnum[dvEnum2Index(_Enum)];
9543 }
9544
9545 #undef dvEnumSetNextTableModuleEnum
dvEnumSetNextTableModuleEnum(dvEnum _Enum,dvEnum value)9546 void dvEnumSetNextTableModuleEnum(
9547 dvEnum _Enum,
9548 dvEnum value)
9549 {
9550 dvEnums.NextTableModuleEnum[dvEnum2Index(_Enum)] = value;
9551 }
9552
9553 #undef dvEnumGetFirstEntry
dvEnumGetFirstEntry(dvEnum _Enum)9554 dvEntry dvEnumGetFirstEntry(
9555 dvEnum _Enum)
9556 {
9557 return dvEnums.FirstEntry[dvEnum2Index(_Enum)];
9558 }
9559
9560 #undef dvEnumSetFirstEntry
dvEnumSetFirstEntry(dvEnum _Enum,dvEntry value)9561 void dvEnumSetFirstEntry(
9562 dvEnum _Enum,
9563 dvEntry value)
9564 {
9565 dvEnums.FirstEntry[dvEnum2Index(_Enum)] = value;
9566 }
9567
9568 #undef dvEnumGetLastEntry
dvEnumGetLastEntry(dvEnum _Enum)9569 dvEntry dvEnumGetLastEntry(
9570 dvEnum _Enum)
9571 {
9572 return dvEnums.LastEntry[dvEnum2Index(_Enum)];
9573 }
9574
9575 #undef dvEnumSetLastEntry
dvEnumSetLastEntry(dvEnum _Enum,dvEntry value)9576 void dvEnumSetLastEntry(
9577 dvEnum _Enum,
9578 dvEntry value)
9579 {
9580 dvEnums.LastEntry[dvEnum2Index(_Enum)] = value;
9581 }
9582
9583 #undef dvEnumGetEntryTableIndex
dvEnumGetEntryTableIndex(dvEnum _Enum)9584 uint32 dvEnumGetEntryTableIndex(
9585 dvEnum _Enum)
9586 {
9587 return dvEnums.EntryTableIndex[dvEnum2Index(_Enum)];
9588 }
9589
9590 #undef dvEnumSetEntryTableIndex
dvEnumSetEntryTableIndex(dvEnum _Enum,uint32 value)9591 void dvEnumSetEntryTableIndex(
9592 dvEnum _Enum,
9593 uint32 value)
9594 {
9595 dvEnums.EntryTableIndex[dvEnum2Index(_Enum)] = value;
9596 }
9597
9598 #undef dvEnumGetNumEntryTable
dvEnumGetNumEntryTable(dvEnum _Enum)9599 uint32 dvEnumGetNumEntryTable(
9600 dvEnum _Enum)
9601 {
9602 return dvEnums.NumEntryTable[dvEnum2Index(_Enum)];
9603 }
9604
9605 #undef dvEnumSetNumEntryTable
dvEnumSetNumEntryTable(dvEnum _Enum,uint32 value)9606 void dvEnumSetNumEntryTable(
9607 dvEnum _Enum,
9608 uint32 value)
9609 {
9610 dvEnums.NumEntryTable[dvEnum2Index(_Enum)] = value;
9611 }
9612
9613 #undef dvEnumGetiEntryTable
dvEnumGetiEntryTable(dvEnum _Enum,uint32 x)9614 dvEntry dvEnumGetiEntryTable(
9615 dvEnum _Enum,
9616 uint32 x)
9617 {
9618 return (dvEnums.EntryTable)[dvEnumGetEntryTableIndex(_Enum) + x];
9619 }
9620
9621 #undef dvEnumSetiEntryTable
dvEnumSetiEntryTable(dvEnum Enum,uint32 x,dvEntry value)9622 void dvEnumSetiEntryTable(
9623 dvEnum Enum,
9624 uint32 x,
9625 dvEntry value)
9626 {
9627 dvEnums.EntryTable[dvEnumGetEntryTableIndex(Enum) + x] = value;
9628 }
9629
9630 #undef dvEnumGetEntryTable
dvEnumGetEntryTable(dvEnum Enum)9631 dvEntry *dvEnumGetEntryTable(
9632 dvEnum Enum)
9633 {
9634 return dvEnums.EntryTable + dvEnumGetEntryTableIndex(Enum);
9635 }
9636
9637 #undef dvEnumGetNumEntry
dvEnumGetNumEntry(dvEnum _Enum)9638 uint32 dvEnumGetNumEntry(
9639 dvEnum _Enum)
9640 {
9641 return dvEnums.NumEntry[dvEnum2Index(_Enum)];
9642 }
9643
9644 #undef dvEnumSetNumEntry
dvEnumSetNumEntry(dvEnum _Enum,uint32 value)9645 void dvEnumSetNumEntry(
9646 dvEnum _Enum,
9647 uint32 value)
9648 {
9649 dvEnums.NumEntry[dvEnum2Index(_Enum)] = value;
9650 }
9651
9652 #undef dvEntryGetName
dvEntryGetName(dvEntry Entry)9653 char *dvEntryGetName(
9654 dvEntry Entry)
9655 {
9656 return utSymGetName(dvEntryGetSym(Entry));
9657 }
9658
9659 #undef dvEntryGetSym
dvEntryGetSym(dvEntry _Entry)9660 utSym dvEntryGetSym(
9661 dvEntry _Entry)
9662 {
9663 return dvEntrys.Sym[dvEntry2Index(_Entry)];
9664 }
9665
9666 #undef dvEntrySetSym
dvEntrySetSym(dvEntry _Entry,utSym value)9667 void dvEntrySetSym(
9668 dvEntry _Entry,
9669 utSym value)
9670 {
9671 dvEntrys.Sym[dvEntry2Index(_Entry)] = value;
9672 }
9673
9674 #undef dvEntryGetValue
dvEntryGetValue(dvEntry _Entry)9675 uint32 dvEntryGetValue(
9676 dvEntry _Entry)
9677 {
9678 return dvEntrys.Value[dvEntry2Index(_Entry)];
9679 }
9680
9681 #undef dvEntrySetValue
dvEntrySetValue(dvEntry _Entry,uint32 value)9682 void dvEntrySetValue(
9683 dvEntry _Entry,
9684 uint32 value)
9685 {
9686 dvEntrys.Value[dvEntry2Index(_Entry)] = value;
9687 }
9688
9689 #undef dvEntryGetEnum
dvEntryGetEnum(dvEntry _Entry)9690 dvEnum dvEntryGetEnum(
9691 dvEntry _Entry)
9692 {
9693 return dvEntrys.Enum[dvEntry2Index(_Entry)];
9694 }
9695
9696 #undef dvEntrySetEnum
dvEntrySetEnum(dvEntry _Entry,dvEnum value)9697 void dvEntrySetEnum(
9698 dvEntry _Entry,
9699 dvEnum value)
9700 {
9701 dvEntrys.Enum[dvEntry2Index(_Entry)] = value;
9702 }
9703
9704 #undef dvEntryGetNextEnumEntry
dvEntryGetNextEnumEntry(dvEntry _Entry)9705 dvEntry dvEntryGetNextEnumEntry(
9706 dvEntry _Entry)
9707 {
9708 return dvEntrys.NextEnumEntry[dvEntry2Index(_Entry)];
9709 }
9710
9711 #undef dvEntrySetNextEnumEntry
dvEntrySetNextEnumEntry(dvEntry _Entry,dvEntry value)9712 void dvEntrySetNextEnumEntry(
9713 dvEntry _Entry,
9714 dvEntry value)
9715 {
9716 dvEntrys.NextEnumEntry[dvEntry2Index(_Entry)] = value;
9717 }
9718
9719 #undef dvEntryGetPrevEnumEntry
dvEntryGetPrevEnumEntry(dvEntry _Entry)9720 dvEntry dvEntryGetPrevEnumEntry(
9721 dvEntry _Entry)
9722 {
9723 return dvEntrys.PrevEnumEntry[dvEntry2Index(_Entry)];
9724 }
9725
9726 #undef dvEntrySetPrevEnumEntry
dvEntrySetPrevEnumEntry(dvEntry _Entry,dvEntry value)9727 void dvEntrySetPrevEnumEntry(
9728 dvEntry _Entry,
9729 dvEntry value)
9730 {
9731 dvEntrys.PrevEnumEntry[dvEntry2Index(_Entry)] = value;
9732 }
9733
9734 #undef dvEntryGetNextTableEnumEntry
dvEntryGetNextTableEnumEntry(dvEntry _Entry)9735 dvEntry dvEntryGetNextTableEnumEntry(
9736 dvEntry _Entry)
9737 {
9738 return dvEntrys.NextTableEnumEntry[dvEntry2Index(_Entry)];
9739 }
9740
9741 #undef dvEntrySetNextTableEnumEntry
dvEntrySetNextTableEnumEntry(dvEntry _Entry,dvEntry value)9742 void dvEntrySetNextTableEnumEntry(
9743 dvEntry _Entry,
9744 dvEntry value)
9745 {
9746 dvEntrys.NextTableEnumEntry[dvEntry2Index(_Entry)] = value;
9747 }
9748
9749 #undef dvEntryGetFirstCase
dvEntryGetFirstCase(dvEntry _Entry)9750 dvCase dvEntryGetFirstCase(
9751 dvEntry _Entry)
9752 {
9753 return dvEntrys.FirstCase[dvEntry2Index(_Entry)];
9754 }
9755
9756 #undef dvEntrySetFirstCase
dvEntrySetFirstCase(dvEntry _Entry,dvCase value)9757 void dvEntrySetFirstCase(
9758 dvEntry _Entry,
9759 dvCase value)
9760 {
9761 dvEntrys.FirstCase[dvEntry2Index(_Entry)] = value;
9762 }
9763
9764 #undef dvEntryGetLastCase
dvEntryGetLastCase(dvEntry _Entry)9765 dvCase dvEntryGetLastCase(
9766 dvEntry _Entry)
9767 {
9768 return dvEntrys.LastCase[dvEntry2Index(_Entry)];
9769 }
9770
9771 #undef dvEntrySetLastCase
dvEntrySetLastCase(dvEntry _Entry,dvCase value)9772 void dvEntrySetLastCase(
9773 dvEntry _Entry,
9774 dvCase value)
9775 {
9776 dvEntrys.LastCase[dvEntry2Index(_Entry)] = value;
9777 }
9778
9779 #undef dvTypedefGetSym
dvTypedefGetSym(dvTypedef _Typedef)9780 utSym dvTypedefGetSym(
9781 dvTypedef _Typedef)
9782 {
9783 return dvTypedefs.Sym[dvTypedef2Index(_Typedef)];
9784 }
9785
9786 #undef dvTypedefSetSym
dvTypedefSetSym(dvTypedef _Typedef,utSym value)9787 void dvTypedefSetSym(
9788 dvTypedef _Typedef,
9789 utSym value)
9790 {
9791 dvTypedefs.Sym[dvTypedef2Index(_Typedef)] = value;
9792 }
9793
9794 #undef dvTypedefGetInitializerIndex
dvTypedefGetInitializerIndex(dvTypedef _Typedef)9795 uint32 dvTypedefGetInitializerIndex(
9796 dvTypedef _Typedef)
9797 {
9798 return dvTypedefs.InitializerIndex[dvTypedef2Index(_Typedef)];
9799 }
9800
9801 #undef dvTypedefSetInitializerIndex
dvTypedefSetInitializerIndex(dvTypedef _Typedef,uint32 value)9802 void dvTypedefSetInitializerIndex(
9803 dvTypedef _Typedef,
9804 uint32 value)
9805 {
9806 dvTypedefs.InitializerIndex[dvTypedef2Index(_Typedef)] = value;
9807 }
9808
9809 #undef dvTypedefGetNumInitializer
dvTypedefGetNumInitializer(dvTypedef _Typedef)9810 uint32 dvTypedefGetNumInitializer(
9811 dvTypedef _Typedef)
9812 {
9813 return dvTypedefs.NumInitializer[dvTypedef2Index(_Typedef)];
9814 }
9815
9816 #undef dvTypedefSetNumInitializer
dvTypedefSetNumInitializer(dvTypedef _Typedef,uint32 value)9817 void dvTypedefSetNumInitializer(
9818 dvTypedef _Typedef,
9819 uint32 value)
9820 {
9821 dvTypedefs.NumInitializer[dvTypedef2Index(_Typedef)] = value;
9822 }
9823
9824 #undef dvTypedefGetiInitializer
dvTypedefGetiInitializer(dvTypedef _Typedef,uint32 x)9825 char dvTypedefGetiInitializer(
9826 dvTypedef _Typedef,
9827 uint32 x)
9828 {
9829 return (dvTypedefs.Initializer)[dvTypedefGetInitializerIndex(_Typedef) + x];
9830 }
9831
9832 #undef dvTypedefSetiInitializer
dvTypedefSetiInitializer(dvTypedef Typedef,uint32 x,char value)9833 void dvTypedefSetiInitializer(
9834 dvTypedef Typedef,
9835 uint32 x,
9836 char value)
9837 {
9838 dvTypedefs.Initializer[dvTypedefGetInitializerIndex(Typedef) + x] = value;
9839 }
9840
9841 #undef dvTypedefGetInitializer
dvTypedefGetInitializer(dvTypedef Typedef)9842 char *dvTypedefGetInitializer(
9843 dvTypedef Typedef)
9844 {
9845 return dvTypedefs.Initializer + dvTypedefGetInitializerIndex(Typedef);
9846 }
9847
9848 #undef dvTypedefGetModule
dvTypedefGetModule(dvTypedef _Typedef)9849 dvModule dvTypedefGetModule(
9850 dvTypedef _Typedef)
9851 {
9852 return dvTypedefs.Module[dvTypedef2Index(_Typedef)];
9853 }
9854
9855 #undef dvTypedefSetModule
dvTypedefSetModule(dvTypedef _Typedef,dvModule value)9856 void dvTypedefSetModule(
9857 dvTypedef _Typedef,
9858 dvModule value)
9859 {
9860 dvTypedefs.Module[dvTypedef2Index(_Typedef)] = value;
9861 }
9862
9863 #undef dvTypedefGetNextModuleTypedef
dvTypedefGetNextModuleTypedef(dvTypedef _Typedef)9864 dvTypedef dvTypedefGetNextModuleTypedef(
9865 dvTypedef _Typedef)
9866 {
9867 return dvTypedefs.NextModuleTypedef[dvTypedef2Index(_Typedef)];
9868 }
9869
9870 #undef dvTypedefSetNextModuleTypedef
dvTypedefSetNextModuleTypedef(dvTypedef _Typedef,dvTypedef value)9871 void dvTypedefSetNextModuleTypedef(
9872 dvTypedef _Typedef,
9873 dvTypedef value)
9874 {
9875 dvTypedefs.NextModuleTypedef[dvTypedef2Index(_Typedef)] = value;
9876 }
9877
9878 #undef dvTypedefGetPrevModuleTypedef
dvTypedefGetPrevModuleTypedef(dvTypedef _Typedef)9879 dvTypedef dvTypedefGetPrevModuleTypedef(
9880 dvTypedef _Typedef)
9881 {
9882 return dvTypedefs.PrevModuleTypedef[dvTypedef2Index(_Typedef)];
9883 }
9884
9885 #undef dvTypedefSetPrevModuleTypedef
dvTypedefSetPrevModuleTypedef(dvTypedef _Typedef,dvTypedef value)9886 void dvTypedefSetPrevModuleTypedef(
9887 dvTypedef _Typedef,
9888 dvTypedef value)
9889 {
9890 dvTypedefs.PrevModuleTypedef[dvTypedef2Index(_Typedef)] = value;
9891 }
9892
9893 #undef dvTypedefGetNextTableModuleTypedef
dvTypedefGetNextTableModuleTypedef(dvTypedef _Typedef)9894 dvTypedef dvTypedefGetNextTableModuleTypedef(
9895 dvTypedef _Typedef)
9896 {
9897 return dvTypedefs.NextTableModuleTypedef[dvTypedef2Index(_Typedef)];
9898 }
9899
9900 #undef dvTypedefSetNextTableModuleTypedef
dvTypedefSetNextTableModuleTypedef(dvTypedef _Typedef,dvTypedef value)9901 void dvTypedefSetNextTableModuleTypedef(
9902 dvTypedef _Typedef,
9903 dvTypedef value)
9904 {
9905 dvTypedefs.NextTableModuleTypedef[dvTypedef2Index(_Typedef)] = value;
9906 }
9907
9908 #undef dvClassGetSym
dvClassGetSym(dvClass _Class)9909 utSym dvClassGetSym(
9910 dvClass _Class)
9911 {
9912 return dvClasss.Sym[dvClass2Index(_Class)];
9913 }
9914
9915 #undef dvClassSetSym
dvClassSetSym(dvClass _Class,utSym value)9916 void dvClassSetSym(
9917 dvClass _Class,
9918 utSym value)
9919 {
9920 dvClasss.Sym[dvClass2Index(_Class)] = value;
9921 }
9922
9923 #undef dvClassGetMemoryStyle
dvClassGetMemoryStyle(dvClass _Class)9924 dvMemoryStyle dvClassGetMemoryStyle(
9925 dvClass _Class)
9926 {
9927 return dvClasss.MemoryStyle[dvClass2Index(_Class)];
9928 }
9929
9930 #undef dvClassSetMemoryStyle
dvClassSetMemoryStyle(dvClass _Class,dvMemoryStyle value)9931 void dvClassSetMemoryStyle(
9932 dvClass _Class,
9933 dvMemoryStyle value)
9934 {
9935 dvClasss.MemoryStyle[dvClass2Index(_Class)] = value;
9936 }
9937
9938 #undef dvClassGetReferenceSize
dvClassGetReferenceSize(dvClass _Class)9939 uint8 dvClassGetReferenceSize(
9940 dvClass _Class)
9941 {
9942 return dvClasss.ReferenceSize[dvClass2Index(_Class)];
9943 }
9944
9945 #undef dvClassSetReferenceSize
dvClassSetReferenceSize(dvClass _Class,uint8 value)9946 void dvClassSetReferenceSize(
9947 dvClass _Class,
9948 uint8 value)
9949 {
9950 dvClasss.ReferenceSize[dvClass2Index(_Class)] = value;
9951 }
9952
9953 #undef dvClassGenerateArrayClass
dvClassGenerateArrayClass(dvClass _Class)9954 bool dvClassGenerateArrayClass(
9955 dvClass _Class)
9956 {
9957 return (dvClasss.GenerateArrayClass[dvClass2Index(_Class) >> 3] >> (dvClass2Index(_Class) & 7)) & 1;
9958 }
9959
9960 #undef dvClassSetGenerateArrayClass
dvClassSetGenerateArrayClass(dvClass _Class,bool value)9961 void dvClassSetGenerateArrayClass(
9962 dvClass _Class,
9963 bool value)
9964 {
9965 uint32 xClass = dvClass2Index(_Class);
9966
9967 dvClasss.GenerateArrayClass[xClass >> 3] = (dvClasss.GenerateArrayClass[xClass >> 3] & ~(1 << (xClass & 7))) |
9968 ((value != 0) << (xClass & 7));
9969 }
9970
9971 #undef dvClassGenerateAttributes
dvClassGenerateAttributes(dvClass _Class)9972 bool dvClassGenerateAttributes(
9973 dvClass _Class)
9974 {
9975 return (dvClasss.GenerateAttributes[dvClass2Index(_Class) >> 3] >> (dvClass2Index(_Class) & 7)) & 1;
9976 }
9977
9978 #undef dvClassSetGenerateAttributes
dvClassSetGenerateAttributes(dvClass _Class,bool value)9979 void dvClassSetGenerateAttributes(
9980 dvClass _Class,
9981 bool value)
9982 {
9983 uint32 xClass = dvClass2Index(_Class);
9984
9985 dvClasss.GenerateAttributes[xClass >> 3] = (dvClasss.GenerateAttributes[xClass >> 3] & ~(1 << (xClass & 7))) |
9986 ((value != 0) << (xClass & 7));
9987 }
9988
9989 #undef dvClassSparse
dvClassSparse(dvClass _Class)9990 bool dvClassSparse(
9991 dvClass _Class)
9992 {
9993 return (dvClasss.Sparse[dvClass2Index(_Class) >> 3] >> (dvClass2Index(_Class) & 7)) & 1;
9994 }
9995
9996 #undef dvClassSetSparse
dvClassSetSparse(dvClass _Class,bool value)9997 void dvClassSetSparse(
9998 dvClass _Class,
9999 bool value)
10000 {
10001 uint32 xClass = dvClass2Index(_Class);
10002
10003 dvClasss.Sparse[xClass >> 3] = (dvClasss.Sparse[xClass >> 3] & ~(1 << (xClass & 7))) |
10004 ((value != 0) << (xClass & 7));
10005 }
10006
10007 #undef dvClassGetNumFields
dvClassGetNumFields(dvClass _Class)10008 uint16 dvClassGetNumFields(
10009 dvClass _Class)
10010 {
10011 return dvClasss.NumFields[dvClass2Index(_Class)];
10012 }
10013
10014 #undef dvClassSetNumFields
dvClassSetNumFields(dvClass _Class,uint16 value)10015 void dvClassSetNumFields(
10016 dvClass _Class,
10017 uint16 value)
10018 {
10019 dvClasss.NumFields[dvClass2Index(_Class)] = value;
10020 }
10021
10022 #undef dvClassGetNumber
dvClassGetNumber(dvClass _Class)10023 uint16 dvClassGetNumber(
10024 dvClass _Class)
10025 {
10026 return dvClasss.Number[dvClass2Index(_Class)];
10027 }
10028
10029 #undef dvClassSetNumber
dvClassSetNumber(dvClass _Class,uint16 value)10030 void dvClassSetNumber(
10031 dvClass _Class,
10032 uint16 value)
10033 {
10034 dvClasss.Number[dvClass2Index(_Class)] = value;
10035 }
10036
10037 #undef dvClassGetModule
dvClassGetModule(dvClass _Class)10038 dvModule dvClassGetModule(
10039 dvClass _Class)
10040 {
10041 return dvClasss.Module[dvClass2Index(_Class)];
10042 }
10043
10044 #undef dvClassSetModule
dvClassSetModule(dvClass _Class,dvModule value)10045 void dvClassSetModule(
10046 dvClass _Class,
10047 dvModule value)
10048 {
10049 dvClasss.Module[dvClass2Index(_Class)] = value;
10050 }
10051
10052 #undef dvClassGetNextModuleClass
dvClassGetNextModuleClass(dvClass _Class)10053 dvClass dvClassGetNextModuleClass(
10054 dvClass _Class)
10055 {
10056 return dvClasss.NextModuleClass[dvClass2Index(_Class)];
10057 }
10058
10059 #undef dvClassSetNextModuleClass
dvClassSetNextModuleClass(dvClass _Class,dvClass value)10060 void dvClassSetNextModuleClass(
10061 dvClass _Class,
10062 dvClass value)
10063 {
10064 dvClasss.NextModuleClass[dvClass2Index(_Class)] = value;
10065 }
10066
10067 #undef dvClassGetPrevModuleClass
dvClassGetPrevModuleClass(dvClass _Class)10068 dvClass dvClassGetPrevModuleClass(
10069 dvClass _Class)
10070 {
10071 return dvClasss.PrevModuleClass[dvClass2Index(_Class)];
10072 }
10073
10074 #undef dvClassSetPrevModuleClass
dvClassSetPrevModuleClass(dvClass _Class,dvClass value)10075 void dvClassSetPrevModuleClass(
10076 dvClass _Class,
10077 dvClass value)
10078 {
10079 dvClasss.PrevModuleClass[dvClass2Index(_Class)] = value;
10080 }
10081
10082 #undef dvClassGetNextTableModuleClass
dvClassGetNextTableModuleClass(dvClass _Class)10083 dvClass dvClassGetNextTableModuleClass(
10084 dvClass _Class)
10085 {
10086 return dvClasss.NextTableModuleClass[dvClass2Index(_Class)];
10087 }
10088
10089 #undef dvClassSetNextTableModuleClass
dvClassSetNextTableModuleClass(dvClass _Class,dvClass value)10090 void dvClassSetNextTableModuleClass(
10091 dvClass _Class,
10092 dvClass value)
10093 {
10094 dvClasss.NextTableModuleClass[dvClass2Index(_Class)] = value;
10095 }
10096
10097 #undef dvClassGetFirstProperty
dvClassGetFirstProperty(dvClass _Class)10098 dvProperty dvClassGetFirstProperty(
10099 dvClass _Class)
10100 {
10101 return dvClasss.FirstProperty[dvClass2Index(_Class)];
10102 }
10103
10104 #undef dvClassSetFirstProperty
dvClassSetFirstProperty(dvClass _Class,dvProperty value)10105 void dvClassSetFirstProperty(
10106 dvClass _Class,
10107 dvProperty value)
10108 {
10109 dvClasss.FirstProperty[dvClass2Index(_Class)] = value;
10110 }
10111
10112 #undef dvClassGetLastProperty
dvClassGetLastProperty(dvClass _Class)10113 dvProperty dvClassGetLastProperty(
10114 dvClass _Class)
10115 {
10116 return dvClasss.LastProperty[dvClass2Index(_Class)];
10117 }
10118
10119 #undef dvClassSetLastProperty
dvClassSetLastProperty(dvClass _Class,dvProperty value)10120 void dvClassSetLastProperty(
10121 dvClass _Class,
10122 dvProperty value)
10123 {
10124 dvClasss.LastProperty[dvClass2Index(_Class)] = value;
10125 }
10126
10127 #undef dvClassGetPropertyTableIndex
dvClassGetPropertyTableIndex(dvClass _Class)10128 uint32 dvClassGetPropertyTableIndex(
10129 dvClass _Class)
10130 {
10131 return dvClasss.PropertyTableIndex[dvClass2Index(_Class)];
10132 }
10133
10134 #undef dvClassSetPropertyTableIndex
dvClassSetPropertyTableIndex(dvClass _Class,uint32 value)10135 void dvClassSetPropertyTableIndex(
10136 dvClass _Class,
10137 uint32 value)
10138 {
10139 dvClasss.PropertyTableIndex[dvClass2Index(_Class)] = value;
10140 }
10141
10142 #undef dvClassGetNumPropertyTable
dvClassGetNumPropertyTable(dvClass _Class)10143 uint32 dvClassGetNumPropertyTable(
10144 dvClass _Class)
10145 {
10146 return dvClasss.NumPropertyTable[dvClass2Index(_Class)];
10147 }
10148
10149 #undef dvClassSetNumPropertyTable
dvClassSetNumPropertyTable(dvClass _Class,uint32 value)10150 void dvClassSetNumPropertyTable(
10151 dvClass _Class,
10152 uint32 value)
10153 {
10154 dvClasss.NumPropertyTable[dvClass2Index(_Class)] = value;
10155 }
10156
10157 #undef dvClassGetiPropertyTable
dvClassGetiPropertyTable(dvClass _Class,uint32 x)10158 dvProperty dvClassGetiPropertyTable(
10159 dvClass _Class,
10160 uint32 x)
10161 {
10162 return (dvClasss.PropertyTable)[dvClassGetPropertyTableIndex(_Class) + x];
10163 }
10164
10165 #undef dvClassSetiPropertyTable
dvClassSetiPropertyTable(dvClass Class,uint32 x,dvProperty value)10166 void dvClassSetiPropertyTable(
10167 dvClass Class,
10168 uint32 x,
10169 dvProperty value)
10170 {
10171 dvClasss.PropertyTable[dvClassGetPropertyTableIndex(Class) + x] = value;
10172 }
10173
10174 #undef dvClassGetPropertyTable
dvClassGetPropertyTable(dvClass Class)10175 dvProperty *dvClassGetPropertyTable(
10176 dvClass Class)
10177 {
10178 return dvClasss.PropertyTable + dvClassGetPropertyTableIndex(Class);
10179 }
10180
10181 #undef dvClassGetNumProperty
dvClassGetNumProperty(dvClass _Class)10182 uint32 dvClassGetNumProperty(
10183 dvClass _Class)
10184 {
10185 return dvClasss.NumProperty[dvClass2Index(_Class)];
10186 }
10187
10188 #undef dvClassSetNumProperty
dvClassSetNumProperty(dvClass _Class,uint32 value)10189 void dvClassSetNumProperty(
10190 dvClass _Class,
10191 uint32 value)
10192 {
10193 dvClasss.NumProperty[dvClass2Index(_Class)] = value;
10194 }
10195
10196 #undef dvClassGetFreeListProperty
dvClassGetFreeListProperty(dvClass _Class)10197 dvProperty dvClassGetFreeListProperty(
10198 dvClass _Class)
10199 {
10200 return dvClasss.FreeListProperty[dvClass2Index(_Class)];
10201 }
10202
10203 #undef dvClassSetFreeListProperty
dvClassSetFreeListProperty(dvClass _Class,dvProperty value)10204 void dvClassSetFreeListProperty(
10205 dvClass _Class,
10206 dvProperty value)
10207 {
10208 dvClasss.FreeListProperty[dvClass2Index(_Class)] = value;
10209 }
10210
10211 #undef dvClassGetFirstSparsegroup
dvClassGetFirstSparsegroup(dvClass _Class)10212 dvSparsegroup dvClassGetFirstSparsegroup(
10213 dvClass _Class)
10214 {
10215 return dvClasss.FirstSparsegroup[dvClass2Index(_Class)];
10216 }
10217
10218 #undef dvClassSetFirstSparsegroup
dvClassSetFirstSparsegroup(dvClass _Class,dvSparsegroup value)10219 void dvClassSetFirstSparsegroup(
10220 dvClass _Class,
10221 dvSparsegroup value)
10222 {
10223 dvClasss.FirstSparsegroup[dvClass2Index(_Class)] = value;
10224 }
10225
10226 #undef dvClassGetLastSparsegroup
dvClassGetLastSparsegroup(dvClass _Class)10227 dvSparsegroup dvClassGetLastSparsegroup(
10228 dvClass _Class)
10229 {
10230 return dvClasss.LastSparsegroup[dvClass2Index(_Class)];
10231 }
10232
10233 #undef dvClassSetLastSparsegroup
dvClassSetLastSparsegroup(dvClass _Class,dvSparsegroup value)10234 void dvClassSetLastSparsegroup(
10235 dvClass _Class,
10236 dvSparsegroup value)
10237 {
10238 dvClasss.LastSparsegroup[dvClass2Index(_Class)] = value;
10239 }
10240
10241 #undef dvClassGetSparsegroupTableIndex
dvClassGetSparsegroupTableIndex(dvClass _Class)10242 uint32 dvClassGetSparsegroupTableIndex(
10243 dvClass _Class)
10244 {
10245 return dvClasss.SparsegroupTableIndex[dvClass2Index(_Class)];
10246 }
10247
10248 #undef dvClassSetSparsegroupTableIndex
dvClassSetSparsegroupTableIndex(dvClass _Class,uint32 value)10249 void dvClassSetSparsegroupTableIndex(
10250 dvClass _Class,
10251 uint32 value)
10252 {
10253 dvClasss.SparsegroupTableIndex[dvClass2Index(_Class)] = value;
10254 }
10255
10256 #undef dvClassGetNumSparsegroupTable
dvClassGetNumSparsegroupTable(dvClass _Class)10257 uint32 dvClassGetNumSparsegroupTable(
10258 dvClass _Class)
10259 {
10260 return dvClasss.NumSparsegroupTable[dvClass2Index(_Class)];
10261 }
10262
10263 #undef dvClassSetNumSparsegroupTable
dvClassSetNumSparsegroupTable(dvClass _Class,uint32 value)10264 void dvClassSetNumSparsegroupTable(
10265 dvClass _Class,
10266 uint32 value)
10267 {
10268 dvClasss.NumSparsegroupTable[dvClass2Index(_Class)] = value;
10269 }
10270
10271 #undef dvClassGetiSparsegroupTable
dvClassGetiSparsegroupTable(dvClass _Class,uint32 x)10272 dvSparsegroup dvClassGetiSparsegroupTable(
10273 dvClass _Class,
10274 uint32 x)
10275 {
10276 return (dvClasss.SparsegroupTable)[dvClassGetSparsegroupTableIndex(_Class) + x];
10277 }
10278
10279 #undef dvClassSetiSparsegroupTable
dvClassSetiSparsegroupTable(dvClass Class,uint32 x,dvSparsegroup value)10280 void dvClassSetiSparsegroupTable(
10281 dvClass Class,
10282 uint32 x,
10283 dvSparsegroup value)
10284 {
10285 dvClasss.SparsegroupTable[dvClassGetSparsegroupTableIndex(Class) + x] = value;
10286 }
10287
10288 #undef dvClassGetSparsegroupTable
dvClassGetSparsegroupTable(dvClass Class)10289 dvSparsegroup *dvClassGetSparsegroupTable(
10290 dvClass Class)
10291 {
10292 return dvClasss.SparsegroupTable + dvClassGetSparsegroupTableIndex(Class);
10293 }
10294
10295 #undef dvClassGetNumSparsegroup
dvClassGetNumSparsegroup(dvClass _Class)10296 uint32 dvClassGetNumSparsegroup(
10297 dvClass _Class)
10298 {
10299 return dvClasss.NumSparsegroup[dvClass2Index(_Class)];
10300 }
10301
10302 #undef dvClassSetNumSparsegroup
dvClassSetNumSparsegroup(dvClass _Class,uint32 value)10303 void dvClassSetNumSparsegroup(
10304 dvClass _Class,
10305 uint32 value)
10306 {
10307 dvClasss.NumSparsegroup[dvClass2Index(_Class)] = value;
10308 }
10309
10310 #undef dvClassGetBaseClass
dvClassGetBaseClass(dvClass _Class)10311 dvClass dvClassGetBaseClass(
10312 dvClass _Class)
10313 {
10314 return dvClasss.BaseClass[dvClass2Index(_Class)];
10315 }
10316
10317 #undef dvClassSetBaseClass
dvClassSetBaseClass(dvClass _Class,dvClass value)10318 void dvClassSetBaseClass(
10319 dvClass _Class,
10320 dvClass value)
10321 {
10322 dvClasss.BaseClass[dvClass2Index(_Class)] = value;
10323 }
10324
10325 #undef dvClassGetFirstDerivedClass
dvClassGetFirstDerivedClass(dvClass _Class)10326 dvClass dvClassGetFirstDerivedClass(
10327 dvClass _Class)
10328 {
10329 return dvClasss.FirstDerivedClass[dvClass2Index(_Class)];
10330 }
10331
10332 #undef dvClassSetFirstDerivedClass
dvClassSetFirstDerivedClass(dvClass _Class,dvClass value)10333 void dvClassSetFirstDerivedClass(
10334 dvClass _Class,
10335 dvClass value)
10336 {
10337 dvClasss.FirstDerivedClass[dvClass2Index(_Class)] = value;
10338 }
10339
10340 #undef dvClassGetNextClassDerivedClass
dvClassGetNextClassDerivedClass(dvClass _Class)10341 dvClass dvClassGetNextClassDerivedClass(
10342 dvClass _Class)
10343 {
10344 return dvClasss.NextClassDerivedClass[dvClass2Index(_Class)];
10345 }
10346
10347 #undef dvClassSetNextClassDerivedClass
dvClassSetNextClassDerivedClass(dvClass _Class,dvClass value)10348 void dvClassSetNextClassDerivedClass(
10349 dvClass _Class,
10350 dvClass value)
10351 {
10352 dvClasss.NextClassDerivedClass[dvClass2Index(_Class)] = value;
10353 }
10354
10355 #undef dvClassGetLastDerivedClass
dvClassGetLastDerivedClass(dvClass _Class)10356 dvClass dvClassGetLastDerivedClass(
10357 dvClass _Class)
10358 {
10359 return dvClasss.LastDerivedClass[dvClass2Index(_Class)];
10360 }
10361
10362 #undef dvClassSetLastDerivedClass
dvClassSetLastDerivedClass(dvClass _Class,dvClass value)10363 void dvClassSetLastDerivedClass(
10364 dvClass _Class,
10365 dvClass value)
10366 {
10367 dvClasss.LastDerivedClass[dvClass2Index(_Class)] = value;
10368 }
10369
10370 #undef dvClassGetFirstChildRelationship
dvClassGetFirstChildRelationship(dvClass _Class)10371 dvRelationship dvClassGetFirstChildRelationship(
10372 dvClass _Class)
10373 {
10374 return dvClasss.FirstChildRelationship[dvClass2Index(_Class)];
10375 }
10376
10377 #undef dvClassSetFirstChildRelationship
dvClassSetFirstChildRelationship(dvClass _Class,dvRelationship value)10378 void dvClassSetFirstChildRelationship(
10379 dvClass _Class,
10380 dvRelationship value)
10381 {
10382 dvClasss.FirstChildRelationship[dvClass2Index(_Class)] = value;
10383 }
10384
10385 #undef dvClassGetLastChildRelationship
dvClassGetLastChildRelationship(dvClass _Class)10386 dvRelationship dvClassGetLastChildRelationship(
10387 dvClass _Class)
10388 {
10389 return dvClasss.LastChildRelationship[dvClass2Index(_Class)];
10390 }
10391
10392 #undef dvClassSetLastChildRelationship
dvClassSetLastChildRelationship(dvClass _Class,dvRelationship value)10393 void dvClassSetLastChildRelationship(
10394 dvClass _Class,
10395 dvRelationship value)
10396 {
10397 dvClasss.LastChildRelationship[dvClass2Index(_Class)] = value;
10398 }
10399
10400 #undef dvClassGetFirstParentRelationship
dvClassGetFirstParentRelationship(dvClass _Class)10401 dvRelationship dvClassGetFirstParentRelationship(
10402 dvClass _Class)
10403 {
10404 return dvClasss.FirstParentRelationship[dvClass2Index(_Class)];
10405 }
10406
10407 #undef dvClassSetFirstParentRelationship
dvClassSetFirstParentRelationship(dvClass _Class,dvRelationship value)10408 void dvClassSetFirstParentRelationship(
10409 dvClass _Class,
10410 dvRelationship value)
10411 {
10412 dvClasss.FirstParentRelationship[dvClass2Index(_Class)] = value;
10413 }
10414
10415 #undef dvClassGetLastParentRelationship
dvClassGetLastParentRelationship(dvClass _Class)10416 dvRelationship dvClassGetLastParentRelationship(
10417 dvClass _Class)
10418 {
10419 return dvClasss.LastParentRelationship[dvClass2Index(_Class)];
10420 }
10421
10422 #undef dvClassSetLastParentRelationship
dvClassSetLastParentRelationship(dvClass _Class,dvRelationship value)10423 void dvClassSetLastParentRelationship(
10424 dvClass _Class,
10425 dvRelationship value)
10426 {
10427 dvClasss.LastParentRelationship[dvClass2Index(_Class)] = value;
10428 }
10429
10430 #undef dvClassGetFirstUnion
dvClassGetFirstUnion(dvClass _Class)10431 dvUnion dvClassGetFirstUnion(
10432 dvClass _Class)
10433 {
10434 return dvClasss.FirstUnion[dvClass2Index(_Class)];
10435 }
10436
10437 #undef dvClassSetFirstUnion
dvClassSetFirstUnion(dvClass _Class,dvUnion value)10438 void dvClassSetFirstUnion(
10439 dvClass _Class,
10440 dvUnion value)
10441 {
10442 dvClasss.FirstUnion[dvClass2Index(_Class)] = value;
10443 }
10444
10445 #undef dvClassGetLastUnion
dvClassGetLastUnion(dvClass _Class)10446 dvUnion dvClassGetLastUnion(
10447 dvClass _Class)
10448 {
10449 return dvClasss.LastUnion[dvClass2Index(_Class)];
10450 }
10451
10452 #undef dvClassSetLastUnion
dvClassSetLastUnion(dvClass _Class,dvUnion value)10453 void dvClassSetLastUnion(
10454 dvClass _Class,
10455 dvUnion value)
10456 {
10457 dvClasss.LastUnion[dvClass2Index(_Class)] = value;
10458 }
10459
10460 #undef dvPropertyGetName
dvPropertyGetName(dvProperty Property)10461 char *dvPropertyGetName(
10462 dvProperty Property)
10463 {
10464 return utSymGetName(dvPropertyGetSym(Property));
10465 }
10466
10467 #undef dvSparsegroupGetName
dvSparsegroupGetName(dvSparsegroup Sparsegroup)10468 char *dvSparsegroupGetName(
10469 dvSparsegroup Sparsegroup)
10470 {
10471 return utSymGetName(dvSparsegroupGetSym(Sparsegroup));
10472 }
10473
10474 #undef dvPropertyGetSym
dvPropertyGetSym(dvProperty _Property)10475 utSym dvPropertyGetSym(
10476 dvProperty _Property)
10477 {
10478 return dvPropertys.Sym[dvProperty2Index(_Property)];
10479 }
10480
10481 #undef dvPropertySetSym
dvPropertySetSym(dvProperty _Property,utSym value)10482 void dvPropertySetSym(
10483 dvProperty _Property,
10484 utSym value)
10485 {
10486 dvPropertys.Sym[dvProperty2Index(_Property)] = value;
10487 }
10488
10489 #undef dvPropertyGetType
dvPropertyGetType(dvProperty _Property)10490 dvPropertyType dvPropertyGetType(
10491 dvProperty _Property)
10492 {
10493 return dvPropertys.Type[dvProperty2Index(_Property)];
10494 }
10495
10496 #undef dvPropertySetType
dvPropertySetType(dvProperty _Property,dvPropertyType value)10497 void dvPropertySetType(
10498 dvProperty _Property,
10499 dvPropertyType value)
10500 {
10501 dvPropertys.Type[dvProperty2Index(_Property)] = value;
10502 }
10503
10504 #undef dvPropertyArray
dvPropertyArray(dvProperty _Property)10505 bool dvPropertyArray(
10506 dvProperty _Property)
10507 {
10508 return (dvPropertys.Array[dvProperty2Index(_Property) >> 3] >> (dvProperty2Index(_Property) & 7)) & 1;
10509 }
10510
10511 #undef dvPropertySetArray
dvPropertySetArray(dvProperty _Property,bool value)10512 void dvPropertySetArray(
10513 dvProperty _Property,
10514 bool value)
10515 {
10516 uint32 xProperty = dvProperty2Index(_Property);
10517
10518 dvPropertys.Array[xProperty >> 3] = (dvPropertys.Array[xProperty >> 3] & ~(1 << (xProperty & 7))) |
10519 ((value != 0) << (xProperty & 7));
10520 }
10521
10522 #undef dvPropertyCascade
dvPropertyCascade(dvProperty _Property)10523 bool dvPropertyCascade(
10524 dvProperty _Property)
10525 {
10526 return (dvPropertys.Cascade[dvProperty2Index(_Property) >> 3] >> (dvProperty2Index(_Property) & 7)) & 1;
10527 }
10528
10529 #undef dvPropertySetCascade
dvPropertySetCascade(dvProperty _Property,bool value)10530 void dvPropertySetCascade(
10531 dvProperty _Property,
10532 bool value)
10533 {
10534 uint32 xProperty = dvProperty2Index(_Property);
10535
10536 dvPropertys.Cascade[xProperty >> 3] = (dvPropertys.Cascade[xProperty >> 3] & ~(1 << (xProperty & 7))) |
10537 ((value != 0) << (xProperty & 7));
10538 }
10539
10540 #undef dvPropertySparse
dvPropertySparse(dvProperty _Property)10541 bool dvPropertySparse(
10542 dvProperty _Property)
10543 {
10544 return (dvPropertys.Sparse[dvProperty2Index(_Property) >> 3] >> (dvProperty2Index(_Property) & 7)) & 1;
10545 }
10546
10547 #undef dvPropertySetSparse
dvPropertySetSparse(dvProperty _Property,bool value)10548 void dvPropertySetSparse(
10549 dvProperty _Property,
10550 bool value)
10551 {
10552 uint32 xProperty = dvProperty2Index(_Property);
10553
10554 dvPropertys.Sparse[xProperty >> 3] = (dvPropertys.Sparse[xProperty >> 3] & ~(1 << (xProperty & 7))) |
10555 ((value != 0) << (xProperty & 7));
10556 }
10557
10558 #undef dvPropertyExpanded
dvPropertyExpanded(dvProperty _Property)10559 bool dvPropertyExpanded(
10560 dvProperty _Property)
10561 {
10562 return (dvPropertys.Expanded[dvProperty2Index(_Property) >> 3] >> (dvProperty2Index(_Property) & 7)) & 1;
10563 }
10564
10565 #undef dvPropertySetExpanded
dvPropertySetExpanded(dvProperty _Property,bool value)10566 void dvPropertySetExpanded(
10567 dvProperty _Property,
10568 bool value)
10569 {
10570 uint32 xProperty = dvProperty2Index(_Property);
10571
10572 dvPropertys.Expanded[xProperty >> 3] = (dvPropertys.Expanded[xProperty >> 3] & ~(1 << (xProperty & 7))) |
10573 ((value != 0) << (xProperty & 7));
10574 }
10575
10576 #undef dvPropertyGetFieldNumber
dvPropertyGetFieldNumber(dvProperty _Property)10577 uint32 dvPropertyGetFieldNumber(
10578 dvProperty _Property)
10579 {
10580 return dvPropertys.FieldNumber[dvProperty2Index(_Property)];
10581 }
10582
10583 #undef dvPropertySetFieldNumber
dvPropertySetFieldNumber(dvProperty _Property,uint32 value)10584 void dvPropertySetFieldNumber(
10585 dvProperty _Property,
10586 uint32 value)
10587 {
10588 dvPropertys.FieldNumber[dvProperty2Index(_Property)] = value;
10589 }
10590
10591 #undef dvPropertyGetFirstElementProp
dvPropertyGetFirstElementProp(dvProperty _Property)10592 dvProperty dvPropertyGetFirstElementProp(
10593 dvProperty _Property)
10594 {
10595 return dvPropertys.FirstElementProp[dvProperty2Index(_Property)];
10596 }
10597
10598 #undef dvPropertySetFirstElementProp
dvPropertySetFirstElementProp(dvProperty _Property,dvProperty value)10599 void dvPropertySetFirstElementProp(
10600 dvProperty _Property,
10601 dvProperty value)
10602 {
10603 dvPropertys.FirstElementProp[dvProperty2Index(_Property)] = value;
10604 }
10605
10606 #undef dvPropertyGetNumElementsProp
dvPropertyGetNumElementsProp(dvProperty _Property)10607 dvProperty dvPropertyGetNumElementsProp(
10608 dvProperty _Property)
10609 {
10610 return dvPropertys.NumElementsProp[dvProperty2Index(_Property)];
10611 }
10612
10613 #undef dvPropertySetNumElementsProp
dvPropertySetNumElementsProp(dvProperty _Property,dvProperty value)10614 void dvPropertySetNumElementsProp(
10615 dvProperty _Property,
10616 dvProperty value)
10617 {
10618 dvPropertys.NumElementsProp[dvProperty2Index(_Property)] = value;
10619 }
10620
10621 #undef dvPropertyHidden
dvPropertyHidden(dvProperty _Property)10622 bool dvPropertyHidden(
10623 dvProperty _Property)
10624 {
10625 return (dvPropertys.Hidden[dvProperty2Index(_Property) >> 3] >> (dvProperty2Index(_Property) & 7)) & 1;
10626 }
10627
10628 #undef dvPropertySetHidden
dvPropertySetHidden(dvProperty _Property,bool value)10629 void dvPropertySetHidden(
10630 dvProperty _Property,
10631 bool value)
10632 {
10633 uint32 xProperty = dvProperty2Index(_Property);
10634
10635 dvPropertys.Hidden[xProperty >> 3] = (dvPropertys.Hidden[xProperty >> 3] & ~(1 << (xProperty & 7))) |
10636 ((value != 0) << (xProperty & 7));
10637 }
10638
10639 #undef dvPropertyGetInitializerIndex
dvPropertyGetInitializerIndex(dvProperty _Property)10640 uint32 dvPropertyGetInitializerIndex(
10641 dvProperty _Property)
10642 {
10643 return dvPropertys.InitializerIndex[dvProperty2Index(_Property)];
10644 }
10645
10646 #undef dvPropertySetInitializerIndex
dvPropertySetInitializerIndex(dvProperty _Property,uint32 value)10647 void dvPropertySetInitializerIndex(
10648 dvProperty _Property,
10649 uint32 value)
10650 {
10651 dvPropertys.InitializerIndex[dvProperty2Index(_Property)] = value;
10652 }
10653
10654 #undef dvPropertyGetNumInitializer
dvPropertyGetNumInitializer(dvProperty _Property)10655 uint32 dvPropertyGetNumInitializer(
10656 dvProperty _Property)
10657 {
10658 return dvPropertys.NumInitializer[dvProperty2Index(_Property)];
10659 }
10660
10661 #undef dvPropertySetNumInitializer
dvPropertySetNumInitializer(dvProperty _Property,uint32 value)10662 void dvPropertySetNumInitializer(
10663 dvProperty _Property,
10664 uint32 value)
10665 {
10666 dvPropertys.NumInitializer[dvProperty2Index(_Property)] = value;
10667 }
10668
10669 #undef dvPropertyGetiInitializer
dvPropertyGetiInitializer(dvProperty _Property,uint32 x)10670 char dvPropertyGetiInitializer(
10671 dvProperty _Property,
10672 uint32 x)
10673 {
10674 return (dvPropertys.Initializer)[dvPropertyGetInitializerIndex(_Property) + x];
10675 }
10676
10677 #undef dvPropertySetiInitializer
dvPropertySetiInitializer(dvProperty Property,uint32 x,char value)10678 void dvPropertySetiInitializer(
10679 dvProperty Property,
10680 uint32 x,
10681 char value)
10682 {
10683 dvPropertys.Initializer[dvPropertyGetInitializerIndex(Property) + x] = value;
10684 }
10685
10686 #undef dvPropertyGetInitializer
dvPropertyGetInitializer(dvProperty Property)10687 char *dvPropertyGetInitializer(
10688 dvProperty Property)
10689 {
10690 return dvPropertys.Initializer + dvPropertyGetInitializerIndex(Property);
10691 }
10692
10693 #undef dvPropertyFixedSize
dvPropertyFixedSize(dvProperty _Property)10694 bool dvPropertyFixedSize(
10695 dvProperty _Property)
10696 {
10697 return (dvPropertys.FixedSize[dvProperty2Index(_Property) >> 3] >> (dvProperty2Index(_Property) & 7)) & 1;
10698 }
10699
10700 #undef dvPropertySetFixedSize
dvPropertySetFixedSize(dvProperty _Property,bool value)10701 void dvPropertySetFixedSize(
10702 dvProperty _Property,
10703 bool value)
10704 {
10705 uint32 xProperty = dvProperty2Index(_Property);
10706
10707 dvPropertys.FixedSize[xProperty >> 3] = (dvPropertys.FixedSize[xProperty >> 3] & ~(1 << (xProperty & 7))) |
10708 ((value != 0) << (xProperty & 7));
10709 }
10710
10711 #undef dvPropertyGetIndexIndex
dvPropertyGetIndexIndex(dvProperty _Property)10712 uint32 dvPropertyGetIndexIndex(
10713 dvProperty _Property)
10714 {
10715 return dvPropertys.IndexIndex[dvProperty2Index(_Property)];
10716 }
10717
10718 #undef dvPropertySetIndexIndex
dvPropertySetIndexIndex(dvProperty _Property,uint32 value)10719 void dvPropertySetIndexIndex(
10720 dvProperty _Property,
10721 uint32 value)
10722 {
10723 dvPropertys.IndexIndex[dvProperty2Index(_Property)] = value;
10724 }
10725
10726 #undef dvPropertyGetNumIndex
dvPropertyGetNumIndex(dvProperty _Property)10727 uint32 dvPropertyGetNumIndex(
10728 dvProperty _Property)
10729 {
10730 return dvPropertys.NumIndex[dvProperty2Index(_Property)];
10731 }
10732
10733 #undef dvPropertySetNumIndex
dvPropertySetNumIndex(dvProperty _Property,uint32 value)10734 void dvPropertySetNumIndex(
10735 dvProperty _Property,
10736 uint32 value)
10737 {
10738 dvPropertys.NumIndex[dvProperty2Index(_Property)] = value;
10739 }
10740
10741 #undef dvPropertyGetiIndex
dvPropertyGetiIndex(dvProperty _Property,uint32 x)10742 char dvPropertyGetiIndex(
10743 dvProperty _Property,
10744 uint32 x)
10745 {
10746 return (dvPropertys.Index)[dvPropertyGetIndexIndex(_Property) + x];
10747 }
10748
10749 #undef dvPropertySetiIndex
dvPropertySetiIndex(dvProperty Property,uint32 x,char value)10750 void dvPropertySetiIndex(
10751 dvProperty Property,
10752 uint32 x,
10753 char value)
10754 {
10755 dvPropertys.Index[dvPropertyGetIndexIndex(Property) + x] = value;
10756 }
10757
10758 #undef dvPropertyGetIndex
dvPropertyGetIndex(dvProperty Property)10759 char *dvPropertyGetIndex(
10760 dvProperty Property)
10761 {
10762 return dvPropertys.Index + dvPropertyGetIndexIndex(Property);
10763 }
10764
10765 #undef dvPropertyGetEnumProp
dvPropertyGetEnumProp(dvProperty _Property)10766 dvEnum dvPropertyGetEnumProp(
10767 dvProperty _Property)
10768 {
10769 return dvPropertys.union1[dvProperty2Index(_Property)].EnumProp;
10770 }
10771
10772 #undef dvPropertySetEnumProp
dvPropertySetEnumProp(dvProperty _Property,dvEnum value)10773 void dvPropertySetEnumProp(
10774 dvProperty _Property,
10775 dvEnum value)
10776 {
10777 dvPropertys.union1[dvProperty2Index(_Property)].EnumProp = value;
10778 }
10779
10780 #undef dvPropertyGetTypedefProp
dvPropertyGetTypedefProp(dvProperty _Property)10781 dvTypedef dvPropertyGetTypedefProp(
10782 dvProperty _Property)
10783 {
10784 return dvPropertys.union1[dvProperty2Index(_Property)].TypedefProp;
10785 }
10786
10787 #undef dvPropertySetTypedefProp
dvPropertySetTypedefProp(dvProperty _Property,dvTypedef value)10788 void dvPropertySetTypedefProp(
10789 dvProperty _Property,
10790 dvTypedef value)
10791 {
10792 dvPropertys.union1[dvProperty2Index(_Property)].TypedefProp = value;
10793 }
10794
10795 #undef dvPropertyGetClassProp
dvPropertyGetClassProp(dvProperty _Property)10796 dvClass dvPropertyGetClassProp(
10797 dvProperty _Property)
10798 {
10799 return dvPropertys.union1[dvProperty2Index(_Property)].ClassProp;
10800 }
10801
10802 #undef dvPropertySetClassProp
dvPropertySetClassProp(dvProperty _Property,dvClass value)10803 void dvPropertySetClassProp(
10804 dvProperty _Property,
10805 dvClass value)
10806 {
10807 dvPropertys.union1[dvProperty2Index(_Property)].ClassProp = value;
10808 }
10809
10810 #undef dvPropertyGetTypeSym
dvPropertyGetTypeSym(dvProperty _Property)10811 utSym dvPropertyGetTypeSym(
10812 dvProperty _Property)
10813 {
10814 return dvPropertys.union1[dvProperty2Index(_Property)].TypeSym;
10815 }
10816
10817 #undef dvPropertySetTypeSym
dvPropertySetTypeSym(dvProperty _Property,utSym value)10818 void dvPropertySetTypeSym(
10819 dvProperty _Property,
10820 utSym value)
10821 {
10822 dvPropertys.union1[dvProperty2Index(_Property)].TypeSym = value;
10823 }
10824
10825 #undef dvPropertyGetWidth
dvPropertyGetWidth(dvProperty _Property)10826 uint8 dvPropertyGetWidth(
10827 dvProperty _Property)
10828 {
10829 return dvPropertys.union1[dvProperty2Index(_Property)].Width;
10830 }
10831
10832 #undef dvPropertySetWidth
dvPropertySetWidth(dvProperty _Property,uint8 value)10833 void dvPropertySetWidth(
10834 dvProperty _Property,
10835 uint8 value)
10836 {
10837 dvPropertys.union1[dvProperty2Index(_Property)].Width = value;
10838 }
10839
10840 #undef dvPropertyGetLine
dvPropertyGetLine(dvProperty _Property)10841 uint32 dvPropertyGetLine(
10842 dvProperty _Property)
10843 {
10844 return dvPropertys.Line[dvProperty2Index(_Property)];
10845 }
10846
10847 #undef dvPropertySetLine
dvPropertySetLine(dvProperty _Property,uint32 value)10848 void dvPropertySetLine(
10849 dvProperty _Property,
10850 uint32 value)
10851 {
10852 dvPropertys.Line[dvProperty2Index(_Property)] = value;
10853 }
10854
10855 #undef dvPropertyGetClass
dvPropertyGetClass(dvProperty _Property)10856 dvClass dvPropertyGetClass(
10857 dvProperty _Property)
10858 {
10859 return dvPropertys.Class[dvProperty2Index(_Property)];
10860 }
10861
10862 #undef dvPropertySetClass
dvPropertySetClass(dvProperty _Property,dvClass value)10863 void dvPropertySetClass(
10864 dvProperty _Property,
10865 dvClass value)
10866 {
10867 dvPropertys.Class[dvProperty2Index(_Property)] = value;
10868 }
10869
10870 #undef dvPropertyGetNextClassProperty
dvPropertyGetNextClassProperty(dvProperty _Property)10871 dvProperty dvPropertyGetNextClassProperty(
10872 dvProperty _Property)
10873 {
10874 return dvPropertys.NextClassProperty[dvProperty2Index(_Property)];
10875 }
10876
10877 #undef dvPropertySetNextClassProperty
dvPropertySetNextClassProperty(dvProperty _Property,dvProperty value)10878 void dvPropertySetNextClassProperty(
10879 dvProperty _Property,
10880 dvProperty value)
10881 {
10882 dvPropertys.NextClassProperty[dvProperty2Index(_Property)] = value;
10883 }
10884
10885 #undef dvPropertyGetPrevClassProperty
dvPropertyGetPrevClassProperty(dvProperty _Property)10886 dvProperty dvPropertyGetPrevClassProperty(
10887 dvProperty _Property)
10888 {
10889 return dvPropertys.PrevClassProperty[dvProperty2Index(_Property)];
10890 }
10891
10892 #undef dvPropertySetPrevClassProperty
dvPropertySetPrevClassProperty(dvProperty _Property,dvProperty value)10893 void dvPropertySetPrevClassProperty(
10894 dvProperty _Property,
10895 dvProperty value)
10896 {
10897 dvPropertys.PrevClassProperty[dvProperty2Index(_Property)] = value;
10898 }
10899
10900 #undef dvPropertyGetNextTableClassProperty
dvPropertyGetNextTableClassProperty(dvProperty _Property)10901 dvProperty dvPropertyGetNextTableClassProperty(
10902 dvProperty _Property)
10903 {
10904 return dvPropertys.NextTableClassProperty[dvProperty2Index(_Property)];
10905 }
10906
10907 #undef dvPropertySetNextTableClassProperty
dvPropertySetNextTableClassProperty(dvProperty _Property,dvProperty value)10908 void dvPropertySetNextTableClassProperty(
10909 dvProperty _Property,
10910 dvProperty value)
10911 {
10912 dvPropertys.NextTableClassProperty[dvProperty2Index(_Property)] = value;
10913 }
10914
10915 #undef dvPropertyGetFirstCase
dvPropertyGetFirstCase(dvProperty _Property)10916 dvCase dvPropertyGetFirstCase(
10917 dvProperty _Property)
10918 {
10919 return dvPropertys.FirstCase[dvProperty2Index(_Property)];
10920 }
10921
10922 #undef dvPropertySetFirstCase
dvPropertySetFirstCase(dvProperty _Property,dvCase value)10923 void dvPropertySetFirstCase(
10924 dvProperty _Property,
10925 dvCase value)
10926 {
10927 dvPropertys.FirstCase[dvProperty2Index(_Property)] = value;
10928 }
10929
10930 #undef dvPropertyGetLastCase
dvPropertyGetLastCase(dvProperty _Property)10931 dvCase dvPropertyGetLastCase(
10932 dvProperty _Property)
10933 {
10934 return dvPropertys.LastCase[dvProperty2Index(_Property)];
10935 }
10936
10937 #undef dvPropertySetLastCase
dvPropertySetLastCase(dvProperty _Property,dvCase value)10938 void dvPropertySetLastCase(
10939 dvProperty _Property,
10940 dvCase value)
10941 {
10942 dvPropertys.LastCase[dvProperty2Index(_Property)] = value;
10943 }
10944
10945 #undef dvPropertyGetFirstKey
dvPropertyGetFirstKey(dvProperty _Property)10946 dvKey dvPropertyGetFirstKey(
10947 dvProperty _Property)
10948 {
10949 return dvPropertys.FirstKey[dvProperty2Index(_Property)];
10950 }
10951
10952 #undef dvPropertySetFirstKey
dvPropertySetFirstKey(dvProperty _Property,dvKey value)10953 void dvPropertySetFirstKey(
10954 dvProperty _Property,
10955 dvKey value)
10956 {
10957 dvPropertys.FirstKey[dvProperty2Index(_Property)] = value;
10958 }
10959
10960 #undef dvPropertyGetLastKey
dvPropertyGetLastKey(dvProperty _Property)10961 dvKey dvPropertyGetLastKey(
10962 dvProperty _Property)
10963 {
10964 return dvPropertys.LastKey[dvProperty2Index(_Property)];
10965 }
10966
10967 #undef dvPropertySetLastKey
dvPropertySetLastKey(dvProperty _Property,dvKey value)10968 void dvPropertySetLastKey(
10969 dvProperty _Property,
10970 dvKey value)
10971 {
10972 dvPropertys.LastKey[dvProperty2Index(_Property)] = value;
10973 }
10974
10975 #undef dvPropertyGetSparsegroup
dvPropertyGetSparsegroup(dvProperty _Property)10976 dvSparsegroup dvPropertyGetSparsegroup(
10977 dvProperty _Property)
10978 {
10979 return dvPropertys.Sparsegroup[dvProperty2Index(_Property)];
10980 }
10981
10982 #undef dvPropertySetSparsegroup
dvPropertySetSparsegroup(dvProperty _Property,dvSparsegroup value)10983 void dvPropertySetSparsegroup(
10984 dvProperty _Property,
10985 dvSparsegroup value)
10986 {
10987 dvPropertys.Sparsegroup[dvProperty2Index(_Property)] = value;
10988 }
10989
10990 #undef dvPropertyGetNextSparsegroupProperty
dvPropertyGetNextSparsegroupProperty(dvProperty _Property)10991 dvProperty dvPropertyGetNextSparsegroupProperty(
10992 dvProperty _Property)
10993 {
10994 return dvPropertys.NextSparsegroupProperty[dvProperty2Index(_Property)];
10995 }
10996
10997 #undef dvPropertySetNextSparsegroupProperty
dvPropertySetNextSparsegroupProperty(dvProperty _Property,dvProperty value)10998 void dvPropertySetNextSparsegroupProperty(
10999 dvProperty _Property,
11000 dvProperty value)
11001 {
11002 dvPropertys.NextSparsegroupProperty[dvProperty2Index(_Property)] = value;
11003 }
11004
11005 #undef dvPropertyGetRelationship
dvPropertyGetRelationship(dvProperty _Property)11006 dvRelationship dvPropertyGetRelationship(
11007 dvProperty _Property)
11008 {
11009 return dvPropertys.Relationship[dvProperty2Index(_Property)];
11010 }
11011
11012 #undef dvPropertySetRelationship
dvPropertySetRelationship(dvProperty _Property,dvRelationship value)11013 void dvPropertySetRelationship(
11014 dvProperty _Property,
11015 dvRelationship value)
11016 {
11017 dvPropertys.Relationship[dvProperty2Index(_Property)] = value;
11018 }
11019
11020 #undef dvPropertyGetNextRelationshipProperty
dvPropertyGetNextRelationshipProperty(dvProperty _Property)11021 dvProperty dvPropertyGetNextRelationshipProperty(
11022 dvProperty _Property)
11023 {
11024 return dvPropertys.NextRelationshipProperty[dvProperty2Index(_Property)];
11025 }
11026
11027 #undef dvPropertySetNextRelationshipProperty
dvPropertySetNextRelationshipProperty(dvProperty _Property,dvProperty value)11028 void dvPropertySetNextRelationshipProperty(
11029 dvProperty _Property,
11030 dvProperty value)
11031 {
11032 dvPropertys.NextRelationshipProperty[dvProperty2Index(_Property)] = value;
11033 }
11034
11035 #undef dvPropertyGetUnion
dvPropertyGetUnion(dvProperty _Property)11036 dvUnion dvPropertyGetUnion(
11037 dvProperty _Property)
11038 {
11039 return dvPropertys.Union[dvProperty2Index(_Property)];
11040 }
11041
11042 #undef dvPropertySetUnion
dvPropertySetUnion(dvProperty _Property,dvUnion value)11043 void dvPropertySetUnion(
11044 dvProperty _Property,
11045 dvUnion value)
11046 {
11047 dvPropertys.Union[dvProperty2Index(_Property)] = value;
11048 }
11049
11050 #undef dvPropertyGetNextUnionProperty
dvPropertyGetNextUnionProperty(dvProperty _Property)11051 dvProperty dvPropertyGetNextUnionProperty(
11052 dvProperty _Property)
11053 {
11054 return dvPropertys.NextUnionProperty[dvProperty2Index(_Property)];
11055 }
11056
11057 #undef dvPropertySetNextUnionProperty
dvPropertySetNextUnionProperty(dvProperty _Property,dvProperty value)11058 void dvPropertySetNextUnionProperty(
11059 dvProperty _Property,
11060 dvProperty value)
11061 {
11062 dvPropertys.NextUnionProperty[dvProperty2Index(_Property)] = value;
11063 }
11064
11065 #undef dvSparsegroupGetSym
dvSparsegroupGetSym(dvSparsegroup _Sparsegroup)11066 utSym dvSparsegroupGetSym(
11067 dvSparsegroup _Sparsegroup)
11068 {
11069 return dvSparsegroups.Sym[dvSparsegroup2Index(_Sparsegroup)];
11070 }
11071
11072 #undef dvSparsegroupSetSym
dvSparsegroupSetSym(dvSparsegroup _Sparsegroup,utSym value)11073 void dvSparsegroupSetSym(
11074 dvSparsegroup _Sparsegroup,
11075 utSym value)
11076 {
11077 dvSparsegroups.Sym[dvSparsegroup2Index(_Sparsegroup)] = value;
11078 }
11079
11080 #undef dvSparsegroupGetClass
dvSparsegroupGetClass(dvSparsegroup _Sparsegroup)11081 dvClass dvSparsegroupGetClass(
11082 dvSparsegroup _Sparsegroup)
11083 {
11084 return dvSparsegroups.Class[dvSparsegroup2Index(_Sparsegroup)];
11085 }
11086
11087 #undef dvSparsegroupSetClass
dvSparsegroupSetClass(dvSparsegroup _Sparsegroup,dvClass value)11088 void dvSparsegroupSetClass(
11089 dvSparsegroup _Sparsegroup,
11090 dvClass value)
11091 {
11092 dvSparsegroups.Class[dvSparsegroup2Index(_Sparsegroup)] = value;
11093 }
11094
11095 #undef dvSparsegroupGetNextClassSparsegroup
dvSparsegroupGetNextClassSparsegroup(dvSparsegroup _Sparsegroup)11096 dvSparsegroup dvSparsegroupGetNextClassSparsegroup(
11097 dvSparsegroup _Sparsegroup)
11098 {
11099 return dvSparsegroups.NextClassSparsegroup[dvSparsegroup2Index(_Sparsegroup)];
11100 }
11101
11102 #undef dvSparsegroupSetNextClassSparsegroup
dvSparsegroupSetNextClassSparsegroup(dvSparsegroup _Sparsegroup,dvSparsegroup value)11103 void dvSparsegroupSetNextClassSparsegroup(
11104 dvSparsegroup _Sparsegroup,
11105 dvSparsegroup value)
11106 {
11107 dvSparsegroups.NextClassSparsegroup[dvSparsegroup2Index(_Sparsegroup)] = value;
11108 }
11109
11110 #undef dvSparsegroupGetPrevClassSparsegroup
dvSparsegroupGetPrevClassSparsegroup(dvSparsegroup _Sparsegroup)11111 dvSparsegroup dvSparsegroupGetPrevClassSparsegroup(
11112 dvSparsegroup _Sparsegroup)
11113 {
11114 return dvSparsegroups.PrevClassSparsegroup[dvSparsegroup2Index(_Sparsegroup)];
11115 }
11116
11117 #undef dvSparsegroupSetPrevClassSparsegroup
dvSparsegroupSetPrevClassSparsegroup(dvSparsegroup _Sparsegroup,dvSparsegroup value)11118 void dvSparsegroupSetPrevClassSparsegroup(
11119 dvSparsegroup _Sparsegroup,
11120 dvSparsegroup value)
11121 {
11122 dvSparsegroups.PrevClassSparsegroup[dvSparsegroup2Index(_Sparsegroup)] = value;
11123 }
11124
11125 #undef dvSparsegroupGetNextTableClassSparsegroup
dvSparsegroupGetNextTableClassSparsegroup(dvSparsegroup _Sparsegroup)11126 dvSparsegroup dvSparsegroupGetNextTableClassSparsegroup(
11127 dvSparsegroup _Sparsegroup)
11128 {
11129 return dvSparsegroups.NextTableClassSparsegroup[dvSparsegroup2Index(_Sparsegroup)];
11130 }
11131
11132 #undef dvSparsegroupSetNextTableClassSparsegroup
dvSparsegroupSetNextTableClassSparsegroup(dvSparsegroup _Sparsegroup,dvSparsegroup value)11133 void dvSparsegroupSetNextTableClassSparsegroup(
11134 dvSparsegroup _Sparsegroup,
11135 dvSparsegroup value)
11136 {
11137 dvSparsegroups.NextTableClassSparsegroup[dvSparsegroup2Index(_Sparsegroup)] = value;
11138 }
11139
11140 #undef dvSparsegroupGetFirstProperty
dvSparsegroupGetFirstProperty(dvSparsegroup _Sparsegroup)11141 dvProperty dvSparsegroupGetFirstProperty(
11142 dvSparsegroup _Sparsegroup)
11143 {
11144 return dvSparsegroups.FirstProperty[dvSparsegroup2Index(_Sparsegroup)];
11145 }
11146
11147 #undef dvSparsegroupSetFirstProperty
dvSparsegroupSetFirstProperty(dvSparsegroup _Sparsegroup,dvProperty value)11148 void dvSparsegroupSetFirstProperty(
11149 dvSparsegroup _Sparsegroup,
11150 dvProperty value)
11151 {
11152 dvSparsegroups.FirstProperty[dvSparsegroup2Index(_Sparsegroup)] = value;
11153 }
11154
11155 #undef dvSparsegroupGetLastProperty
dvSparsegroupGetLastProperty(dvSparsegroup _Sparsegroup)11156 dvProperty dvSparsegroupGetLastProperty(
11157 dvSparsegroup _Sparsegroup)
11158 {
11159 return dvSparsegroups.LastProperty[dvSparsegroup2Index(_Sparsegroup)];
11160 }
11161
11162 #undef dvSparsegroupSetLastProperty
dvSparsegroupSetLastProperty(dvSparsegroup _Sparsegroup,dvProperty value)11163 void dvSparsegroupSetLastProperty(
11164 dvSparsegroup _Sparsegroup,
11165 dvProperty value)
11166 {
11167 dvSparsegroups.LastProperty[dvSparsegroup2Index(_Sparsegroup)] = value;
11168 }
11169
11170 #undef dvSparsegroupGetRelationship
dvSparsegroupGetRelationship(dvSparsegroup _Sparsegroup)11171 dvRelationship dvSparsegroupGetRelationship(
11172 dvSparsegroup _Sparsegroup)
11173 {
11174 return dvSparsegroups.Relationship[dvSparsegroup2Index(_Sparsegroup)];
11175 }
11176
11177 #undef dvSparsegroupSetRelationship
dvSparsegroupSetRelationship(dvSparsegroup _Sparsegroup,dvRelationship value)11178 void dvSparsegroupSetRelationship(
11179 dvSparsegroup _Sparsegroup,
11180 dvRelationship value)
11181 {
11182 dvSparsegroups.Relationship[dvSparsegroup2Index(_Sparsegroup)] = value;
11183 }
11184
11185 #undef dvRelationshipGetType
dvRelationshipGetType(dvRelationship _Relationship)11186 dvRelationshipType dvRelationshipGetType(
11187 dvRelationship _Relationship)
11188 {
11189 return dvRelationships.Type[dvRelationship2Index(_Relationship)];
11190 }
11191
11192 #undef dvRelationshipSetType
dvRelationshipSetType(dvRelationship _Relationship,dvRelationshipType value)11193 void dvRelationshipSetType(
11194 dvRelationship _Relationship,
11195 dvRelationshipType value)
11196 {
11197 dvRelationships.Type[dvRelationship2Index(_Relationship)] = value;
11198 }
11199
11200 #undef dvRelationshipGetParentLabelSym
dvRelationshipGetParentLabelSym(dvRelationship _Relationship)11201 utSym dvRelationshipGetParentLabelSym(
11202 dvRelationship _Relationship)
11203 {
11204 return dvRelationships.ParentLabelSym[dvRelationship2Index(_Relationship)];
11205 }
11206
11207 #undef dvRelationshipSetParentLabelSym
dvRelationshipSetParentLabelSym(dvRelationship _Relationship,utSym value)11208 void dvRelationshipSetParentLabelSym(
11209 dvRelationship _Relationship,
11210 utSym value)
11211 {
11212 dvRelationships.ParentLabelSym[dvRelationship2Index(_Relationship)] = value;
11213 }
11214
11215 #undef dvRelationshipGetChildLabelSym
dvRelationshipGetChildLabelSym(dvRelationship _Relationship)11216 utSym dvRelationshipGetChildLabelSym(
11217 dvRelationship _Relationship)
11218 {
11219 return dvRelationships.ChildLabelSym[dvRelationship2Index(_Relationship)];
11220 }
11221
11222 #undef dvRelationshipSetChildLabelSym
dvRelationshipSetChildLabelSym(dvRelationship _Relationship,utSym value)11223 void dvRelationshipSetChildLabelSym(
11224 dvRelationship _Relationship,
11225 utSym value)
11226 {
11227 dvRelationships.ChildLabelSym[dvRelationship2Index(_Relationship)] = value;
11228 }
11229
11230 #undef dvRelationshipMandatory
dvRelationshipMandatory(dvRelationship _Relationship)11231 bool dvRelationshipMandatory(
11232 dvRelationship _Relationship)
11233 {
11234 return (dvRelationships.Mandatory[dvRelationship2Index(_Relationship) >> 3] >> (dvRelationship2Index(_Relationship) & 7)) & 1;
11235 }
11236
11237 #undef dvRelationshipSetMandatory
dvRelationshipSetMandatory(dvRelationship _Relationship,bool value)11238 void dvRelationshipSetMandatory(
11239 dvRelationship _Relationship,
11240 bool value)
11241 {
11242 uint32 xRelationship = dvRelationship2Index(_Relationship);
11243
11244 dvRelationships.Mandatory[xRelationship >> 3] = (dvRelationships.Mandatory[xRelationship >> 3] & ~(1 << (xRelationship & 7))) |
11245 ((value != 0) << (xRelationship & 7));
11246 }
11247
11248 #undef dvRelationshipCascade
dvRelationshipCascade(dvRelationship _Relationship)11249 bool dvRelationshipCascade(
11250 dvRelationship _Relationship)
11251 {
11252 return (dvRelationships.Cascade[dvRelationship2Index(_Relationship) >> 3] >> (dvRelationship2Index(_Relationship) & 7)) & 1;
11253 }
11254
11255 #undef dvRelationshipSetCascade
dvRelationshipSetCascade(dvRelationship _Relationship,bool value)11256 void dvRelationshipSetCascade(
11257 dvRelationship _Relationship,
11258 bool value)
11259 {
11260 uint32 xRelationship = dvRelationship2Index(_Relationship);
11261
11262 dvRelationships.Cascade[xRelationship >> 3] = (dvRelationships.Cascade[xRelationship >> 3] & ~(1 << (xRelationship & 7))) |
11263 ((value != 0) << (xRelationship & 7));
11264 }
11265
11266 #undef dvRelationshipAccessChild
dvRelationshipAccessChild(dvRelationship _Relationship)11267 bool dvRelationshipAccessChild(
11268 dvRelationship _Relationship)
11269 {
11270 return (dvRelationships.AccessChild[dvRelationship2Index(_Relationship) >> 3] >> (dvRelationship2Index(_Relationship) & 7)) & 1;
11271 }
11272
11273 #undef dvRelationshipSetAccessChild
dvRelationshipSetAccessChild(dvRelationship _Relationship,bool value)11274 void dvRelationshipSetAccessChild(
11275 dvRelationship _Relationship,
11276 bool value)
11277 {
11278 uint32 xRelationship = dvRelationship2Index(_Relationship);
11279
11280 dvRelationships.AccessChild[xRelationship >> 3] = (dvRelationships.AccessChild[xRelationship >> 3] & ~(1 << (xRelationship & 7))) |
11281 ((value != 0) << (xRelationship & 7));
11282 }
11283
11284 #undef dvRelationshipAccessParent
dvRelationshipAccessParent(dvRelationship _Relationship)11285 bool dvRelationshipAccessParent(
11286 dvRelationship _Relationship)
11287 {
11288 return (dvRelationships.AccessParent[dvRelationship2Index(_Relationship) >> 3] >> (dvRelationship2Index(_Relationship) & 7)) & 1;
11289 }
11290
11291 #undef dvRelationshipSetAccessParent
dvRelationshipSetAccessParent(dvRelationship _Relationship,bool value)11292 void dvRelationshipSetAccessParent(
11293 dvRelationship _Relationship,
11294 bool value)
11295 {
11296 uint32 xRelationship = dvRelationship2Index(_Relationship);
11297
11298 dvRelationships.AccessParent[xRelationship >> 3] = (dvRelationships.AccessParent[xRelationship >> 3] & ~(1 << (xRelationship & 7))) |
11299 ((value != 0) << (xRelationship & 7));
11300 }
11301
11302 #undef dvRelationshipSharedParent
dvRelationshipSharedParent(dvRelationship _Relationship)11303 bool dvRelationshipSharedParent(
11304 dvRelationship _Relationship)
11305 {
11306 return (dvRelationships.SharedParent[dvRelationship2Index(_Relationship) >> 3] >> (dvRelationship2Index(_Relationship) & 7)) & 1;
11307 }
11308
11309 #undef dvRelationshipSetSharedParent
dvRelationshipSetSharedParent(dvRelationship _Relationship,bool value)11310 void dvRelationshipSetSharedParent(
11311 dvRelationship _Relationship,
11312 bool value)
11313 {
11314 uint32 xRelationship = dvRelationship2Index(_Relationship);
11315
11316 dvRelationships.SharedParent[xRelationship >> 3] = (dvRelationships.SharedParent[xRelationship >> 3] & ~(1 << (xRelationship & 7))) |
11317 ((value != 0) << (xRelationship & 7));
11318 }
11319
11320 #undef dvRelationshipSparse
dvRelationshipSparse(dvRelationship _Relationship)11321 bool dvRelationshipSparse(
11322 dvRelationship _Relationship)
11323 {
11324 return (dvRelationships.Sparse[dvRelationship2Index(_Relationship) >> 3] >> (dvRelationship2Index(_Relationship) & 7)) & 1;
11325 }
11326
11327 #undef dvRelationshipSetSparse
dvRelationshipSetSparse(dvRelationship _Relationship,bool value)11328 void dvRelationshipSetSparse(
11329 dvRelationship _Relationship,
11330 bool value)
11331 {
11332 uint32 xRelationship = dvRelationship2Index(_Relationship);
11333
11334 dvRelationships.Sparse[xRelationship >> 3] = (dvRelationships.Sparse[xRelationship >> 3] & ~(1 << (xRelationship & 7))) |
11335 ((value != 0) << (xRelationship & 7));
11336 }
11337
11338 #undef dvRelationshipExpanded
dvRelationshipExpanded(dvRelationship _Relationship)11339 bool dvRelationshipExpanded(
11340 dvRelationship _Relationship)
11341 {
11342 return (dvRelationships.Expanded[dvRelationship2Index(_Relationship) >> 3] >> (dvRelationship2Index(_Relationship) & 7)) & 1;
11343 }
11344
11345 #undef dvRelationshipSetExpanded
dvRelationshipSetExpanded(dvRelationship _Relationship,bool value)11346 void dvRelationshipSetExpanded(
11347 dvRelationship _Relationship,
11348 bool value)
11349 {
11350 uint32 xRelationship = dvRelationship2Index(_Relationship);
11351
11352 dvRelationships.Expanded[xRelationship >> 3] = (dvRelationships.Expanded[xRelationship >> 3] & ~(1 << (xRelationship & 7))) |
11353 ((value != 0) << (xRelationship & 7));
11354 }
11355
11356 #undef dvRelationshipGetSchema
dvRelationshipGetSchema(dvRelationship _Relationship)11357 dvSchema dvRelationshipGetSchema(
11358 dvRelationship _Relationship)
11359 {
11360 return dvRelationships.Schema[dvRelationship2Index(_Relationship)];
11361 }
11362
11363 #undef dvRelationshipSetSchema
dvRelationshipSetSchema(dvRelationship _Relationship,dvSchema value)11364 void dvRelationshipSetSchema(
11365 dvRelationship _Relationship,
11366 dvSchema value)
11367 {
11368 dvRelationships.Schema[dvRelationship2Index(_Relationship)] = value;
11369 }
11370
11371 #undef dvRelationshipGetNextSchemaRelationship
dvRelationshipGetNextSchemaRelationship(dvRelationship _Relationship)11372 dvRelationship dvRelationshipGetNextSchemaRelationship(
11373 dvRelationship _Relationship)
11374 {
11375 return dvRelationships.NextSchemaRelationship[dvRelationship2Index(_Relationship)];
11376 }
11377
11378 #undef dvRelationshipSetNextSchemaRelationship
dvRelationshipSetNextSchemaRelationship(dvRelationship _Relationship,dvRelationship value)11379 void dvRelationshipSetNextSchemaRelationship(
11380 dvRelationship _Relationship,
11381 dvRelationship value)
11382 {
11383 dvRelationships.NextSchemaRelationship[dvRelationship2Index(_Relationship)] = value;
11384 }
11385
11386 #undef dvRelationshipGetParentClass
dvRelationshipGetParentClass(dvRelationship _Relationship)11387 dvClass dvRelationshipGetParentClass(
11388 dvRelationship _Relationship)
11389 {
11390 return dvRelationships.ParentClass[dvRelationship2Index(_Relationship)];
11391 }
11392
11393 #undef dvRelationshipSetParentClass
dvRelationshipSetParentClass(dvRelationship _Relationship,dvClass value)11394 void dvRelationshipSetParentClass(
11395 dvRelationship _Relationship,
11396 dvClass value)
11397 {
11398 dvRelationships.ParentClass[dvRelationship2Index(_Relationship)] = value;
11399 }
11400
11401 #undef dvRelationshipGetNextClassChildRelationship
dvRelationshipGetNextClassChildRelationship(dvRelationship _Relationship)11402 dvRelationship dvRelationshipGetNextClassChildRelationship(
11403 dvRelationship _Relationship)
11404 {
11405 return dvRelationships.NextClassChildRelationship[dvRelationship2Index(_Relationship)];
11406 }
11407
11408 #undef dvRelationshipSetNextClassChildRelationship
dvRelationshipSetNextClassChildRelationship(dvRelationship _Relationship,dvRelationship value)11409 void dvRelationshipSetNextClassChildRelationship(
11410 dvRelationship _Relationship,
11411 dvRelationship value)
11412 {
11413 dvRelationships.NextClassChildRelationship[dvRelationship2Index(_Relationship)] = value;
11414 }
11415
11416 #undef dvRelationshipGetChildClass
dvRelationshipGetChildClass(dvRelationship _Relationship)11417 dvClass dvRelationshipGetChildClass(
11418 dvRelationship _Relationship)
11419 {
11420 return dvRelationships.ChildClass[dvRelationship2Index(_Relationship)];
11421 }
11422
11423 #undef dvRelationshipSetChildClass
dvRelationshipSetChildClass(dvRelationship _Relationship,dvClass value)11424 void dvRelationshipSetChildClass(
11425 dvRelationship _Relationship,
11426 dvClass value)
11427 {
11428 dvRelationships.ChildClass[dvRelationship2Index(_Relationship)] = value;
11429 }
11430
11431 #undef dvRelationshipGetNextClassParentRelationship
dvRelationshipGetNextClassParentRelationship(dvRelationship _Relationship)11432 dvRelationship dvRelationshipGetNextClassParentRelationship(
11433 dvRelationship _Relationship)
11434 {
11435 return dvRelationships.NextClassParentRelationship[dvRelationship2Index(_Relationship)];
11436 }
11437
11438 #undef dvRelationshipSetNextClassParentRelationship
dvRelationshipSetNextClassParentRelationship(dvRelationship _Relationship,dvRelationship value)11439 void dvRelationshipSetNextClassParentRelationship(
11440 dvRelationship _Relationship,
11441 dvRelationship value)
11442 {
11443 dvRelationships.NextClassParentRelationship[dvRelationship2Index(_Relationship)] = value;
11444 }
11445
11446 #undef dvRelationshipGetFirstProperty
dvRelationshipGetFirstProperty(dvRelationship _Relationship)11447 dvProperty dvRelationshipGetFirstProperty(
11448 dvRelationship _Relationship)
11449 {
11450 return dvRelationships.FirstProperty[dvRelationship2Index(_Relationship)];
11451 }
11452
11453 #undef dvRelationshipSetFirstProperty
dvRelationshipSetFirstProperty(dvRelationship _Relationship,dvProperty value)11454 void dvRelationshipSetFirstProperty(
11455 dvRelationship _Relationship,
11456 dvProperty value)
11457 {
11458 dvRelationships.FirstProperty[dvRelationship2Index(_Relationship)] = value;
11459 }
11460
11461 #undef dvRelationshipGetLastProperty
dvRelationshipGetLastProperty(dvRelationship _Relationship)11462 dvProperty dvRelationshipGetLastProperty(
11463 dvRelationship _Relationship)
11464 {
11465 return dvRelationships.LastProperty[dvRelationship2Index(_Relationship)];
11466 }
11467
11468 #undef dvRelationshipSetLastProperty
dvRelationshipSetLastProperty(dvRelationship _Relationship,dvProperty value)11469 void dvRelationshipSetLastProperty(
11470 dvRelationship _Relationship,
11471 dvProperty value)
11472 {
11473 dvRelationships.LastProperty[dvRelationship2Index(_Relationship)] = value;
11474 }
11475
11476 #undef dvRelationshipGetFirstKey
dvRelationshipGetFirstKey(dvRelationship _Relationship)11477 dvKey dvRelationshipGetFirstKey(
11478 dvRelationship _Relationship)
11479 {
11480 return dvRelationships.FirstKey[dvRelationship2Index(_Relationship)];
11481 }
11482
11483 #undef dvRelationshipSetFirstKey
dvRelationshipSetFirstKey(dvRelationship _Relationship,dvKey value)11484 void dvRelationshipSetFirstKey(
11485 dvRelationship _Relationship,
11486 dvKey value)
11487 {
11488 dvRelationships.FirstKey[dvRelationship2Index(_Relationship)] = value;
11489 }
11490
11491 #undef dvRelationshipGetLastKey
dvRelationshipGetLastKey(dvRelationship _Relationship)11492 dvKey dvRelationshipGetLastKey(
11493 dvRelationship _Relationship)
11494 {
11495 return dvRelationships.LastKey[dvRelationship2Index(_Relationship)];
11496 }
11497
11498 #undef dvRelationshipSetLastKey
dvRelationshipSetLastKey(dvRelationship _Relationship,dvKey value)11499 void dvRelationshipSetLastKey(
11500 dvRelationship _Relationship,
11501 dvKey value)
11502 {
11503 dvRelationships.LastKey[dvRelationship2Index(_Relationship)] = value;
11504 }
11505
11506 #undef dvRelationshipGetParentSparsegroup
dvRelationshipGetParentSparsegroup(dvRelationship _Relationship)11507 dvSparsegroup dvRelationshipGetParentSparsegroup(
11508 dvRelationship _Relationship)
11509 {
11510 return dvRelationships.ParentSparsegroup[dvRelationship2Index(_Relationship)];
11511 }
11512
11513 #undef dvRelationshipSetParentSparsegroup
dvRelationshipSetParentSparsegroup(dvRelationship _Relationship,dvSparsegroup value)11514 void dvRelationshipSetParentSparsegroup(
11515 dvRelationship _Relationship,
11516 dvSparsegroup value)
11517 {
11518 dvRelationships.ParentSparsegroup[dvRelationship2Index(_Relationship)] = value;
11519 }
11520
11521 #undef dvRelationshipGetChildSparsegroup
dvRelationshipGetChildSparsegroup(dvRelationship _Relationship)11522 dvSparsegroup dvRelationshipGetChildSparsegroup(
11523 dvRelationship _Relationship)
11524 {
11525 return dvRelationships.ChildSparsegroup[dvRelationship2Index(_Relationship)];
11526 }
11527
11528 #undef dvRelationshipSetChildSparsegroup
dvRelationshipSetChildSparsegroup(dvRelationship _Relationship,dvSparsegroup value)11529 void dvRelationshipSetChildSparsegroup(
11530 dvRelationship _Relationship,
11531 dvSparsegroup value)
11532 {
11533 dvRelationships.ChildSparsegroup[dvRelationship2Index(_Relationship)] = value;
11534 }
11535
11536 #undef dvKeyGetPropertySym
dvKeyGetPropertySym(dvKey _Key)11537 utSym dvKeyGetPropertySym(
11538 dvKey _Key)
11539 {
11540 return dvKeys.PropertySym[dvKey2Index(_Key)];
11541 }
11542
11543 #undef dvKeySetPropertySym
dvKeySetPropertySym(dvKey _Key,utSym value)11544 void dvKeySetPropertySym(
11545 dvKey _Key,
11546 utSym value)
11547 {
11548 dvKeys.PropertySym[dvKey2Index(_Key)] = value;
11549 }
11550
11551 #undef dvKeyGetLineNum
dvKeyGetLineNum(dvKey _Key)11552 uint32 dvKeyGetLineNum(
11553 dvKey _Key)
11554 {
11555 return dvKeys.LineNum[dvKey2Index(_Key)];
11556 }
11557
11558 #undef dvKeySetLineNum
dvKeySetLineNum(dvKey _Key,uint32 value)11559 void dvKeySetLineNum(
11560 dvKey _Key,
11561 uint32 value)
11562 {
11563 dvKeys.LineNum[dvKey2Index(_Key)] = value;
11564 }
11565
11566 #undef dvKeyGetProperty
dvKeyGetProperty(dvKey _Key)11567 dvProperty dvKeyGetProperty(
11568 dvKey _Key)
11569 {
11570 return dvKeys.Property[dvKey2Index(_Key)];
11571 }
11572
11573 #undef dvKeySetProperty
dvKeySetProperty(dvKey _Key,dvProperty value)11574 void dvKeySetProperty(
11575 dvKey _Key,
11576 dvProperty value)
11577 {
11578 dvKeys.Property[dvKey2Index(_Key)] = value;
11579 }
11580
11581 #undef dvKeyGetNextPropertyKey
dvKeyGetNextPropertyKey(dvKey _Key)11582 dvKey dvKeyGetNextPropertyKey(
11583 dvKey _Key)
11584 {
11585 return dvKeys.NextPropertyKey[dvKey2Index(_Key)];
11586 }
11587
11588 #undef dvKeySetNextPropertyKey
dvKeySetNextPropertyKey(dvKey _Key,dvKey value)11589 void dvKeySetNextPropertyKey(
11590 dvKey _Key,
11591 dvKey value)
11592 {
11593 dvKeys.NextPropertyKey[dvKey2Index(_Key)] = value;
11594 }
11595
11596 #undef dvKeyGetRelationship
dvKeyGetRelationship(dvKey _Key)11597 dvRelationship dvKeyGetRelationship(
11598 dvKey _Key)
11599 {
11600 return dvKeys.Relationship[dvKey2Index(_Key)];
11601 }
11602
11603 #undef dvKeySetRelationship
dvKeySetRelationship(dvKey _Key,dvRelationship value)11604 void dvKeySetRelationship(
11605 dvKey _Key,
11606 dvRelationship value)
11607 {
11608 dvKeys.Relationship[dvKey2Index(_Key)] = value;
11609 }
11610
11611 #undef dvKeyGetNextRelationshipKey
dvKeyGetNextRelationshipKey(dvKey _Key)11612 dvKey dvKeyGetNextRelationshipKey(
11613 dvKey _Key)
11614 {
11615 return dvKeys.NextRelationshipKey[dvKey2Index(_Key)];
11616 }
11617
11618 #undef dvKeySetNextRelationshipKey
dvKeySetNextRelationshipKey(dvKey _Key,dvKey value)11619 void dvKeySetNextRelationshipKey(
11620 dvKey _Key,
11621 dvKey value)
11622 {
11623 dvKeys.NextRelationshipKey[dvKey2Index(_Key)] = value;
11624 }
11625
11626 #undef dvUnionGetPropertySym
dvUnionGetPropertySym(dvUnion _Union)11627 utSym dvUnionGetPropertySym(
11628 dvUnion _Union)
11629 {
11630 return dvUnions.PropertySym[dvUnion2Index(_Union)];
11631 }
11632
11633 #undef dvUnionSetPropertySym
dvUnionSetPropertySym(dvUnion _Union,utSym value)11634 void dvUnionSetPropertySym(
11635 dvUnion _Union,
11636 utSym value)
11637 {
11638 dvUnions.PropertySym[dvUnion2Index(_Union)] = value;
11639 }
11640
11641 #undef dvUnionGetTypeProperty
dvUnionGetTypeProperty(dvUnion _Union)11642 dvProperty dvUnionGetTypeProperty(
11643 dvUnion _Union)
11644 {
11645 return dvUnions.TypeProperty[dvUnion2Index(_Union)];
11646 }
11647
11648 #undef dvUnionSetTypeProperty
dvUnionSetTypeProperty(dvUnion _Union,dvProperty value)11649 void dvUnionSetTypeProperty(
11650 dvUnion _Union,
11651 dvProperty value)
11652 {
11653 dvUnions.TypeProperty[dvUnion2Index(_Union)] = value;
11654 }
11655
11656 #undef dvUnionGetLine
dvUnionGetLine(dvUnion _Union)11657 uint32 dvUnionGetLine(
11658 dvUnion _Union)
11659 {
11660 return dvUnions.Line[dvUnion2Index(_Union)];
11661 }
11662
11663 #undef dvUnionSetLine
dvUnionSetLine(dvUnion _Union,uint32 value)11664 void dvUnionSetLine(
11665 dvUnion _Union,
11666 uint32 value)
11667 {
11668 dvUnions.Line[dvUnion2Index(_Union)] = value;
11669 }
11670
11671 #undef dvUnionGetNumber
dvUnionGetNumber(dvUnion _Union)11672 uint16 dvUnionGetNumber(
11673 dvUnion _Union)
11674 {
11675 return dvUnions.Number[dvUnion2Index(_Union)];
11676 }
11677
11678 #undef dvUnionSetNumber
dvUnionSetNumber(dvUnion _Union,uint16 value)11679 void dvUnionSetNumber(
11680 dvUnion _Union,
11681 uint16 value)
11682 {
11683 dvUnions.Number[dvUnion2Index(_Union)] = value;
11684 }
11685
11686 #undef dvUnionGetFieldNumber
dvUnionGetFieldNumber(dvUnion _Union)11687 uint32 dvUnionGetFieldNumber(
11688 dvUnion _Union)
11689 {
11690 return dvUnions.FieldNumber[dvUnion2Index(_Union)];
11691 }
11692
11693 #undef dvUnionSetFieldNumber
dvUnionSetFieldNumber(dvUnion _Union,uint32 value)11694 void dvUnionSetFieldNumber(
11695 dvUnion _Union,
11696 uint32 value)
11697 {
11698 dvUnions.FieldNumber[dvUnion2Index(_Union)] = value;
11699 }
11700
11701 #undef dvUnionGetNumCases
dvUnionGetNumCases(dvUnion _Union)11702 uint16 dvUnionGetNumCases(
11703 dvUnion _Union)
11704 {
11705 return dvUnions.NumCases[dvUnion2Index(_Union)];
11706 }
11707
11708 #undef dvUnionSetNumCases
dvUnionSetNumCases(dvUnion _Union,uint16 value)11709 void dvUnionSetNumCases(
11710 dvUnion _Union,
11711 uint16 value)
11712 {
11713 dvUnions.NumCases[dvUnion2Index(_Union)] = value;
11714 }
11715
11716 #undef dvUnionGetClass
dvUnionGetClass(dvUnion _Union)11717 dvClass dvUnionGetClass(
11718 dvUnion _Union)
11719 {
11720 return dvUnions.Class[dvUnion2Index(_Union)];
11721 }
11722
11723 #undef dvUnionSetClass
dvUnionSetClass(dvUnion _Union,dvClass value)11724 void dvUnionSetClass(
11725 dvUnion _Union,
11726 dvClass value)
11727 {
11728 dvUnions.Class[dvUnion2Index(_Union)] = value;
11729 }
11730
11731 #undef dvUnionGetNextClassUnion
dvUnionGetNextClassUnion(dvUnion _Union)11732 dvUnion dvUnionGetNextClassUnion(
11733 dvUnion _Union)
11734 {
11735 return dvUnions.NextClassUnion[dvUnion2Index(_Union)];
11736 }
11737
11738 #undef dvUnionSetNextClassUnion
dvUnionSetNextClassUnion(dvUnion _Union,dvUnion value)11739 void dvUnionSetNextClassUnion(
11740 dvUnion _Union,
11741 dvUnion value)
11742 {
11743 dvUnions.NextClassUnion[dvUnion2Index(_Union)] = value;
11744 }
11745
11746 #undef dvUnionGetFirstProperty
dvUnionGetFirstProperty(dvUnion _Union)11747 dvProperty dvUnionGetFirstProperty(
11748 dvUnion _Union)
11749 {
11750 return dvUnions.FirstProperty[dvUnion2Index(_Union)];
11751 }
11752
11753 #undef dvUnionSetFirstProperty
dvUnionSetFirstProperty(dvUnion _Union,dvProperty value)11754 void dvUnionSetFirstProperty(
11755 dvUnion _Union,
11756 dvProperty value)
11757 {
11758 dvUnions.FirstProperty[dvUnion2Index(_Union)] = value;
11759 }
11760
11761 #undef dvUnionGetLastProperty
dvUnionGetLastProperty(dvUnion _Union)11762 dvProperty dvUnionGetLastProperty(
11763 dvUnion _Union)
11764 {
11765 return dvUnions.LastProperty[dvUnion2Index(_Union)];
11766 }
11767
11768 #undef dvUnionSetLastProperty
dvUnionSetLastProperty(dvUnion _Union,dvProperty value)11769 void dvUnionSetLastProperty(
11770 dvUnion _Union,
11771 dvProperty value)
11772 {
11773 dvUnions.LastProperty[dvUnion2Index(_Union)] = value;
11774 }
11775
11776 #undef dvCaseGetEntrySym
dvCaseGetEntrySym(dvCase _Case)11777 utSym dvCaseGetEntrySym(
11778 dvCase _Case)
11779 {
11780 return dvCases.EntrySym[dvCase2Index(_Case)];
11781 }
11782
11783 #undef dvCaseSetEntrySym
dvCaseSetEntrySym(dvCase _Case,utSym value)11784 void dvCaseSetEntrySym(
11785 dvCase _Case,
11786 utSym value)
11787 {
11788 dvCases.EntrySym[dvCase2Index(_Case)] = value;
11789 }
11790
11791 #undef dvCaseGetEntry
dvCaseGetEntry(dvCase _Case)11792 dvEntry dvCaseGetEntry(
11793 dvCase _Case)
11794 {
11795 return dvCases.Entry[dvCase2Index(_Case)];
11796 }
11797
11798 #undef dvCaseSetEntry
dvCaseSetEntry(dvCase _Case,dvEntry value)11799 void dvCaseSetEntry(
11800 dvCase _Case,
11801 dvEntry value)
11802 {
11803 dvCases.Entry[dvCase2Index(_Case)] = value;
11804 }
11805
11806 #undef dvCaseGetNextEntryCase
dvCaseGetNextEntryCase(dvCase _Case)11807 dvCase dvCaseGetNextEntryCase(
11808 dvCase _Case)
11809 {
11810 return dvCases.NextEntryCase[dvCase2Index(_Case)];
11811 }
11812
11813 #undef dvCaseSetNextEntryCase
dvCaseSetNextEntryCase(dvCase _Case,dvCase value)11814 void dvCaseSetNextEntryCase(
11815 dvCase _Case,
11816 dvCase value)
11817 {
11818 dvCases.NextEntryCase[dvCase2Index(_Case)] = value;
11819 }
11820
11821 #undef dvCaseGetProperty
dvCaseGetProperty(dvCase _Case)11822 dvProperty dvCaseGetProperty(
11823 dvCase _Case)
11824 {
11825 return dvCases.Property[dvCase2Index(_Case)];
11826 }
11827
11828 #undef dvCaseSetProperty
dvCaseSetProperty(dvCase _Case,dvProperty value)11829 void dvCaseSetProperty(
11830 dvCase _Case,
11831 dvProperty value)
11832 {
11833 dvCases.Property[dvCase2Index(_Case)] = value;
11834 }
11835
11836 #undef dvCaseGetNextPropertyCase
dvCaseGetNextPropertyCase(dvCase _Case)11837 dvCase dvCaseGetNextPropertyCase(
11838 dvCase _Case)
11839 {
11840 return dvCases.NextPropertyCase[dvCase2Index(_Case)];
11841 }
11842
11843 #undef dvCaseSetNextPropertyCase
dvCaseSetNextPropertyCase(dvCase _Case,dvCase value)11844 void dvCaseSetNextPropertyCase(
11845 dvCase _Case,
11846 dvCase value)
11847 {
11848 dvCases.NextPropertyCase[dvCase2Index(_Case)] = value;
11849 }
11850
11851 #endif
11852