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