home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / SCIENCE / STAGES12.ZIP / PRINTS2.C < prev    next >
Text File  |  1991-04-21  |  31KB  |  1,088 lines
  1. #include "header.h"
  2. #include "file.h"
  3.  
  4. /************************************************************************/
  5. /**    print routines: part 2                           **/
  6. /************************************************************************/
  7. /* contains:    printusrcells
  8.            printresulthdr
  9.         printresults
  10.         prresF
  11.         prresB
  12.         printepi
  13.         getcellname
  14.         printexit
  15.         printHARDCOPY
  16.         printFILECOPY
  17.         printCycleTime
  18.         printline
  19.         printresHARD
  20. */
  21.  
  22. static int printresulthdr(int fileq);
  23. static int prresF(char *daystr, int *cell, int *len,
  24.           char *cellstr, int *ok, int okcell, int oknum,
  25.           int endspot, char *opstr1, char *opstr2);
  26. static int prresB(char *daystr, int *cell, int *len,
  27.           char *cellstr, int *ok, int okcell, int oknum,
  28.           int endspot, char *opstr1, char *opstr2);
  29. static int getcellname(int i, int *cell, char *cellname,
  30.                char dir, int endspot);
  31.  
  32.  
  33. /********************************/
  34. /*     function: printusrcells    */
  35. /********************************/
  36. /* prints out a list of the user-entered input cells
  37.    (interactive mode only) */
  38. printusrcells (cellstrs, trials)
  39.   char cellstrs[][MAXIPLEN];
  40.   int trials;
  41. {
  42.   int i;
  43. #if PC
  44.   int j;
  45. #endif
  46.  
  47.   if (! trials)
  48.     return(0);
  49.  
  50. #if PC
  51.   j = 1;
  52.   clrscr1(3);
  53.   gotoxy(4, j++);
  54.   cprintf("These are the input cells:");
  55.   gotoxy(6, j);
  56.   if (HARDCOPY) {
  57.     fprintf(stdprn, "\tThese are the input cells:");
  58.     fprintf(stdprn, "\n\t\t");
  59.   }
  60. #else
  61.   printf("\tThese are the input cells:\n\t\t");
  62. #endif
  63.   if (FILEq && FILECOPY)
  64.     fprintf(fpout, "\tThese are the input cells:\n\t\t");
  65.  
  66.   for ( i=0; i<trials; i++ ) {
  67. #if PC
  68.     if ((j >= MSGLNS) && (wherex() >= 65)) {
  69.       /* end of last line of window reached */
  70.       hitreturn(3);
  71.       clrscr1(3);
  72.       j = 1;
  73.       gotoxy(4, j++);
  74.       cprintf("These are the input cells:");
  75.       gotoxy(6, j);
  76.     } /* if j */
  77.  
  78.     if (i && (wherex() >= 65)) {  /* if xpos near eol, start new ln */
  79. #else
  80.     if (i && ((i % 5)==0)) {    /* after 5 cells, start new line */
  81. #endif
  82. #if PC
  83.       gotoxy(6, ++j);
  84.       if (HARDCOPY)
  85.     fprintf(stdprn, "\n\t\t");
  86. #else
  87.       printf("\n\t\t");
  88. #endif
  89.       if (FILEq && FILECOPY)
  90.     fprintf(fpout, "\n\t\t");
  91.     } /* if time for newline */
  92.  
  93. #if PC
  94.     cprintf("%s   ", cellstrs[i]);
  95.     if (HARDCOPY)
  96.       fprintf(stdprn, "%s   ", cellstrs[i]);
  97. #else
  98.     printf("%s   ", cellstrs[i]);
  99. #endif
  100.     if (FILEq && FILECOPY)
  101.       fprintf(fpout, "%s   ", cellstrs[i]);
  102.   } /* for */
  103.  
  104. #if PC
  105.   if (HARDCOPY)
  106.     fprintf(stdprn, "\n");
  107. #else
  108.   printf("\n");
  109. #endif
  110.   if (FILEq && FILECOPY)
  111.     fprintf(fpout, "\n");
  112.   return(0);
  113. } /* printusrcells */
  114.  
  115. /********************************/
  116. /*     function: printresulthdr    */
  117. /********************************/
  118. /* static means that this function is only used within this file
  119.    saves space in the executable file */
  120. static printresulthdr (fileq)
  121.   int fileq;
  122. {
  123. #if PC
  124.   clrscr1(3);
  125.   clrscr1(2);
  126.   clrscr1(1);
  127.   gotoxy(2, 1);
  128.   cprintf("Init cell     Days%s  1st third", tab);
  129.   cprintf("%s  2nd third%s  3rd third", tab, tab);
  130.   gotoxy(2, 2);
  131.   printline(0, LNWID, '=');
  132.   if (HARDCOPY) {
  133.     fprintf(stdprn, "\nInit cell     Days%s  1st third", tab);
  134.     fprintf(stdprn, "%s  2nd third%s  3rd third\n", tab, tab);
  135.     printline(2, LNWID, '=');
  136.   }
  137.   fprintf(tmpfp, "\nInit cell     Days%s  1st third", tab);
  138.   fprintf(tmpfp, "%s  2nd third%s  3rd third\n", tab, tab);
  139.   printline(5, LNWID, '=');
  140. #else
  141.   printf("\nInit cell     Days%s  1st third", tab);
  142.   printf("%s  2nd third%s  3rd third\n", tab, tab);
  143.   printline(0, LNWID, '=');
  144. #endif
  145.   if (FILEq && FILECOPY)
  146.     if (fileq) {
  147.       fprintf(fpout, "\nInit cell     Days%s  1st third", tab);
  148.       fprintf(fpout, "%s  2nd third%s  3rd third\n", tab, tab);
  149.       printline(1, LNWID, '=');
  150.     }
  151.   return(0);
  152. } /* printresulthdr */
  153.  
  154. /********************************/
  155. /*     function: printresults    */
  156. /********************************/
  157. /*  the functions printresults, prresF and prresB all use a temporary
  158.     output file into which they write their output.
  159.     then if the user decides to print the output on the printer,
  160.     we just dump the file to the printer. */
  161. printresults (dir, days, daystr, cell, cellstr, ok, okcell, oknum,
  162.           endspot, opstr, oncep, epip, opstr1, opstr2)
  163.   char dir;        /* direction: F or B        */
  164.   double days;        /* used if oknum=1        */
  165.   char *daystr;        /* used if oknum=0        */
  166.   int *cell;        /* used if okcell=1: cells reached */
  167.   char *cellstr;    /* used if okcell=0: init cell    */
  168.   int *ok;        /* move ok? from the 4 pts in init stage */
  169.   int okcell, oknum;    /* cell/days valid?        */
  170.   int endspot;        /* which 3d of stage did move end in? */
  171.   char *opstr;        /* err string if move went out of bounds */
  172.   int *oncep;        /* controls outputhdr printing    */
  173.   int *epip;        /* controls printepi printing    */
  174.   char *opstr1,
  175.        *opstr2;        /* strs for when cell ejac but still tracking stgs */
  176. {
  177.   int len[4];        /* CellName lengths    */
  178.   int i;        /* iteration var    */
  179. #if PC
  180.   static int j=1;       /* j = y-pos in the output window (STATIC VAR!) */
  181.   int lines;        /* # lines in output window this output will need */
  182. #endif
  183.  
  184. /* format:
  185. init cell<5>days<10>1st third<10>2nd third<10>3rd third
  186.         1  1    2       3    4       5    6       7
  187. 1    9   5  8    9       7    8       6    7       5   */
  188.   if (! *oncep) {
  189. #if PC
  190.     makedisplay();
  191.     topline(" Stages Output ");
  192.     clrscr1(3);
  193.     clrscr1(1);
  194.     j = 3;
  195. #endif
  196.     *oncep = 1;
  197.     printresulthdr(1);
  198.   } /* if ! oncep */
  199.  
  200. #if PC
  201.   /* determine how many output lines this cell/day input will require;
  202.      if cell ok, only need 2 o/p lines (1 for data, 1 for underline) */
  203.   if ((ok[0] != 1) || (ok[1] !=1 ) || (ok[2] !=1 ) || (ok[3] != 1)) {
  204.     /* final cell epididymis/pre-entry: need 3 extra lines */
  205.     lines = 5;
  206.   } else
  207.     lines = 2;
  208.  
  209.   if (j >= (OUTPUTLNS-lines)) {
  210.     hitreturn(1);
  211.     clrscr1(1);
  212.     printresulthdr(0);
  213.     j = 3;
  214.   }
  215.   outputwin();
  216.   gotoxy(2, j++);
  217. #endif
  218.  
  219.   if (oknum) {
  220. #if PC
  221.     cprintf(" %6s   %8.4lf", cellstr, days);
  222.     if (HARDCOPY)
  223.       fprintf(stdprn, " %6s   %8.4lf", cellstr, days);
  224.     fprintf(tmpfp, " %6s   %8.4lf", cellstr, days);
  225. #else
  226.     printf(" %6s   %8.4lf", cellstr, days);
  227. #endif
  228.     if (FILEq && FILECOPY)
  229.       fprintf(fpout, " %6s   %8.4lf", cellstr, days);
  230.   } else {    /* bad i/p num syntax */
  231. #if PC
  232.     cprintf(" %6s   %8s", cellstr, daystr);
  233.     if (HARDCOPY)
  234.       fprintf(stdprn, " %6s   %8s", cellstr, daystr);
  235.     fprintf(tmpfp, " %6s   %8s", cellstr, daystr);
  236. #else
  237.     printf(" %6s   %8s", cellstr, daystr);
  238. #endif
  239.     if (FILEq && FILECOPY)
  240.       fprintf(fpout, " %6s   %8s", cellstr, daystr);
  241.   } /* if oknum */
  242.  
  243.   for ( i=0; i<4; i++ ) {
  244.     if (ok[i]==1) {
  245.       len[i] = strlen(CellNames[cell[i]]);
  246.     } else {
  247.       /* this is because, if ok!=1, then cell[i] = stage reached */
  248.       if (cell[i] < 10)
  249.     /* 1-digit stage */
  250.     len[i] = 1;
  251.       else
  252.     /* 2-digit stage: don't expect to see > 100 stages in the cycle */
  253.     len[i] = 2;
  254.     }
  255.   } /* for */
  256.  
  257.   switch (dir) {
  258.   case 'F':
  259.     prresF(daystr, cell, len, cellstr, ok, okcell, oknum,
  260.        endspot, opstr1, opstr2);
  261.     break;
  262.   case 'B':
  263.     prresB(daystr, cell, len, cellstr, ok, okcell, oknum,
  264.        endspot, opstr1, opstr2);
  265.     break;
  266.   default:    /* shouldn't! */
  267. #if PC
  268.     clrscr1(1);
  269.     gotoxy(1, 5);
  270.     cprintf("%sprintresults: Internal error, dir=%d", tab2, dir);
  271.     gotoxy(1, 7);
  272.     cprintf("%s                Sorry, aborting.", tab2);
  273. #endif
  274.     printexit(21);
  275.     break;
  276.   } /* switch */
  277. #if PC
  278.   gotoxy(2, j++);
  279.   if (HARDCOPY)
  280.     fprintf(stdprn, "\n");
  281.   fprintf(tmpfp, "\n");
  282. #else
  283.   printf("\n");
  284. #endif
  285.   if (FILEq && FILECOPY)
  286.     fprintf(fpout, "\n");
  287.  
  288.   if ((ok[0] != 1) || (ok[1] !=1 ) || (ok[2] !=1 ) || (ok[3] != 1)) {
  289. #if PC
  290.     cprintf("  (%s)\n", opstr);
  291.     gotoxy(2, j++);
  292.     cprintf("%s", opstr1);
  293.     gotoxy(2, j++);
  294.     cprintf("%s", opstr2);
  295.     gotoxy(2, j++);
  296.     if (HARDCOPY) {
  297.       fprintf(stdprn, "  (%s)\n", opstr);
  298.