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