home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume12 / cake / part03 / print.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-10-14  |  4.8 KB  |  304 lines
  1. /*
  2. **    Printout routines for Cake data structures.
  3. */
  4.  
  5. #ifdef    CAKEDEBUG
  6.  
  7. static    char
  8. rcs_id[] = "$Header: /mip/zs/src/sys/cake/RCS/print.c,v 1.15 87/10/05 20:15:33 zs Exp $";
  9.  
  10. #include    "cake.h"
  11.  
  12. char *
  13. str_pflag(flag)
  14. reg    int    flag;
  15. {
  16.     char        buf[256];
  17.  
  18.     strcpy(buf, "[");
  19.     if (flag & nf_NONVOL)
  20.         strcat(buf, "nonvol ");
  21.     if (flag & nf_PRECIOUS)
  22.         strcat(buf, "precious ");
  23.     if (flag & nf_PSEUDO)
  24.         strcat(buf, "pseudo ");
  25.     if (flag & nf_REDUNDANT)
  26.         strcat(buf, "redundant ");
  27.     if (flag & nf_WHEN)
  28.         strcat(buf, "when ");
  29.     if (flag & nf_DEPNONVOL)
  30.         strcat(buf, "depnonvol ");
  31.     if (flag & nf_NODELETE)
  32.         strcat(buf, "nodelete ");
  33.     if (flag & nf_NEWFILE)
  34.         strcat(buf, "newfile ");
  35.     if (flag & nf_EXIST)
  36.         strcat(buf, "exist ");
  37.     if (flag & nf_BUSY)
  38.         strcat(buf, "busy ");
  39.     if (flag & nf_ERR)
  40.         strcat(buf, "err ");
  41.     if (flag & nf_TRACED)
  42.         strcat(buf, "traced ");
  43.     if (flag & nf_WARNED)
  44.         strcat(buf, "warned ");
  45.     if (flag & nf_ORIG)
  46.         strcat(buf, "orig ");
  47.  
  48.     if (strlen(buf) > 1)
  49.         buf[strlen(buf)-1] = '\0';
  50.  
  51.     strcat(buf, "]");
  52.     return new_name(buf);
  53. }
  54.  
  55. char *
  56. str_aflag(flag)
  57. reg    int    flag;
  58. {
  59.     char        buf[128];
  60.  
  61.     strcpy(buf, "[");
  62.     if (flag & af_SILENT)
  63.         strcat(buf, "silent ");
  64.     if (flag & af_IGNORE)
  65.         strcat(buf, "ignore ");
  66.     if (flag & af_MINUSN)
  67.         strcat(buf, "minusn ");
  68.     if (flag & af_SYSTEM)
  69.         strcat(buf, "system ");
  70.     if (flag & af_SCRIPT)
  71.         strcat(buf, "script ");
  72.  
  73.     if (strlen(buf) > 1)
  74.         buf[strlen(buf)-1] = '\0';
  75.  
  76.     strcat(buf, "]");
  77.     return new_name(buf);
  78. }
  79.  
  80. print_pat(pat)
  81. reg    Pat    *pat;
  82. {
  83.     if (pat->p_cmd)
  84.         printf("`%s`", pat->p_str);
  85.     else
  86.         printf("%s", pat->p_str);
  87.  
  88.     printf(str_pflag(pat->p_flag));
  89. }
  90.  
  91. print_act(act)
  92. reg    Act    *act;
  93. {
  94.     printf(str_aflag(act->a_flag));
  95.     printf("%s", act->a_str);
  96. }
  97.  
  98. print_test(test)
  99. reg    Test    *test;
  100. {
  101.     reg    List    *ptr;
  102.     reg    char    *pre;
  103.     reg    Pat    *pat;
  104.  
  105.     if (test == NULL)
  106.     {
  107.         printf("null");
  108.         return;
  109.     }
  110.  
  111.     switch (test->t_kind)
  112.     {
  113.  
  114. when t_TRUE:    printf("true");
  115. when t_FALSE:    printf("false");
  116.  
  117. when t_AND:    print_test(test->t_left);
  118.         printf(" and ");
  119.         print_test(test->t_right);
  120.  
  121. when t_OR:    print_test(test->t_left);
  122.         printf(" or ");
  123.         print_test(test->t_right);
  124.  
  125. when t_NOT:    printf("not ");
  126.         print_test(test->t_left);
  127.  
  128. when t_CMD:    printf("cmd `%s`", test->t_cmd);
  129.  
  130. when t_MATCH:    printf("match ");
  131.         print_pat(test->t_pat);
  132.         printf(" against");
  133.         printf(" (");
  134.         print_pat((Pat *) first(test->t_list));
  135.         printf(") ");
  136.         print_pat((Pat *) last(test->t_list));
  137.  
  138. when t_LIST:    printf("list ");
  139.         print_pat(test->t_pat);
  140.  
  141.         printf(" in (");
  142.         pre = "";
  143.         for_list (ptr, test->t_list)
  144.         {
  145.             pat = (Pat *) ldata(ptr);
  146.             printf(pre);
  147.             print_pat(pat);
  148.             pre = ", ";
  149.         }
  150.  
  151.         printf(")");
  152.  
  153. when t_EXIST:    printf("exist ");
  154.         print_pat(test->t_pat);
  155.  
  156. when t_CANDO:    printf("cando ");
  157.         print_pat(test->t_pat);
  158.  
  159. when t_OK:    printf("ok ");
  160.         print_pat(test->t_pat);
  161.  
  162. otherwise:    printf("Bad type kind %d in print_test\n", test->t_kind);
  163.  
  164.     }
  165. }
  166.  
  167. print_entry(entry)
  168. reg    Entry    *entry;
  169. {
  170.     reg    List    *ptr;
  171.     reg    Pat    *pat;
  172.     reg    Act    *act;
  173.     reg    char    *pre;
  174.  
  175.     printf("ENTRY\nnew: ");
  176.     pre = "";
  177.     for_list (ptr, entry->e_new)
  178.     {
  179.         pat = (Pat *) ldata(ptr);
  180.         printf(pre);
  181.         print_pat(pat);
  182.         pre = ", ";
  183.     }
  184.  
  185.     printf("\nold: ");
  186.     pre = "";
  187.     for_list (ptr, entry->e_old)
  188.     {
  189.         pat = (Pat *) ldata(ptr);
  190.         printf(pre);
  191.         print_pat(pat);
  192.         pre = ", ";
  193.     }
  194.  
  195.     printf("\nwhen: ");
  196.     pre = "";
  197.     for_list (ptr, entry->e_when)
  198.     {
  199.         pat = (Pat *) ldata(ptr);
  200.         printf(pre);
  201.         print_pat(pat);
  202.         pre = ", ";
  203.     }
  204.  
  205.     printf("\ntest: ");
  206.     print_test(entry->e_cond);
  207.  
  208.     printf("\nactions:\n");
  209.     for_list (ptr, entry->e_act)
  210.     {
  211.         act = (Act *) ldata(ptr);
  212.         print_act(act);
  213.     }
  214.  
  215.     printf("\n");
  216. }
  217.  
  218. char *
  219. str_nkind(nkind)
  220. reg    N_kind    nkind;
  221. {
  222.     switch (nkind)
  223.     {
  224. when n_OK:    return "ok";
  225. when n_NOWAY:    return "noway";
  226. when n_CANDO:    return "cando";
  227.     }
  228.  
  229.     return "bizarre";
  230. }
  231.  
  232. print_time(str, ntime)
  233. reg    char    *str;
  234. time_t        ntime;
  235. {
  236.     extern    char    *ctime();
  237.  
  238.     printf("%s time: %d, %s", str, ntime, ctime(&ntime));
  239. }
  240.  
  241. print_node(node)
  242. reg    Node    *node;
  243. {
  244.     reg    List    *ptr;
  245.     reg    char    *pre;
  246.     reg    Node    *bnode;
  247.     reg    Act    *act;
  248.  
  249.     printf("\nNODE\n%s: kind %s flag %s\n", node->n_name, 
  250.         str_nkind(node->n_kind), str_pflag(node->n_flag));
  251.     print_time("real",  node->n_rtime);
  252.     print_time("used",  node->n_utime);
  253.     print_time("saved", node->n_stime);
  254.  
  255.     printf("new: ");
  256.     pre = "";
  257.     for_list (ptr, node->n_new)
  258.     {
  259.         bnode = (Node *) ldata(ptr);
  260.         printf(pre);
  261.         printf(bnode->n_name);
  262.         pre = ", ";
  263.     }
  264.  
  265.     printf("\nold: ");
  266.     pre = "";
  267.     for_list (ptr, node->n_old)
  268.     {
  269.         bnode = (Node *) ldata(ptr);
  270.         printf(pre);
  271.         printf(bnode->n_name);
  272.         pre = ", ";
  273.     }
  274.  
  275.     printf("\naction:\n");
  276.     for_list (ptr, node->n_act)
  277.     {
  278.         act = (Act *) ldata(ptr);
  279.         print_act(act);
  280.     }
  281.  
  282.     if (node->n_badguys != (List *) NULL)
  283.     {
  284.         printf("bad guys: ");
  285.         pre = "";
  286.         for_list (ptr, node->n_badguys)
  287.         {
  288.             bnode = (Node *) ldata(ptr);
  289.             printf(pre);
  290.             printf(bnode->n_name);
  291.             pre = ", ";
  292.         }
  293.  
  294.         printf("\n");
  295.     }
  296.  
  297.     if (node->n_msg != NULL)
  298.         printf("msg: %s", node->n_msg);
  299.  
  300.     printf("\n");
  301. }
  302.  
  303. #endif
  304.