开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
HTBTree.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：26k
源码类别：

浏览器

开发平台：

Unix_Linux

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