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