home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume12 / cake / part03 / make.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-10-14  |  2.9 KB  |  201 lines

  1. /*
  2. **    Module to make Cake data structures.
  3. */
  4.  
  5. static    char
  6. rcs_id[] = "$Header: /mip/zs/src/sys/cake/RCS/make.c,v 1.15 87/10/05 20:15:02 zs Exp $";
  7.  
  8. #include    "cake.h"
  9.  
  10. Node *
  11. make_node(name)
  12. reg    char    *name;
  13. {
  14.     reg    Node    *node;
  15.  
  16.     node = make(Node);
  17.     node->n_name    = name;
  18.  
  19.     if (name == NULL)
  20.         return node;
  21.  
  22.     node->n_kind = n_NOWAY;        /* not yet */
  23.     node->n_flag = 0;
  24.     node->n_old  = makelist0();
  25.     node->n_when = NULL;
  26.     node->n_act  = NULL;
  27.     node->n_new  = makelist(node);
  28. #if 0    /* N must be 1 for the time being */
  29.     node->n_pid  = 0;
  30.     node->n_file = NULL;
  31. #endif
  32.     node_stat(node);
  33.     node->n_utime   = 0;
  34.     node->n_stime   = node->n_rtime;
  35.     node->n_badguys = NULL;
  36.     node->n_msg     = NULL;
  37.  
  38.     return node;
  39. }
  40.  
  41. Entry *
  42. make_dep(new, old, cond, file, colon)
  43. reg    List    *new;                /* of Pat    */
  44. reg    List    *old;                /* of Pat    */
  45. reg    Test    *cond;
  46. reg    char    *file;
  47. reg    char    *colon;
  48. {
  49.     reg    Entry    *entry;
  50.  
  51.     entry = make(Entry);
  52.     entry->e_new  = new;
  53.     entry->e_old  = old;
  54.     entry->e_cond = cond;
  55.     entry->e_file = file;
  56.     entry->e_dblc = streq(colon, "::");
  57.     entry->e_when = makelist0();
  58.  
  59.     return entry;
  60. }
  61.  
  62. Test *
  63. make_test_mm(name)
  64. reg    Pat    *name;
  65. {
  66.     reg    Test    *test;
  67.  
  68.     test = make(Test);
  69.     test->t_kind = t_MATCH;
  70.     test->t_pat  = name;
  71.     test->t_list = makelist0();
  72.  
  73.     return test;
  74. }
  75.  
  76. Test *
  77. make_test_m(name, varpat, pattern)
  78. reg    Pat    *name;
  79. reg    Pat    *varpat;
  80. reg    Pat    *pattern;
  81. {
  82.     reg    Test    *test;
  83.  
  84.     test = make(Test);
  85.     test->t_kind = t_MATCH;
  86.     test->t_pat  = name;
  87.     test->t_list = makelist0();
  88.  
  89.     if (varpat == NULL)
  90.         addtail(test->t_list, make_pat("-vX", FALSE, 0));
  91.     else
  92.         addtail(test->t_list, varpat);    /* no assignment */
  93.  
  94.     addtail(test->t_list, pattern);        /* no assignment */
  95.     return test;
  96. }
  97.  
  98. Test *
  99. make_test_c(cmd)
  100. reg    char    *cmd;
  101. {
  102.     reg    Test    *test;
  103.  
  104.     test = make(Test);
  105.     test->t_kind = t_CMD;
  106.     test->t_cmd  = cmd;
  107.  
  108.     return test;
  109. }
  110.  
  111. Test *
  112. make_test_s(tkind, pat)
  113. reg    T_kind    tkind;
  114. reg    Pat    *pat;
  115. {
  116.     reg    Test    *test;
  117.  
  118.     test = make(Test);
  119.     test->t_kind = tkind;
  120.     test->t_pat  = pat;
  121.  
  122.     return test;
  123. }
  124.  
  125. Test *
  126. make_test_l(pat, list)
  127. reg    Pat    *pat;
  128. reg    List    *list;                /* of Pat    */
  129. {
  130.     reg    Test    *test;
  131.  
  132.     test = make(Test);
  133.     test->t_kind = t_LIST;
  134.     test->t_pat  = pat;
  135.     test->t_list = list;
  136.  
  137.     return test;
  138. }
  139.  
  140. Test *
  141. make_test_b(tkind, left, right)
  142. reg    T_kind    tkind;
  143. reg    Test    *left;
  144. reg    Test    *right;
  145. {
  146.     reg    Test    *test;
  147.  
  148.     test = make(Test);
  149.     test->t_kind  = tkind;
  150.     test->t_left  = left;
  151.     test->t_right = right;
  152.  
  153.     return test;
  154. }
  155.  
  156. Test *
  157. make_test_u(tkind, left)
  158. reg    T_kind    tkind;
  159. reg    Test    *left;
  160. {
  161.     reg    Test    *test;
  162.  
  163.     test = make(Test);
  164.     test->t_kind  = tkind;
  165.     test->t_left  = left;
  166.     test->t_right = (Test *) NULL;
  167.  
  168.     return test;
  169. }
  170.  
  171. Pat *
  172. make_pat(text, iscmd, flags)
  173. reg    char    *text;
  174. reg    bool    iscmd;
  175. reg    int    flags;
  176. {
  177.     reg    Pat    *pat;
  178.  
  179.     pat = make(Pat);
  180.     pat->p_str  = text;
  181.     pat->p_cmd  = iscmd;
  182.     pat->p_flag = flags;
  183.  
  184.     checkpatlen(text);
  185.     return pat;
  186. }
  187.  
  188. Act *
  189. make_act(str, flag)
  190. reg    char    *str;
  191. reg    int    flag;
  192. {
  193.     reg    Act    *act;
  194.  
  195.     act = make(Act);
  196.     act->a_str  = str;
  197.     act->a_flag = flag;
  198.  
  199.     return act;
  200. }
  201.