Annotation of libwww/Library/src/HTBTree.c, revision 2.15
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 */
15: #include "tcp.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:
21:
22:
23:
24:
25: PUBLIC HTBTree * HTBTree_new ARGS1(HTComparer, comp)
26: /*********************************************************
27: ** This function returns an HTBTree with memory allocated
28: ** for it when given a mean to compare things
29: */
30: {
31: HTBTree * tree = (HTBTree *)malloc(sizeof(HTBTree));
32: if (tree==NULL) outofmem(__FILE__, "HTBTree_new");
33:
34: tree->compare = comp;
35: tree->top = NULL;
36:
37: return tree;
38: }
39:
40:
41:
42:
2.7 secret 43: PRIVATE void HTBTElement_free ARGS1(HTBTElement*, element)
44: /**********************************************************
45: ** This void will free the memory allocated for one element
46: */
47: {
2.9 secret 48: if (element) {
49: if (element->left != NULL) HTBTElement_free(element->left);
50: if (element->right != NULL) HTBTElement_free(element->right);
51: free(element);
52: }
2.7 secret 53: }
1.1 timbl 54:
55: PUBLIC void HTBTree_free ARGS1(HTBTree*, tree)
56: /**************************************************************
57: ** This void will free the memory allocated for the whole tree
58: */
59: {
2.6 timbl 60: HTBTElement_free(tree->top);
1.1 timbl 61: free(tree);
62: }
63:
64:
65:
66:
2.7 secret 67: PRIVATE void HTBTElementAndObject_free ARGS1(HTBTElement*, element)
2.6 timbl 68: /**********************************************************
69: ** This void will free the memory allocated for one element
70: */
71: {
2.9 secret 72: if (element) { /* Just in case nothing was in the tree anyway */
73: if (element->left != NULL) HTBTElementAndObject_free(element->left);
74: if (element->right != NULL)
75: HTBTElementAndObject_free(element->right);
76: free(element->object);
77: free(element);
78: }
2.7 secret 79: }
80:
81: PUBLIC void HTBTreeAndObject_free ARGS1(HTBTree*, tree)
82: /**************************************************************
83: ** This void will free the memory allocated for the whole tree
84: */
85: {
86: HTBTElementAndObject_free(tree->top);
87: free(tree);
2.6 timbl 88: }
89:
90:
91:
92:
1.1 timbl 93: PUBLIC void HTBTree_add ARGS2(
94: HTBTree*, tree,
95: void*, object)
96: /**********************************************************************
97: ** This void is the core of HTBTree.c . It will
98: ** 1/ add a new element to the tree at the right place
99: ** so that the tree remains sorted
100: ** 2/ balance the tree to be as fast as possible when reading it
101: */
102: {
2.6 timbl 103: HTBTElement * father_of_element;
104: HTBTElement * added_element;
105: HTBTElement * forefather_of_element;
106: HTBTElement * father_of_forefather;
2.10 secret 107: BOOL father_found,top_found;
108: int depth,depth2,corrections;
2.6 timbl 109: /* father_of_element is a pointer to the structure that is the father of the
110: ** new object "object".
111: ** added_element is a pointer to the structure that contains or will contain
1.1 timbl 112: ** the new object "object".
2.6 timbl 113: ** father_of_forefather and forefather_of_element are pointers that are used
114: ** to modify the depths of upper elements, when needed.
1.1 timbl 115: **
2.7 secret 116: ** father_found indicates by a value NO when the future father of "object"
117: ** is found.
2.6 timbl 118: ** top_found indicates by a value NO when, in case of a difference of depths
1.1 timbl 119: ** < 2, the top of the tree is encountered and forbids any further try to
120: ** balance the tree.
2.10 secret 121: ** corrections is an integer used to avoid infinite loops in cases
1.1 timbl 122: ** such as:
123: **
124: ** 3 3
125: ** 4 4
126: ** 5 5
127: **
128: ** 3 is used here to show that it need not be the top of the tree.
129: */
130:
131: /*
132: ** 1/ Adding of the element to the binary tree
133: */
134:
135: if (tree->top == NULL)
136: {
137: tree->top = (HTBTElement *)malloc(sizeof(HTBTElement));
138: if (tree->top == NULL) outofmem(__FILE__, "HTBTree_add");
139: tree->top->up = NULL;
140: tree->top->object = object;
141: tree->top->left = NULL;
142: tree->top->left_depth = 0;
143: tree->top->right = NULL;
144: tree->top->right_depth = 0;
145: }
146: else
147: {
2.6 timbl 148: father_found = YES;
149: father_of_element = tree->top;
150: added_element = NULL;
151: father_of_forefather = NULL;
152: forefather_of_element = NULL;
153: while (father_found)
1.1 timbl 154: {
2.6 timbl 155: if (tree->compare(object,father_of_element->object)<0)
1.1 timbl 156: {
2.6 timbl 157: if (father_of_element->left != NULL)
158: father_of_element = father_of_element->left;
1.1 timbl 159: else
160: {
2.6 timbl 161: father_found = NO;
162: father_of_element->left =
163: (HTBTElement *)malloc(sizeof(HTBTElement));
164: if (father_of_element->left==NULL)
165: outofmem(__FILE__, "HTBTree_add");
166: added_element = father_of_element->left;
167: added_element->up = father_of_element;
168: added_element->object = object;
169: added_element->left = NULL;
170: added_element->left_depth = 0;
171: added_element->right = NULL;
172: added_element->right_depth = 0;
1.1 timbl 173: }
174: }
2.8 secret 175: if (tree->compare(object,father_of_element->object)>=0)
1.1 timbl 176: {
2.6 timbl 177: if (father_of_element->right != NULL)
178: father_of_element = father_of_element->right;
1.1 timbl 179: else
180: {
2.6 timbl 181: father_found = NO;
182: father_of_element->right =
183: (HTBTElement *)malloc(sizeof(HTBTElement));
184: if (father_of_element->right==NULL)
185: outofmem(__FILE__, "HTBTree_add");
186: added_element = father_of_element->right;
187: added_element->up = father_of_element;
188: added_element->object = object;
189: added_element->left = NULL;
190: added_element->left_depth = 0;
191: added_element->right = NULL;
192: added_element->right_depth = 0;
1.1 timbl 193: }
194: }
195: }
196: /*
197: ** Changing of all depths that need to be changed
198: */
2.6 timbl 199: father_of_forefather = father_of_element;
200: forefather_of_element = added_element;
1.1 timbl 201: do
202: {
2.6 timbl 203: if (father_of_forefather->left == forefather_of_element)
1.1 timbl 204: {
2.6 timbl 205: depth = father_of_forefather->left_depth;
206: father_of_forefather->left_depth = 1
2.7 secret 207: + MAXIMUM(forefather_of_element->right_depth,
2.6 timbl 208: forefather_of_element->left_depth);
209: depth2 = father_of_forefather->left_depth;
1.1 timbl 210: }
211: else
212: {
2.6 timbl 213: depth = father_of_forefather->right_depth;
214: father_of_forefather->right_depth = 1
2.7 secret 215: + MAXIMUM(forefather_of_element->right_depth,
2.6 timbl 216: forefather_of_element->left_depth);
217: depth2 = father_of_forefather->right_depth;
1.1 timbl 218: }
2.6 timbl 219: forefather_of_element = father_of_forefather;
220: father_of_forefather = father_of_forefather->up;
221: } while ((depth != depth2) && (father_of_forefather != NULL));
1.1 timbl 222:
223:
2.10 secret 224:
1.1 timbl 225: /*
226: ** 2/ Balancing the binary tree, if necessary
2.11 secret 227: ** Bugs in this part have been fixed in March 94 - AS
1.1 timbl 228: */
2.6 timbl 229: top_found = YES;
2.10 secret 230: corrections = 0;
231: while ((top_found) && (corrections < 7))
1.1 timbl 232: {
2.6 timbl 233: if ((abs(father_of_element->left_depth
234: - father_of_element->right_depth)) < 2)
1.1 timbl 235: {
2.6 timbl 236: if (father_of_element->up != NULL)
237: father_of_element = father_of_element->up;
238: else top_found = NO;
1.1 timbl 239: }
240: else
241: { /* We start the process of balancing */
242:
2.10 secret 243: corrections = corrections + 1;
1.1 timbl 244: /*
2.10 secret 245: ** corrections is an integer used to avoid infinite
1.1 timbl 246: ** loops in cases such as:
247: **
248: ** 3 3
249: ** 4 4
250: ** 5 5
251: **
252: ** 3 is used to show that it need not be the top of the tree
2.10 secret 253: ** But let's avoid these two exceptions anyhow
2.11 secret 254: ** with the two following conditions (March 94 - AS)
1.1 timbl 255: */
256:
2.10 secret 257: if ((father_of_element->left == NULL)
258: && (father_of_element->right->right == NULL)
259: && (father_of_element->right->left->left == NULL)
260: && (father_of_element->right->left->right == NULL))
261: corrections = 7;
262:
263: if ((father_of_element->right == NULL)
264: && (father_of_element->left->left == NULL)
265: && (father_of_element->left->right->right == NULL)
266: && (father_of_element->left->right->left == NULL))
267: corrections = 7;
268:
1.1 timbl 269:
2.6 timbl 270: if (father_of_element->left_depth > father_of_element->right_depth)
1.1 timbl 271: {
2.6 timbl 272: added_element = father_of_element->left;
273: father_of_element->left_depth = added_element->right_depth;
274: added_element->right_depth = 1
2.7 secret 275: + MAXIMUM(father_of_element->right_depth,
2.6 timbl 276: father_of_element->left_depth);
277: if (father_of_element->up != NULL)
1.1 timbl 278: {
2.11 secret 279: /* Bug fixed in March 94 */
2.10 secret 280: BOOL first_time;
281:
2.6 timbl 282: father_of_forefather = father_of_element->up;
283: forefather_of_element = added_element;
2.10 secret 284: first_time = YES;
1.1 timbl 285: do
286: {
2.6 timbl 287: if (father_of_forefather->left
288: == forefather_of_element->up)
2.10 secret 289: {
290: depth = father_of_forefather->left_depth;
291: if (first_time)
292: {
293: father_of_forefather->left_depth = 1
294: + MAXIMUM(forefather_of_element->left_depth,
295: forefather_of_element->right_depth);
296: first_time = NO;
297: }
298: else
299: father_of_forefather->left_depth = 1
300: + MAXIMUM(forefather_of_element->up->left_depth,
301: forefather_of_element->up->right_depth);
302:
2.6 timbl 303: depth2 = father_of_forefather->left_depth;
1.1 timbl 304: }
305: else
306: {
2.6 timbl 307: depth = father_of_forefather->right_depth;
2.10 secret 308: if (first_time)
309: {
310: father_of_forefather->right_depth = 1
311: + MAXIMUM(forefather_of_element->left_depth,
312: forefather_of_element->right_depth);
313: first_time = NO;
314: }
315: else
316: father_of_forefather->right_depth = 1
317: + MAXIMUM(forefather_of_element->up->left_depth,
318: forefather_of_element->up->right_depth);
2.6 timbl 319: depth2 = father_of_forefather->right_depth;
1.1 timbl 320: }
2.10 secret 321: forefather_of_element = forefather_of_element->up;
2.6 timbl 322: father_of_forefather = father_of_forefather->up;
2.7 secret 323: } while ((depth != depth2) &&
324: (father_of_forefather != NULL));
2.6 timbl 325: father_of_forefather = father_of_element->up;
326: if (father_of_forefather->left == father_of_element)
1.1 timbl 327: {
328: /*
329: ** 3 3
330: ** 4 5
331: ** When tree 5 6 becomes 7 4
332: ** 7 8 8 6
333: **
334: ** 3 is used to show that it may not be the top of the
335: ** tree.
336: */
2.6 timbl 337: father_of_forefather->left = added_element;
338: father_of_element->left = added_element->right;
339: added_element->right = father_of_element;
1.1 timbl 340: }
2.6 timbl 341: if (father_of_forefather->right == father_of_element)
1.1 timbl 342: {
343: /*
344: ** 3 3
345: ** 4 5
346: ** When tree 5 6 becomes 7 4
347: ** 7 8 8 6
348: **
349: ** 3 is used to show that it may not be the top of the
350: ** tree
351: */
2.6 timbl 352: father_of_forefather->right = added_element;
353: father_of_element->left = added_element->right;
354: added_element->right = father_of_element;
1.1 timbl 355: }
2.6 timbl 356: added_element->up = father_of_forefather;
1.1 timbl 357: }
358: else
359: {
360: /*
361: **
362: ** 1 2
363: ** When tree 2 3 becomes 4 1
364: ** 4 5 5 3
365: **
366: ** 1 is used to show that it is the top of the tree
367: */
2.6 timbl 368: added_element->up = NULL;
369: father_of_element->left = added_element->right;
370: added_element->right = father_of_element;
1.1 timbl 371: }
2.6 timbl 372: father_of_element->up = added_element;
373: if (father_of_element->left != NULL)
374: father_of_element->left->up = father_of_element;
1.1 timbl 375: }
376: else
377: {
2.6 timbl 378: added_element = father_of_element->right;
379: father_of_element->right_depth = added_element->left_depth;
380: added_element->left_depth = 1 +
2.7 secret 381: MAXIMUM(father_of_element->right_depth,
2.6 timbl 382: father_of_element->left_depth);
383: if (father_of_element->up != NULL)
2.11 secret 384: /* Bug fixed in March 94 */
1.1 timbl 385: {
2.10 secret 386: BOOL first_time;
387:
2.6 timbl 388: father_of_forefather = father_of_element->up;
389: forefather_of_element = added_element;
2.10 secret 390: first_time = YES;
1.1 timbl 391: do
392: {
2.10 secret 393: if (father_of_forefather->left
394: == forefather_of_element->up)
1.1 timbl 395: {
2.6 timbl 396: depth = father_of_forefather->left_depth;
2.10 secret 397: if (first_time)
398: {
399: father_of_forefather->left_depth = 1
400: + MAXIMUM(forefather_of_element->left_depth,
401: forefather_of_element->right_depth);
402: first_time = NO;
403: }
404: else
405: father_of_forefather->left_depth = 1
406: + MAXIMUM(forefather_of_element->up->left_depth,
407: forefather_of_element->up->right_depth);
408: depth2 = father_of_forefather->left_depth;
1.1 timbl 409: }
410: else
411: {
2.6 timbl 412: depth = father_of_forefather->right_depth;
2.10 secret 413: if (first_time)
414: {
415: father_of_forefather->right_depth = 1
416: + MAXIMUM(forefather_of_element->left_depth,
417: forefather_of_element->right_depth);
418: first_time = NO;
419: }
420: else
421: father_of_forefather->right_depth = 1
422: + MAXIMUM(forefather_of_element->up->left_depth,
423: forefather_of_element->up->right_depth);
2.6 timbl 424: depth2 = father_of_forefather->right_depth;
1.1 timbl 425: }
2.6 timbl 426: father_of_forefather = father_of_forefather->up;
2.10 secret 427: forefather_of_element = forefather_of_element->up;
2.7 secret 428: } while ((depth != depth2) &&
429: (father_of_forefather != NULL));
2.6 timbl 430: father_of_forefather = father_of_element->up;
431: if (father_of_forefather->left == father_of_element)
1.1 timbl 432: {
433: /*
434: ** 3 3
435: ** 4 6
436: ** When tree 5 6 becomes 4 8
437: ** 7 8 5 7
438: **
439: ** 3 is used to show that it may not be the top of the
440: ** tree.
441: */
2.6 timbl 442: father_of_forefather->left = added_element;
443: father_of_element->right = added_element->left;
444: added_element->left = father_of_element;
1.1 timbl 445: }
2.6 timbl 446: if (father_of_forefather->right == father_of_element)
1.1 timbl 447: {
448: /*
449: ** 3 3
450: ** 4 6
451: ** When tree 5 6 becomes 4 8
452: ** 7 8 5 7
453: **
454: ** 3 is used to show that it may not be the top of the
455: ** tree
456: */
2.6 timbl 457: father_of_forefather->right = added_element;
458: father_of_element->right = added_element->left;
459: added_element->left = father_of_element;
1.1 timbl 460: }
2.6 timbl 461: added_element->up = father_of_forefather;
1.1 timbl 462: }
463: else
464: {
465: /*
466: **
467: ** 1 3
468: ** When tree 2 3 becomes 1 5
469: ** 4 5 2 4
470: **
471: ** 1 is used to show that it is the top of the tree.
472: */
2.6 timbl 473: added_element->up = NULL;
474: father_of_element->right = added_element->left;
475: added_element->left = father_of_element;
1.1 timbl 476: }
2.6 timbl 477: father_of_element->up = added_element;
2.8 secret 478: if (father_of_element->right != NULL)
479: father_of_element->right->up = father_of_element;
1.1 timbl 480: }
481: }
482: }
2.6 timbl 483: while (father_of_element->up != NULL)
1.1 timbl 484: {
2.6 timbl 485: father_of_element = father_of_element->up;
1.1 timbl 486: }
2.6 timbl 487: tree->top = father_of_element;
1.1 timbl 488: }
489: }
490:
491:
492:
493: PUBLIC HTBTElement * HTBTree_next ARGS2(
494: HTBTree*, tree,
495: HTBTElement*, ele)
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: {
2.6 timbl 502: HTBTElement * father_of_element;
503: HTBTElement * father_of_forefather;
1.1 timbl 504:
505: if (ele == NULL)
506: {
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.6 timbl 514: father_of_element = ele;
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.6 timbl 533: #ifdef BTREE_TRACE
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.7 secret 539: printf("\nObject = %s\t",(char *)father_of_element->object);
2.6 timbl 540: if (father_of_element->up != NULL)
2.7 secret 541: printf("Objet du pere = %s\n",
542: (char *)father_of_element->up->object);
2.6 timbl 543: else printf("Pas de Pere\n");
544: if (father_of_element->left != NULL)
2.7 secret 545: printf("Objet du fils gauche = %s\t",
546: (char *)father_of_element->left->object);
2.6 timbl 547: else printf("Pas de fils gauche\t");
548: if (father_of_element->right != NULL)
2.7 secret 549: printf("Objet du fils droit = %s\n",
550: (char *)father_of_element->right->object);
2.6 timbl 551: else printf("Pas de fils droit\n");
552: printf("Profondeur gauche = %i\t",father_of_element->left_depth);
553: printf("Profondeur droite = %i\n",father_of_element->right_depth);
554: printf(" **************\n");
555: }
556: #endif
557: return father_of_element;
1.1 timbl 558: }
559:
560:
561: #ifdef TEST
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.6 timbl 704: #ifdef BTREE_TRACE
705: printf("\nTreeTopObject=%s\n\n",tree->top->object);
706: #endif
707: next_element = HTBTree_next(tree,NULL);
708: while (next_element != NULL)
1.1 timbl 709: {
2.6 timbl 710: #ifndef BTREE_TRACE
711: printf("The next element is %s\n",next_element->object);
712: #endif
713: next_element = HTBTree_next(tree,next_element);
1.1 timbl 714: }
715: HTBTree_free (tree);
716: }
717:
718:
719: #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