Annotation of libwww/Library/src/HTBTree.c, revision 2.22
2.12 frystyk 1: /* HTBTree.c
2: ** BINARY TREE FOR SORTING THINGS
2.10 secret 3: **
2.15 frystyk 4: ** (c) COPYRIGHT MIT 1995.
2.12 frystyk 5: ** Please first read the full copyright statement in the file COPYRIGH.
6: **
7: ** Authors:
8: ** Arthur Secret
9: **
10: ** 4 March 94: Bug fixed in the balancing procedure
2.10 secret 11: **
1.1 timbl 12: */
13:
2.14 frystyk 14: /* Library include files */
2.21 frystyk 15: #include "sysdep.h"
1.1 timbl 16: #include "HTUtils.h"
17: #include "HTBTree.h"
18:
2.7 secret 19: #define MAXIMUM(a,b) ((a)>(b)?(a):(b))
1.1 timbl 20:
2.18 frystyk 21: struct _HTBTree_element {
22: void *object; /* User object */
23: struct _HTBTree_element *up;
24: struct _HTBTree_element *left;
25: int left_depth;
26: struct _HTBTree_element *right;
27: int right_depth;
28: };
29:
30: struct _HTBTree {
31: HTComparer * compare;
32: struct _HTBTree_element * top;
33: };
1.1 timbl 34:
2.18 frystyk 35: PUBLIC void * HTBTree_object (HTBTElement * element)
36: {
37: return element ? element->object : NULL;
38: }
1.1 timbl 39:
2.18 frystyk 40: PUBLIC HTBTree * HTBTree_new (HTComparer * comp)
1.1 timbl 41: /*********************************************************
42: ** This function returns an HTBTree with memory allocated
43: ** for it when given a mean to compare things
44: */
45: {
2.19 frystyk 46: HTBTree * tree;
47: if ((tree = (HTBTree *) HT_CALLOC(1, sizeof(HTBTree))) == NULL)
48: HT_OUTOFMEM("HTBTree_new");
1.1 timbl 49: tree->compare = comp;
50: tree->top = NULL;
51: return tree;
52: }
53:
54:
55:
56:
2.22 ! frystyk 57: PRIVATE void HTBTElement_free (HTBTElement* element)
2.7 secret 58: /**********************************************************
2.21 frystyk 59: ** This void will HT_FREE the memory allocated for one element
2.7 secret 60: */
61: {
2.9 secret 62: if (element) {
2.22 ! frystyk 63: if (element->left != NULL) HTBTElement_free(element->left);
! 64: if (element->right != NULL) HTBTElement_free(element->right);
2.19 frystyk 65: HT_FREE(element);
2.9 secret 66: }
2.7 secret 67: }
1.1 timbl 68:
2.22 ! frystyk 69: PUBLIC void HTBTree_free (HTBTree* tree)
1.1 timbl 70: /**************************************************************
2.21 frystyk 71: ** This void will HT_FREE the memory allocated for the whole tree
1.1 timbl 72: */
73: {
2.22 ! frystyk 74: HTBTElement_free(tree->top);
2.19 frystyk 75: HT_FREE(tree);
1.1 timbl 76: }
77:
78:
79:
80:
2.22 ! frystyk 81: PRIVATE void HTBTElementAndObject_free (HTBTElement* element)
2.6 timbl 82: /**********************************************************
2.21 frystyk 83: ** This void will HT_FREE the memory allocated for one element
2.6 timbl 84: */
85: {
2.9 secret 86: if (element) { /* Just in case nothing was in the tree anyway */
2.22 ! frystyk 87: if (element->left != NULL) HTBTElementAndObject_free(element->left);
2.9 secret 88: if (element->right != NULL)
2.22 ! frystyk 89: HTBTElementAndObject_free(element->right);
2.19 frystyk 90: HT_FREE(element->object);
91: HT_FREE(element);
2.9 secret 92: }
2.7 secret 93: }
94:
2.22 ! frystyk 95: PUBLIC void HTBTreeAndObject_free (HTBTree* tree)
2.7 secret 96: /**************************************************************
2.21 frystyk 97: ** This void will HT_FREE the memory allocated for the whole tree
2.7 secret 98: */
99: {
2.22 ! frystyk 100: HTBTElementAndObject_free(tree->top);
2.19 frystyk 101: HT_FREE(tree);
2.6 timbl 102: }
103:
2.18 frystyk 104: /*
105: ** This void is the core of HTBTree.c . It will
106: ** 1/ add a new element to the tree at the right place
107: ** so that the tree remains sorted
108: ** 2/ balance the tree to be as fast as possible when reading it
109: */
110: PUBLIC void HTBTree_add (HTBTree * tree, void * object)
1.1 timbl 111: {
2.6 timbl 112: HTBTElement * father_of_element;
113: HTBTElement * added_element;
114: HTBTElement * forefather_of_element;
115: HTBTElement * father_of_forefather;
2.10 secret 116: BOOL father_found,top_found;
117: int depth,depth2,corrections;
2.6 timbl 118: /* father_of_element is a pointer to the structure that is the father of the
119: ** new object "object".
120: ** added_element is a pointer to the structure that contains or will contain
1.1 timbl 121: ** the new object "object".
2.6 timbl 122: ** father_of_forefather and forefather_of_element are pointers that are used
123: ** to modify the depths of upper elements, when needed.
1.1 timbl 124: **
2.7 secret 125: ** father_found indicates by a value NO when the future father of "object"
126: ** is found.
2.6 timbl 127: ** top_found indicates by a value NO when, in case of a difference of depths
1.1 timbl 128: ** < 2, the top of the tree is encountered and forbids any further try to
129: ** balance the tree.
2.10 secret 130: ** corrections is an integer used to avoid infinite loops in cases
1.1 timbl 131: ** such as:
132: **
133: ** 3 3
134: ** 4 4
135: ** 5 5
136: **
137: ** 3 is used here to show that it need not be the top of the tree.
138: */
139:
140: /*
141: ** 1/ Adding of the element to the binary tree
142: */
143:
144: if (tree->top == NULL)
145: {
2.19 frystyk 146: if ((tree->top = (HTBTElement *) HT_MALLOC(sizeof(HTBTElement))) == NULL)
147: HT_OUTOFMEM("HTBTree_add");
1.1 timbl 148: tree->top->up = NULL;
149: tree->top->object = object;
150: tree->top->left = NULL;
151: tree->top->left_depth = 0;
152: tree->top->right = NULL;
153: tree->top->right_depth = 0;
154: }
155: else
156: {
2.6 timbl 157: father_found = YES;
158: father_of_element = tree->top;
159: added_element = NULL;
160: father_of_forefather = NULL;
161: forefather_of_element = NULL;
162: while (father_found)
1.1 timbl 163: {
2.6 timbl 164: if (tree->compare(object,father_of_element->object)<0)
1.1 timbl 165: {
2.6 timbl 166: if (father_of_element->left != NULL)
167: father_of_element = father_of_element->left;
1.1 timbl 168: else
169: {
2.6 timbl 170: father_found = NO;
2.19 frystyk 171: if ((father_of_element->left = (HTBTElement *) HT_MALLOC(sizeof(HTBTElement))) == NULL)
172: HT_OUTOFMEM("HTBTree_add");
2.6 timbl 173: added_element = father_of_element->left;
174: added_element->up = father_of_element;
175: added_element->object = object;
176: added_element->left = NULL;
177: added_element->left_depth = 0;
178: added_element->right = NULL;
179: added_element->right_depth = 0;
1.1 timbl 180: }
181: }
2.8 secret 182: if (tree->compare(object,father_of_element->object)>=0)
1.1 timbl 183: {
2.6 timbl 184: if (father_of_element->right != NULL)
185: father_of_element = father_of_element->right;
1.1 timbl 186: else
187: {
2.6 timbl 188: father_found = NO;
2.19 frystyk 189: if ((father_of_element->right = (HTBTElement *) HT_MALLOC(sizeof(HTBTElement))) == NULL)
190: HT_OUTOFMEM("father_of_element->right ");
2.6 timbl 191: added_element = father_of_element->right;
192: added_element->up = father_of_element;
193: added_element->object = object;
194: added_element->left = NULL;
195: added_element->left_depth = 0;
196: added_element->right = NULL;
197: added_element->right_depth = 0;
1.1 timbl 198: }
199: }
200: }
201: /*
202: ** Changing of all depths that need to be changed
203: */
2.6 timbl 204: father_of_forefather = father_of_element;
205: forefather_of_element = added_element;
1.1 timbl 206: do
207: {
2.6 timbl 208: if (father_of_forefather->left == forefather_of_element)
1.1 timbl 209: {
2.6 timbl 210: depth = father_of_forefather->left_depth;
211: father_of_forefather->left_depth = 1
2.7 secret 212: + MAXIMUM(forefather_of_element->right_depth,
2.6 timbl 213: forefather_of_element->left_depth);
214: depth2 = father_of_forefather->left_depth;
1.1 timbl 215: }
216: else
217: {
2.6 timbl 218: depth = father_of_forefather->right_depth;
219: father_of_forefather->right_depth = 1
2.7 secret 220: + MAXIMUM(forefather_of_element->right_depth,
2.6 timbl 221: forefather_of_element->left_depth);
222: depth2 = father_of_forefather->right_depth;
1.1 timbl 223: }
2.6 timbl 224: forefather_of_element = father_of_forefather;
225: father_of_forefather = father_of_forefather->up;
226: } while ((depth != depth2) && (father_of_forefather != NULL));
1.1 timbl 227:
228:
2.10 secret 229:
1.1 timbl 230: /*
231: ** 2/ Balancing the binary tree, if necessary
2.11 secret 232: ** Bugs in this part have been fixed in March 94 - AS
1.1 timbl 233: */
2.6 timbl 234: top_found = YES;
2.10 secret 235: corrections = 0;
236: while ((top_found) && (corrections < 7))
1.1 timbl 237: {
2.6 timbl 238: if ((abs(father_of_element->left_depth
239: - father_of_element->right_depth)) < 2)
1.1 timbl 240: {
2.6 timbl 241: if (father_of_element->up != NULL)
242: father_of_element = father_of_element->up;
243: else top_found = NO;
1.1 timbl 244: }
245: else
246: { /* We start the process of balancing */
247:
2.10 secret 248: corrections = corrections + 1;
1.1 timbl 249: /*
2.10 secret 250: ** corrections is an integer used to avoid infinite
1.1 timbl 251: ** loops in cases such as:
252: **
253: ** 3 3
254: ** 4 4
255: ** 5 5
256: **
257: ** 3 is used to show that it need not be the top of the tree
2.10 secret 258: ** But let's avoid these two exceptions anyhow
2.11 secret 259: ** with the two following conditions (March 94 - AS)
1.1 timbl 260: */
261:
2.10 secret 262: if ((father_of_element->left == NULL)
263: && (father_of_element->right->right == NULL)
264: && (father_of_element->right->left->left == NULL)
265: && (father_of_element->right->left->right == NULL))
266: corrections = 7;
267:
268: if ((father_of_element->right == NULL)
269: && (father_of_element->left->left == NULL)
270: && (father_of_element->left->right->right == NULL)
271: && (father_of_element->left->right->left == NULL))
272: corrections = 7;
273:
1.1 timbl 274:
2.6 timbl 275: if (father_of_element->left_depth > father_of_element->right_depth)
1.1 timbl 276: {
2.6 timbl 277: added_element = father_of_element->left;
278: father_of_element->left_depth = added_element->right_depth;
279: added_element->right_depth = 1
2.7 secret 280: + MAXIMUM(father_of_element->right_depth,
2.6 timbl 281: father_of_element->left_depth);
282: if (father_of_element->up != NULL)
1.1 timbl 283: {
2.11 secret 284: /* Bug fixed in March 94 */
2.10 secret 285: BOOL first_time;
286:
2.6 timbl 287: father_of_forefather = father_of_element->up;
288: forefather_of_element = added_element;
2.10 secret 289: first_time = YES;
1.1 timbl 290: do
291: {
2.6 timbl 292: if (father_of_forefather->left
293: == forefather_of_element->up)
2.10 secret 294: {
295: depth = father_of_forefather->left_depth;
296: if (first_time)
297: {
298: father_of_forefather->left_depth = 1
299: + MAXIMUM(forefather_of_element->left_depth,
300: forefather_of_element->right_depth);
301: first_time = NO;
302: }
303: else
304: father_of_forefather->left_depth = 1
305: + MAXIMUM(forefather_of_element->up->left_depth,
306: forefather_of_element->up->right_depth);
307:
2.6 timbl 308: depth2 = father_of_forefather->left_depth;
1.1 timbl 309: }
310: else
311: {
2.6 timbl 312: depth = father_of_forefather->right_depth;
2.10 secret 313: if (first_time)
314: {
315: father_of_forefather->right_depth = 1
316: + MAXIMUM(forefather_of_element->left_depth,
317: forefather_of_element->right_depth);
318: first_time = NO;
319: }
320: else
321: father_of_forefather->right_depth = 1
322: + MAXIMUM(forefather_of_element->up->left_depth,
323: forefather_of_element->up->right_depth);
2.6 timbl 324: depth2 = father_of_forefather->right_depth;
1.1 timbl 325: }
2.10 secret 326: forefather_of_element = forefather_of_element->up;
2.6 timbl 327: father_of_forefather = father_of_forefather->up;
2.7 secret 328: } while ((depth != depth2) &&
329: (father_of_forefather != NULL));
2.6 timbl 330: father_of_forefather = father_of_element->up;
331: if (father_of_forefather->left == father_of_element)
1.1 timbl 332: {
333: /*
334: ** 3 3
335: ** 4 5
336: ** When tree 5 6 becomes 7 4
337: ** 7 8 8 6
338: **
339: ** 3 is used to show that it may not be the top of the
340: ** tree.
341: */
2.6 timbl 342: father_of_forefather->left = added_element;
343: father_of_element->left = added_element->right;
344: added_element->right = father_of_element;
1.1 timbl 345: }
2.6 timbl 346: if (father_of_forefather->right == father_of_element)
1.1 timbl 347: {
348: /*
349: ** 3 3
350: ** 4 5
351: ** When tree 5 6 becomes 7 4
352: ** 7 8 8 6
353: **
354: ** 3 is used to show that it may not be the top of the
355: ** tree
356: */
2.6 timbl 357: father_of_forefather->right = added_element;
358: father_of_element->left = added_element->right;
359: added_element->right = father_of_element;
1.1 timbl 360: }
2.6 timbl 361: added_element->up = father_of_forefather;
1.1 timbl 362: }
363: else
364: {
365: /*
366: **
367: ** 1 2
368: ** When tree 2 3 becomes 4 1
369: ** 4 5 5 3
370: **
371: ** 1 is used to show that it is the top of the tree
372: */
2.6 timbl 373: added_element->up = NULL;
374: father_of_element->left = added_element->right;
375: added_element->right = father_of_element;
1.1 timbl 376: }
2.6 timbl 377: father_of_element->up = added_element;
378: if (father_of_element->left != NULL)
379: father_of_element->left->up = father_of_element;
1.1 timbl 380: }
381: else
382: {
2.6 timbl 383: added_element = father_of_element->right;
384: father_of_element->right_depth = added_element->left_depth;
385: added_element->left_depth = 1 +
2.7 secret 386: MAXIMUM(father_of_element->right_depth,
2.6 timbl 387: father_of_element->left_depth);
388: if (father_of_element->up != NULL)
2.11 secret 389: /* Bug fixed in March 94 */
1.1 timbl 390: {
2.10 secret 391: BOOL first_time;
392:
2.6 timbl 393: father_of_forefather = father_of_element->up;
394: forefather_of_element = added_element;
2.10 secret 395: first_time = YES;
1.1 timbl 396: do
397: {
2.10 secret 398: if (father_of_forefather->left
399: == forefather_of_element->up)
1.1 timbl 400: {
2.6 timbl 401: depth = father_of_forefather->left_depth;
2.10 secret 402: if (first_time)
403: {
404: father_of_forefather->left_depth = 1
405: + MAXIMUM(forefather_of_element->left_depth,
406: forefather_of_element->right_depth);
407: first_time = NO;
408: }
409: else
410: father_of_forefather->left_depth = 1
411: + MAXIMUM(forefather_of_element->up->left_depth,
412: forefather_of_element->up->right_depth);
413: depth2 = father_of_forefather->left_depth;
1.1 timbl 414: }
415: else
416: {
2.6 timbl 417: depth = father_of_forefather->right_depth;
2.10 secret 418: if (first_time)
419: {
420: father_of_forefather->right_depth = 1
421: + MAXIMUM(forefather_of_element->left_depth,
422: forefather_of_element->right_depth);
423: first_time = NO;
424: }
425: else
426: father_of_forefather->right_depth = 1
427: + MAXIMUM(forefather_of_element->up->left_depth,
428: forefather_of_element->up->right_depth);
2.6 timbl 429: depth2 = father_of_forefather->right_depth;
1.1 timbl 430: }
2.6 timbl 431: father_of_forefather = father_of_forefather->up;
2.10 secret 432: forefather_of_element = forefather_of_element->up;
2.7 secret 433: } while ((depth != depth2) &&
434: (father_of_forefather != NULL));
2.6 timbl 435: father_of_forefather = father_of_element->up;
436: if (father_of_forefather->left == father_of_element)
1.1 timbl 437: {
438: /*
439: ** 3 3
440: ** 4 6
441: ** When tree 5 6 becomes 4 8
442: ** 7 8 5 7
443: **
444: ** 3 is used to show that it may not be the top of the
445: ** tree.
446: */
2.6 timbl 447: father_of_forefather->left = added_element;
448: father_of_element->right = added_element->left;
449: added_element->left = father_of_element;
1.1 timbl 450: }
2.6 timbl 451: if (father_of_forefather->right == father_of_element)
1.1 timbl 452: {
453: /*
454: ** 3 3
455: ** 4 6
456: ** When tree 5 6 becomes 4 8
457: ** 7 8 5 7
458: **
459: ** 3 is used to show that it may not be the top of the
460: ** tree
461: */
2.6 timbl 462: father_of_forefather->right = added_element;
463: father_of_element->right = added_element->left;
464: added_element->left = father_of_element;
1.1 timbl 465: }
2.6 timbl 466: added_element->up = father_of_forefather;
1.1 timbl 467: }
468: else
469: {
470: /*
471: **
472: ** 1 3
473: ** When tree 2 3 becomes 1 5
474: ** 4 5 2 4
475: **
476: ** 1 is used to show that it is the top of the tree.
477: */
2.6 timbl 478: added_element->up = NULL;
479: father_of_element->right = added_element->left;
480: added_element->left = father_of_element;
1.1 timbl 481: }
2.6 timbl 482: father_of_element->up = added_element;
2.8 secret 483: if (father_of_element->right != NULL)
484: father_of_element->right->up = father_of_element;
1.1 timbl 485: }
486: }
487: }
2.6 timbl 488: while (father_of_element->up != NULL)
1.1 timbl 489: {
2.6 timbl 490: father_of_element = father_of_element->up;
1.1 timbl 491: }
2.6 timbl 492: tree->top = father_of_element;
1.1 timbl 493: }
494: }
495:
2.18 frystyk 496: /*
497: ** this function returns a pointer to the leftmost element if ele is NULL,
498: ** and to the next object to the right otherways.
499: ** If no elements left, returns a pointer to NULL.
500: */
501: PUBLIC HTBTElement * HTBTree_next(HTBTree * tree, HTBTElement * element)
1.1 timbl 502: {
2.6 timbl 503: HTBTElement * father_of_element;
504: HTBTElement * father_of_forefather;
2.18 frystyk 505: if (!element) {
2.6 timbl 506: father_of_element = tree->top;
507: if (father_of_element != NULL)
508: while (father_of_element->left != NULL)
509: father_of_element = father_of_element->left;
1.1 timbl 510: }
511: else
512: {
2.18 frystyk 513: father_of_element = element;
2.6 timbl 514: if (father_of_element->right != NULL)
1.1 timbl 515: {
2.6 timbl 516: father_of_element = father_of_element->right;
517: while (father_of_element->left != NULL)
518: father_of_element = father_of_element->left;
1.1 timbl 519: }
520: else
521: {
2.6 timbl 522: father_of_forefather = father_of_element->up;
2.7 secret 523: while (father_of_forefather &&
524: (father_of_forefather->right == father_of_element))
525: {
526: father_of_element = father_of_forefather;
527: father_of_forefather = father_of_element->up;
528: }
2.6 timbl 529: father_of_element = father_of_forefather;
1.1 timbl 530: }
531: }
2.21 frystyk 532: #if 0
2.6 timbl 533: /* The option -DBTREE_TRACE will give much more information
534: ** about the way the process is running, for debugging matters
535: */
536: if (father_of_element != NULL)
537: {
2.20 eric 538: HTTrace("\nObject = %s\t",(char *)father_of_element->object);
2.6 timbl 539: if (father_of_element->up != NULL)
2.20 eric 540: HTTrace("Objet du pere = %s\n",
2.7 secret 541: (char *)father_of_element->up->object);
2.20 eric 542: else HTTrace("Pas de Pere\n");
2.6 timbl 543: if (father_of_element->left != NULL)
2.20 eric 544: HTTrace("Objet du fils gauche = %s\t",
2.7 secret 545: (char *)father_of_element->left->object);
2.20 eric 546: else HTTrace("Pas de fils gauche\t");
2.6 timbl 547: if (father_of_element->right != NULL)
2.20 eric 548: HTTrace("Objet du fils droit = %s\n",
2.7 secret 549: (char *)father_of_element->right->object);
2.20 eric 550: else HTTrace("Pas de fils droit\n");
551: HTTrace("Profondeur gauche = %i\t",father_of_element->left_depth);
552: HTTrace("Profondeur droite = %i\n",father_of_element->right_depth);
553: HTTrace(" **************\n");
2.6 timbl 554: }
555: #endif
556: return father_of_element;
1.1 timbl 557: }
558:
559:
2.21 frystyk 560: #if 0
1.1 timbl 561: main ()
562: /******************************************************
563: ** This is just a test to show how to handle HTBTree.c
564: */
565: {
566: HTBTree * tree;
2.6 timbl 567: HTBTElement * next_element;
1.1 timbl 568:
2.8 secret 569: tree = HTBTree_new((HTComparer)strcasecmp);
570: HTBTree_add(tree,"hypertext");
571: HTBTree_add(tree,"Addressing");
572: HTBTree_add(tree,"X11");
573: HTBTree_add(tree,"Tools");
574: HTBTree_add(tree,"Proposal.wn");
575: HTBTree_add(tree,"Protocols");
576: HTBTree_add(tree,"NeXT");
577: HTBTree_add(tree,"Daemon");
578: HTBTree_add(tree,"Test");
579: HTBTree_add(tree,"Administration");
580: HTBTree_add(tree,"LineMode");
581: HTBTree_add(tree,"DesignIssues");
582: HTBTree_add(tree,"MarkUp");
583: HTBTree_add(tree,"Macintosh");
584: HTBTree_add(tree,"Proposal.rtf.wn");
585: HTBTree_add(tree,"FIND");
586: HTBTree_add(tree,"Paper");
587: HTBTree_add(tree,"Tcl");
588: HTBTree_add(tree,"Talks");
589: HTBTree_add(tree,"Architecture");
590: HTBTree_add(tree,"VMSHelp");
591: HTBTree_add(tree,"Provider");
592: HTBTree_add(tree,"Archive");
593: HTBTree_add(tree,"SLAC");
594: HTBTree_add(tree,"Project");
595: HTBTree_add(tree,"News");
596: HTBTree_add(tree,"Viola");
597: HTBTree_add(tree,"Users");
598: HTBTree_add(tree,"FAQ");
599: HTBTree_add(tree,"WorkingNotes");
600: HTBTree_add(tree,"Windows");
601: HTBTree_add(tree,"FineWWW");
602: HTBTree_add(tree,"Frame");
603: HTBTree_add(tree,"XMosaic");
604: HTBTree_add(tree,"People");
605: HTBTree_add(tree,"All");
606: HTBTree_add(tree,"Curses");
607: HTBTree_add(tree,"Erwise");
608: HTBTree_add(tree,"Carl");
609: HTBTree_add(tree,"MidasWWW");
610: HTBTree_add(tree,"XPM");
611: HTBTree_add(tree,"MailRobot");
612: HTBTree_add(tree,"Illustrations");
613: HTBTree_add(tree,"VMClient");
614: HTBTree_add(tree,"XPA");
615: HTBTree_add(tree,"Clients.html");
616: HTBTree_add(tree,"Library");
617: HTBTree_add(tree,"CERNLIB_Distribution");
618: HTBTree_add(tree,"libHTML");
619: HTBTree_add(tree,"WindowsPC");
620: HTBTree_add(tree,"tkWWW");
621: HTBTree_add(tree,"tk2.3");
622: HTBTree_add(tree,"CVS-RCS");
623: HTBTree_add(tree,"DecnetSockets");
624: HTBTree_add(tree,"SGMLStream");
625: HTBTree_add(tree,"NextStep");
626: HTBTree_add(tree,"CVSRepository_old");
627: HTBTree_add(tree,"ArthurSecret");
628: HTBTree_add(tree,"CVSROOT");
629: HTBTree_add(tree,"HytelnetGate");
630: HTBTree_add(tree,"cern.www.new.src");
631: HTBTree_add(tree,"Conditions");
632: HTBTree_add(tree,"HTMLGate");
633: HTBTree_add(tree,"Makefile");
634: HTBTree_add(tree,"Newsgroups.html");
635: HTBTree_add(tree,"People.html");
636: HTBTree_add(tree,"Bugs.html");
637: HTBTree_add(tree,"Summary.html");
638: HTBTree_add(tree,"zDesignIssues.wn");
639: HTBTree_add(tree,"HT.draw");
640: HTBTree_add(tree,"HTandCERN.wn");
641: HTBTree_add(tree,"Ideas.wn");
642: HTBTree_add(tree,"MarkUp.wn");
643: HTBTree_add(tree,"Proposal.html");
644: HTBTree_add(tree,"SearchPanel.draw");
645: HTBTree_add(tree,"Comments.wn");
646: HTBTree_add(tree,"Xanadu.html");
647: HTBTree_add(tree,"Storinglinks.html");
648: HTBTree_add(tree,"TheW3Book.html");
649: HTBTree_add(tree,"Talk_Feb-91.html");
650: HTBTree_add(tree,"JFosterEntry.txt");
651: HTBTree_add(tree,"Summary.txt");
652: HTBTree_add(tree,"Bibliography.html");
653: HTBTree_add(tree,"HTandCern.txt");
654: HTBTree_add(tree,"Talk.draw");
655: HTBTree_add(tree,"zDesignNotes.html");
656: HTBTree_add(tree,"Link.html");
657: HTBTree_add(tree,"Status.html");
658: HTBTree_add(tree,"http.txt");
659: HTBTree_add(tree,"People.html~");
660: HTBTree_add(tree,"TAGS");
661: HTBTree_add(tree,"summary.txt");
662: HTBTree_add(tree,"Technical.html");
663: HTBTree_add(tree,"Terms.html");
664: HTBTree_add(tree,"JANETAccess.html");
665: HTBTree_add(tree,"People.txt");
666: HTBTree_add(tree,"README.txt");
667: HTBTree_add(tree,"CodingStandards.html");
668: HTBTree_add(tree,"Copyright.txt");
669: HTBTree_add(tree,"Status_old.html");
670: HTBTree_add(tree,"patches~");
671: HTBTree_add(tree,"RelatedProducts.html");
672: HTBTree_add(tree,"Implementation");
673: HTBTree_add(tree,"History.html");
674: HTBTree_add(tree,"Makefile.bak");
675: HTBTree_add(tree,"Makefile.old");
676: HTBTree_add(tree,"Policy.html");
677: HTBTree_add(tree,"WhatIs.html");
678: HTBTree_add(tree,"TheProject.html");
679: HTBTree_add(tree,"Notation.html");
680: HTBTree_add(tree,"Helping.html");
681: HTBTree_add(tree,"Cyber-WWW.sit.Hqx");
682: HTBTree_add(tree,"Glossary.html");
683: HTBTree_add(tree,"maketags.html");
684: HTBTree_add(tree,"IntroCS.html");
685: HTBTree_add(tree,"Contrib");
686: HTBTree_add(tree,"Help.html");
687: HTBTree_add(tree,"CodeManagExec");
688: HTBTree_add(tree,"HT-0.1draz");
689: HTBTree_add(tree,"Cello");
690: HTBTree_add(tree,"TOPUB");
691: HTBTree_add(tree,"BUILD");
692: HTBTree_add(tree,"BUILDALL");
693: HTBTree_add(tree,"Lynx");
694: HTBTree_add(tree,"ArthurLibrary");
695: HTBTree_add(tree,"RashtyClient");
696: HTBTree_add(tree,"#History.html#");
697: HTBTree_add(tree,"PerlServers");
698: HTBTree_add(tree,"modules");
699: HTBTree_add(tree,"NCSA_httpd");
700: HTBTree_add(tree,"MAIL2HTML");
701: HTBTree_add(tree,"core");
702: HTBTree_add(tree,"EmacsWWW");
2.20 eric 703: HTTrace("\nTreeTopObject=%s\n\n",tree->top->object);
2.6 timbl 704: next_element = HTBTree_next(tree,NULL);
705: while (next_element != NULL)
1.1 timbl 706: {
2.20 eric 707: HTTrace("The next element is %s\n",next_element->object);
2.6 timbl 708: next_element = HTBTree_next(tree,next_element);
1.1 timbl 709: }
2.22 ! frystyk 710: HTBTree_free (tree);
1.1 timbl 711: }
712: #endif
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTBTree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src