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