home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 297_01 / prprint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-23  |  9.7 KB  |  433 lines
  1. /* prprint.c */
  2. /* Print functions.
  3.  * It's up to you to improve pr_string(),
  4.  * which relies on global variables to know where to output.
  5.  * This means you could even output on a string.
  6.  */
  7. #include <stdio.h>
  8. #include <ctype.h>
  9. #include "prtypes.h"
  10. #include "prlex.h"
  11.  
  12. #ifndef NDEBUG
  13. #define CHK(X) if(!check_object(X))INTERNAL_ERROR("wild pointer");
  14. #endif 
  15.  
  16.  
  17. extern char *Print_buffer;
  18. extern atom_ptr_t Nil;
  19. extern node_ptr_t DerefNode;
  20. extern subst_ptr_t DerefSubst;
  21.  
  22. FILE * Curr_outfile;
  23. extern node_ptr_t Printing_var_nodeptr;
  24.  
  25.  
  26. /*******************************************************************
  27.             prompt_user()
  28. You might want to empty the keyboard buffer here.
  29.  *******************************************************************/
  30.  
  31. prompt_user()
  32. {
  33. #ifdef LINE_EDITOR /* not provided */
  34.     empty_buffer();
  35. #endif
  36.     return(tty_pr_string("?-"));
  37. }
  38.  
  39.  
  40. /*******************************************************************
  41.             pr_solution()
  42.  Used when answering yes to a query.
  43.  *******************************************************************/
  44.  
  45. pr_solution(nvar, substptr)
  46. varindx nvar;
  47. subst_ptr_t substptr;
  48. {
  49.     extern char *Var2Names[];
  50.     extern int Tracing_now;
  51.     varindx i;
  52.     char *molec;
  53.  
  54.     tty_pr_string("yes\n");
  55.  
  56.     for(i = 0; i< nvar; i ++)
  57.     {
  58.         if(Var2Names[i] == NULL)INTERNAL_ERROR("VARNAME");
  59.         NODEPTR_OFFSET(Printing_var_nodeptr) = i * sizeof(struct subst);
  60.         molec = (char *)substptr + NODEPTR_OFFSET(Printing_var_nodeptr);
  61.         if((((subst_ptr_t)molec)->skel) == NULL)
  62.             continue;/* noreference */
  63.         tty_pr_string(Var2Names[i]);
  64.         tty_pr_string(" = ");
  65.         tty_out_node(Printing_var_nodeptr, substptr);
  66.         tty_pr_string("\n");
  67.     }
  68. }
  69.  
  70. #ifdef CHARACTER
  71. /******************************************************************************
  72.             print_character()
  73. Print a character as nicely as possible (like the C language char data )
  74.  ******************************************************************************/
  75. print_character(c)
  76. uchar_t c;
  77. {
  78.         if(isprint(c))          
  79.           {
  80.            sprintf(Print_buffer, "'%c'", c);
  81.            return(pr_string(Print_buffer));
  82.           }
  83.         else
  84.         switch(c)
  85.         {
  86.         case '\t':
  87.         return(pr_string("'\\t'"));
  88.         break;
  89.  
  90.         case '\v':
  91.         return(pr_string("'\\v'"));
  92.         break;
  93.  
  94.         case '\f':
  95.         return(pr_string("'\\f'"));
  96.         break;
  97.  
  98.         case '\n':
  99.         return(pr_string("'\\n'"));
  100.         break;
  101.  
  102.  
  103.         case '\r':
  104.         return(pr_string("'\\r'"));
  105.         break;
  106.  
  107.         default :
  108.         sprintf(Print_buffer, "'\\%o'", c);
  109.         return(pr_string(Print_buffer));
  110.         }
  111. }
  112. #endif
  113.  
  114. /*******************************************************************
  115.             out_node()
  116. Print the instantiated version of an object.
  117. The object exists only in a virtual way, dereferencing is the way
  118. of getting at the values of those variables.
  119.  *******************************************************************/
  120.  
  121. out_node(nodeptr, substptr)
  122. node_ptr_t nodeptr; /* this is the object to print */
  123. subst_ptr_t substptr;/* this gives you the variable values */
  124. {
  125.     extern long offset_subst();/* from pralloc.c */
  126.     atom_ptr_t atomptr;
  127.     varindx offset;
  128.  
  129.     dereference(nodeptr, substptr);
  130.     nodeptr = DerefNode;
  131.     substptr = DerefSubst;
  132.  
  133.     switch(NODEPTR_TYPE(nodeptr))
  134.     {
  135.     case ATOM:
  136.         atomptr = NODEPTR_ATOM(nodeptr);
  137.         return(pr_string(atomptr->name));
  138.  
  139.     case VAR:
  140.         offset = NODEPTR_OFFSET(nodeptr);
  141.         sprintf(Print_buffer, "_%d_%ld", offset/sizeof(struct subst),
  142.             offset_subst(substptr));
  143.         return(pr_string(Print_buffer));
  144.  
  145.     case STRING:
  146.         sprintf(Print_buffer, "%c%s%c", STRING_QUOTE,
  147.             NODEPTR_STRING(nodeptr),
  148.             STRING_QUOTE);
  149.         return(pr_string(Print_buffer));
  150.  
  151. #ifdef REAL
  152.     case REAL:
  153.         sprintf(Print_buffer, "%f", NODEPTR_REAL(nodeptr));
  154.         return(pr_string(Print_buffer));
  155. #endif
  156.  
  157.     case INT:
  158.         sprintf(Print_buffer, "%ld", NODEPTR_INT(nodeptr));
  159.         return(pr_string(Print_buffer));
  160.  
  161.     case PAIR:
  162.         return(out_pair(nodeptr, substptr));
  163.  
  164.     case CLAUSE:
  165.         return(pr_string("<clause>")); /* not normally printed */
  166.  
  167. #ifdef CHARACTER
  168.     case CHARACTER:
  169.         return(print_character(NODEPTR_CHARACTER(nodeptr)));
  170. #endif
  171.     default:
  172.         INTERNAL_ERROR("unknown type");
  173.     }
  174. }
  175.  
  176. /*******************************************************************
  177.             out_pair()
  178.  Print a list.
  179.  *******************************************************************/
  180.  
  181. out_pair(listnode, substptr)
  182. node_ptr_t listnode;
  183. subst_ptr_t substptr;
  184. {
  185.     int len;
  186.     len = pr_string("(");
  187.     len += out1_pair(listnode, substptr);
  188.     return(len);
  189. }
  190.  
  191. out1_pair(nodeptr, substptr)
  192. node_ptr_t nodeptr;
  193. subst_ptr_t substptr;
  194. {
  195.     node_ptr_t tailptr;
  196.     int len;
  197.  
  198.     len = out_node(NODEPTR_HEAD(nodeptr), substptr);
  199.     tailptr = NODEPTR_TAIL(nodeptr);
  200.     dereference(tailptr, substptr);
  201.  
  202.     if(IS_NIL(DerefNode))
  203.     {
  204.         len += pr_string(")");
  205.     }
  206.     else
  207.         if(NODEPTR_TYPE(DerefNode) == PAIR)
  208.         {
  209.             len += pr_string(" ");
  210.             len += out1_pair(DerefNode, DerefSubst);
  211.         }
  212.         else
  213.         {
  214.             len += pr_string(CONS_STR);
  215.             len += out_node(DerefNode, DerefSubst);
  216.             len += pr_string(")");
  217.         }
  218. return(len);
  219. }
  220.  
  221.  
  222.  
  223.  
  224.  
  225. /******************************************************************************
  226.              tty_out_node();
  227. Output to the screen, independently of Curr_outfile.
  228.  ******************************************************************************/
  229. tty_out_node(nodeptr, substptr)
  230. node_ptr_t nodeptr;
  231. subst_ptr_t substptr;
  232. {
  233. FILE *save_ofp;
  234. int len;
  235.  
  236. save_ofp = Curr_outfile;
  237. Curr_outfile = stdout;
  238. len = out_node(nodeptr, substptr);
  239. Curr_outfile = save_ofp;
  240. return(len);
  241. }
  242.  
  243.  
  244. /*******************************************************************
  245.             pr_node()
  246. Print the uninstantiated version of a node.
  247. This is here for source-level debugging.
  248.  *******************************************************************/
  249.  
  250. pr_node(nodeptr)
  251. node_ptr_t nodeptr;
  252. {
  253.     atom_ptr_t atomptr;
  254.     varindx offset;
  255.  
  256.     CHK(nodeptr);
  257.  
  258.     switch(NODEPTR_TYPE(nodeptr))
  259.     {
  260.     case ATOM:
  261.         atomptr = NODEPTR_ATOM(nodeptr);
  262.         return(pr_string(atomptr->name));
  263.  
  264.     case VAR:
  265.         offset = NODEPTR_OFFSET(nodeptr);
  266.         sprintf(Print_buffer, "_%d", offset/sizeof(struct subst));
  267.         return(pr_string(Print_buffer));
  268.  
  269.     case STRING:
  270.         sprintf(Print_buffer, "%c%s%c", STRING_QUOTE,
  271.             NODEPTR_STRING(nodeptr),
  272.             STRING_QUOTE);
  273.         return(pr_string(Print_buffer));
  274.  
  275. #ifdef REAL
  276.     case REAL:
  277.         sprintf(Print_buffer, "%f", NODEPTR_REAL(nodeptr));
  278.         return(pr_string(Print_buffer));
  279. #endif
  280.  
  281.     case INT:
  282.         sprintf(Print_buffer, "%ld", NODEPTR_INT(nodeptr));
  283.         return(pr_string(Print_buffer));
  284.  
  285.     case PAIR:
  286.         return(pr_pair(NODEPTR_PAIR(nodeptr)));
  287.  
  288.     case CLAUSE :
  289.         return(pr_clause(NODEPTR_CLAUSE(nodeptr)));/* just for debug */
  290.  
  291. #ifdef CHARACTER
  292.     case CHARACTER:
  293.         return(print_character(NODEPTR_CHARACTER(nodeptr)));
  294. #endif
  295.     default:
  296.         INTERNAL_ERROR("unknown type");
  297.         return (-1);
  298.     }
  299. }
  300.  
  301.  
  302. /*******************************************************************
  303.             pr_pair()
  304.  *******************************************************************/
  305.  
  306. pr_pair(pairptr)
  307. pair_ptr_t pairptr;
  308. {
  309.     int len;
  310.  
  311.     len = pr_string("(");
  312.     len += pr1_pair(pairptr);
  313.     return(len);
  314. }
  315.  
  316. /*******************************************************************
  317.             pr1_pair()
  318.  used by pr_pair only.
  319.  *******************************************************************/
  320.  
  321. pr1_pair(pairptr)
  322. pair_ptr_t pairptr;
  323. {
  324.     node_ptr_t tailptr;
  325.     objtype_t tailtype;
  326.     int len = 0;
  327.  
  328.     len += pr_node(PAIRPTR_HEAD(pairptr));
  329.     tailptr = PAIRPTR_TAIL(pairptr);
  330.  
  331.     tailtype = NODEPTR_TYPE(tailptr);
  332.  
  333.     if((tailtype == ATOM) && (NODEPTR_ATOM(tailptr) == Nil))
  334.     {
  335.         len += pr_string(")");
  336.         
  337.     }
  338.     else
  339.         if(tailtype == PAIR)
  340.         {
  341.             len += pr_string(" ");
  342.             len += pr1_pair(NODEPTR_PAIR(tailptr));
  343.         }
  344.         else
  345.         {
  346.             len += pr_string(CONS_STR);
  347.             len += pr_node(tailptr);
  348.             len += pr_string(")");
  349.         }
  350. return(len);
  351. }
  352.  
  353.  
  354. /*******************************************************************
  355.             pr_clause()
  356.  You might modify this to make it pretty-print
  357.  *******************************************************************/
  358.  
  359. pr_clause(clauseptr)
  360. clause_ptr_t clauseptr;
  361. {
  362.     int len;
  363.  
  364.     len = pr_string("(");
  365.     len += pr_node(CLAUSEPTR_HEAD(clauseptr));
  366.     if(IS_FACT(clauseptr))
  367.     {
  368.         len += pr_string(")");
  369.     }
  370.     else
  371.     {
  372.         node_ptr_t goals;
  373.         goals = CLAUSEPTR_GOALS(clauseptr);
  374.         len += pr1_pair(NODEPTR_PAIR(goals));
  375.     }
  376.     len += pr_string("\n");
  377. return(len);
  378. }
  379.  
  380. /*******************************************************************
  381.             pr_packet()
  382. Print all clauses pertaining to a predicate.
  383.  *******************************************************************/
  384. pr_packet(clauseptr)
  385. clause_ptr_t clauseptr;/* Usually the first clause of the predicate */
  386. {
  387.     int len = 0;
  388.  
  389.     while(clauseptr)
  390.     {
  391.         len += pr_clause(clauseptr);
  392.         clauseptr = CLAUSEPTR_NEXT(clauseptr);
  393.     }
  394.  
  395.     return(len);
  396. }
  397.  
  398.  
  399. /******************************************************************************
  400.             maplist
  401.  Here is a function you may care to use.
  402.  Applies a function to each element of a list, which may exist in a 
  403. virtual way, as expected in a structure sharing implementation.
  404.  Returns the sum total of the function values as the function descends the
  405.  list.
  406.  ******************************************************************************/
  407. maplist(listnode, substptr , fn)
  408. node_ptr_t listnode;
  409. subst_ptr_t substptr; /* environment of the list */
  410. intfun fn;        /* the function to apply   */
  411. {
  412. int value, total = 0;
  413.  
  414.     while(1 )
  415.     {
  416.         dereference(NODEPTR_HEAD(listnode), substptr);
  417.         if((value = (*fn)(DerefNode, DerefSubst)) == 0)
  418.             return 0;
  419.         else
  420.         total += value;
  421.         dereference(NODEPTR_TAIL(listnode), substptr);
  422.         if(NODEPTR_TYPE(DerefNode) != PAIR)
  423.         {
  424.             return total;
  425.         }
  426.         listnode = DerefNode;
  427.         substptr = DerefSubst;
  428.  
  429.     }
  430. }
  431.  
  432. /* end of file */
  433.