home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / icon / dos / src / icont / tree.c < prev    next >
C/C++ Source or Header  |  1992-02-10  |  4KB  |  199 lines
  1. /*
  2.  * tree.c -- functions for constructing parse trees
  3.  */
  4.  
  5. #include "../h/gsupport.h"
  6. #include "tproto.h"
  7. #include "tree.h"
  8.  
  9. /*
  10.  *  tree[1-6] construct parse tree nodes with specified values.  tfree
  11.  *   points at the next free word in the parse tree space.  Nodes are
  12.  *   built by copying argument values into successive locations starting
  13.  *   at tfree.  Parameters a and b are line and column information,
  14.  *   while parameters c through f are values to be assigned to n_field[0-3].
  15.  *   Note that this could be done with a single routine; a separate routine
  16.  *   for each node size is used for speed and simplicity.
  17.  */
  18.  
  19. nodeptr tree1(type)
  20. int type;
  21.    {
  22.    register nodeptr t;
  23.  
  24.    t = tfree;
  25.    tfree = (nodeptr) ((word *)tfree + 1);
  26.    if (tfree > tend)
  27.       tsyserr("out of tree space");
  28.    t->n_type = type;
  29.    return t;
  30.    }
  31.  
  32. nodeptr tree2(type, loc_model)
  33. int type;
  34. nodeptr loc_model;
  35.    {
  36.    register nodeptr t;
  37.  
  38.    t = tfree;
  39.    tfree = (nodeptr) ((word *)tfree + 4);
  40.    if (tfree > tend)
  41.       tsyserr("out of tree space");
  42.    t->n_type = type;
  43.    t->n_file = loc_model->n_file;
  44.    t->n_line = loc_model->n_line;
  45.    t->n_col = loc_model->n_col;
  46.    return t;
  47.    }
  48.  
  49. nodeptr tree3(type, loc_model, c)
  50. int type;
  51. nodeptr loc_model;
  52. nodeptr c;
  53.    {
  54.    register nodeptr t;
  55.  
  56.    t = tfree;
  57.    tfree = (nodeptr) ((word *)tfree + 5);
  58.    if (tfree > tend)
  59.       tsyserr("out of tree space");
  60.    t->n_type = type;
  61.    t->n_file = loc_model->n_file;
  62.    t->n_line = loc_model->n_line;
  63.    t->n_col = loc_model->n_col;
  64.    t->n_field[0].n_ptr = c;
  65.    return t;
  66.    }
  67.  
  68. nodeptr tree4(type, loc_model, c, d)
  69. int type;
  70. nodeptr loc_model;
  71. nodeptr c, d;
  72.    {
  73.    register nodeptr t;
  74.  
  75.    t = tfree;
  76.    tfree = (nodeptr) ((word *)tfree + 6);
  77.    if (tfree > tend)
  78.       tsyserr("out of tree space");
  79.    t->n_type = type;
  80.    t->n_file = loc_model->n_file;
  81.    t->n_line = loc_model->n_line;
  82.    t->n_col = loc_model->n_col;
  83.    t->n_field[0].n_ptr = c;
  84.    t->n_field[1].n_ptr = d;
  85.    return t;
  86.    }
  87.  
  88. nodeptr tree5(type, loc_model, c, d, e)
  89. int type;
  90. nodeptr loc_model;
  91. nodeptr c, d, e;
  92.    {
  93.    register nodeptr t;
  94.  
  95.    t = tfree;
  96.    tfree = (nodeptr) ((word *)tfree + 7);
  97.    if (tfree > tend)
  98.       tsyserr("out of tree space");
  99.    t->n_type = type;
  100.    t->n_file = loc_model->n_file;
  101.    t->n_line = loc_model->n_line;
  102.    t->n_col = loc_model->n_col;
  103.    t->n_field[0].n_ptr = c;
  104.    t->n_field[1].n_ptr = d;
  105.    t->n_field[2].n_ptr = e;
  106.    return t;
  107.    }
  108.  
  109. nodeptr tree6(type, loc_model, c, d, e, f)
  110. int type;
  111. nodeptr loc_model;
  112. nodeptr c, d, e, f;
  113.    {
  114.    register nodeptr t;
  115.  
  116.    t = tfree;
  117.    tfree = (nodeptr) ((word *)tfree + 8);
  118.    if (tfree > tend)
  119.       tsyserr("out of tree space");
  120.    t->n_type = type;
  121.    t->n_file = loc_model->n_file;
  122.    t->n_line = loc_model->n_line;
  123.    t->n_col = loc_model->n_col;
  124.    t->n_field[0].n_ptr = c;
  125.    t->n_field[1].n_ptr = d;
  126.    t->n_field[2].n_ptr = e;
  127.    t->n_field[3].n_ptr = f;
  128.    return t;
  129.    }
  130.  
  131. nodeptr int_leaf(type, loc_model, c)
  132. int type;
  133. nodeptr loc_model;
  134. int c;
  135.    {
  136.    register nodeptr t;
  137.  
  138.    t = tfree;
  139.    tfree = (nodeptr) ((word *)tfree + 5);
  140.    if (tfree > tend)
  141.       tsyserr("out of tree space");
  142.    t->n_type = type;
  143.    t->n_file = loc_model->n_file;
  144.    t->n_line = loc_model->n_line;
  145.    t->n_col = loc_model->n_col;
  146.    t->n_field[0].n_val = c;
  147.    return t;
  148.    }
  149.  
  150. nodeptr c_str_leaf(type, loc_model, c)
  151. int type;
  152. nodeptr loc_model;
  153. char *c;
  154.    {
  155.    register nodeptr t;
  156.  
  157.    t = tfree;
  158.    tfree = (nodeptr) ((word *)tfree + 5);
  159.    if (tfree > tend)
  160.       tsyserr("out of tree space");
  161.    t->n_type = type;
  162.    t->n_file = loc_model->n_file;
  163.    t->n_line = loc_model->n_line;
  164.    t->n_col = loc_model->n_col;
  165.    t->n_field[0].n_str = c;
  166.    return t;
  167.    }
  168.  
  169. nodeptr i_str_leaf(type, loc_model, c, d)
  170. int type;
  171. nodeptr loc_model;
  172. char *c;
  173. int d;
  174.    {
  175.    register nodeptr t;
  176.  
  177.    t = tfree;
  178.    tfree = (nodeptr) ((word *)tfree + 6);
  179.    if (tfree > tend)
  180.       tsyserr("out of tree space");
  181.    t->n_type = type;
  182.    t->n_file = loc_model->n_file;
  183.    t->n_line = loc_model->n_line;
  184.    t->n_col = loc_model->n_col;
  185.    t->n_field[0].n_str = c;
  186.    t->n_field[1].n_val = d;
  187.    return t;
  188.    }
  189.  
  190. /*
  191.  * Clear the tree space by setting the free pointer back to the first word
  192.  *  of the tree space.
  193.  */
  194.  
  195. novalue treeinit()
  196.    {
  197.    tfree = tree;
  198.    }
  199.