home *** CD-ROM | disk | FTP | other *** search
/ High Voltage Shareware / high1.zip / high1 / DIR23 / TOUCH2.ZIP / DUMP.C < prev    next >
C/C++ Source or Header  |  1993-08-14  |  24KB  |  1,209 lines
  1. /*
  2.  * dump.c - dump the meter's memory
  3.  *
  4.  * V. Abell
  5.  */
  6.  
  7. /*
  8.  * Copyright 1993 Victor A. Abell, Lafayette, Indiana  47906.  All rights
  9.  * reserved.
  10.  *
  11.  * Written by Victor A. Abell.
  12.  *
  13.  * Permission is granted to anyone to use this software for any purpose on
  14.  * any computer system, and to alter it and redistribute it freely, subject
  15.  * to the following restrictions:
  16.  *
  17.  * 1. Victor A. Abell is not responsible for any consequences of the use of
  18.  * this software.
  19.  *
  20.  * 2. The origin of this software must not be misrepresented, either by
  21.  *    explicit claim or by omission.  Credit to Victor A. Abell must
  22.  *    appear in documentation and sources.
  23.  *
  24.  * 3. Altered versions must be plainly marked as such, and must not be
  25.  *    misrepresented as being the original software.
  26.  *
  27.  * 4. This notice may not be removed or altered.
  28.  */
  29. #ifndef lint
  30. static char copyright[] =
  31. "@(#) Copyright 1993 Victor A. Abell.\nAll rights reserved.\n";
  32. #endif
  33.  
  34. #include "touch2.h"
  35. #include <stdlib.h>
  36. #include <string.h>
  37. #include "asyncpec.h"
  38. #include <sys/types.h>
  39. #include <sys/stat.h>
  40.  
  41. #define DUMPNL    256            /* dump number of lines */
  42. #define FIELDLN    16            /* dump field length */
  43. #define    RDYCOL    31            /* ready message column */
  44. #define    SMROW    12            /* status message row */
  45.  
  46. char CksumErrMsg[64];            /* checksum error message */
  47. char Date[FIELDLN];            /* dump line date */
  48. char Dow[FIELDLN];            /* dump line day of week */
  49. int DumpHs = 0;                /* dump header status */
  50. int DumpLc = 0;                /* number of dump lines */
  51. char DumpfnQ[DUMPFNL];            /* QuattroPro dump file name */
  52. char DumpfnR[DUMPFNL];            /* raw dump file name */
  53. FILE *Dumpfs = NULL;            /* write dump file stream */
  54. char DumpLine[DUMPLL+1];        /* dump line */
  55. char *DumpLp[DUMPNL];            /* dump line pointers */
  56. char Graphfn[DUMPFNL];            /* graph file name */
  57. FILE *Graphfs = NULL;            /* graph file stream */
  58. FILE *Rdumpfs = NULL;            /* read dump file stream */
  59. short Rtype;                /* dump line reading type */
  60. char Time[FIELDLN];            /* dump line time */
  61.  
  62.  
  63. struct menu DumpErr[] = {
  64.     { 12, 20, DumpLine },
  65.     {  0,  0, NULL },
  66. };
  67.  
  68. struct menu DumpRdy[] = {
  69.     { 12, RDYCOL, "Waiting on meter" },
  70.     {  0,  0, NULL },
  71. };
  72.  
  73. struct menu DumpSt[] = {
  74.     { 12, 27, "Waiting for meter to start dump" },
  75.     {  0,  0, NULL },
  76. };
  77.  
  78. #define    TYPEBUFL    64
  79. char CheckDump[TYPEBUFL];
  80. char DumpFile[TYPEBUFL];
  81. char DumpScreen[TYPEBUFL];
  82. char EraseBuf[TYPEBUFL];
  83. char FormatBuf[TYPEBUFL];
  84. char GraphBuf[TYPEBUFL];
  85. char GraphTtl[GTTLLNL+2+1];
  86. char ReadBuf[TYPEBUFL];
  87.  
  88. struct menu DumpType[] = {
  89.     {  2, 10, CheckDump },
  90. #define    CKDMPLN    0
  91.     {  4, 10, EraseBuf },
  92.     {  6, 10, DumpFile },
  93. #define FILLN    2
  94.     {  8, 10, GraphBuf },
  95. #define    GRAPHLN    3
  96.     { 10, 10, FormatBuf },
  97. #define    FMTLN    4
  98.     { 12, 10, ReadBuf },
  99. #define READLN    5
  100.     { 14, 10, DumpScreen },
  101. #define SCRLN    6
  102.     { 16, 10, "T - change graph title from:" },
  103.     { 17, 12,  GraphTtl},
  104.     { 19, 10, "X - eXit"},
  105.     {  0,  0, NULL },
  106. };
  107.  
  108. struct menu GraphType[] = {
  109.     { 12, 30, "F - write graph to file" },
  110.     { 14, 30, "S - draw graph on screen" },
  111.     {  0,  0, NULL },
  112. };
  113.  
  114. static int CheckCksum(int len);
  115. static void DispDumpLns();
  116. static void EraseDump();
  117.  
  118. #if    defined(UNIX)
  119. static int GetDispLn(char *s, int n);
  120. #else
  121. static int GetDispLn(char *s, short n);
  122. #endif
  123.  
  124. static int CheckFileNm(char *fn);
  125. static int GetDumpType(char *ty);
  126. static void RcvErr(int err);
  127. static void ReadDump();
  128. static int StoreDumpLn();
  129. static void TrimSpaces(char *s);
  130. static void WarnCantOpen(char *f);
  131.  
  132. #ifdef    UNIX
  133. static int WarnCksum(int f);
  134. #else
  135. static int WarnCksum(short f);
  136. #endif
  137.  
  138. static int WarnDumpHdr();
  139. static void WarnDumpLen();
  140. static int WarnExist(char *d, struct stat *s);
  141. static void WrDumpF();
  142.  
  143.  
  144. /*
  145.  * CheckCksum() - check checksum
  146.  */
  147.  
  148.  
  149. static int
  150. CheckCksum(len)
  151.     int len;            /* length of line in DumpLine */
  152. {
  153.     char cksum[5];
  154.     short i;
  155.     unsigned int sum;
  156.  
  157.     if (Cksum) {
  158.         if (len < 5) {
  159.             (void) strcpy(CksumErrMsg, "Record is too short.");
  160.             return(1);
  161.         }
  162.     /*
  163.      * A leading 'P' has been stripped from all dump header records,
  164.      * and a leading "P " has been stripped from dump file records.
  165.      * They need to be considered in computing the checksum.
  166.      */
  167.         if (DumpLc == 0)
  168.             sum = (unsigned int) 'P';
  169.         else {
  170.             if (DumpLine[0] == 'P')
  171.                 sum = 0;
  172.             else 
  173.                 sum = (unsigned int) 'P' + (unsigned int) ' ';
  174.         }
  175.         for (i = 0; i < (len - 5); i++)
  176.             sum += (unsigned int) DumpLine[i];
  177.         (void) sprintf(cksum, "%04x", sum);
  178.         if (strcmpi(&DumpLine[len - 4], cksum) == 0)
  179.             return(0);
  180.         for (i = 0; cksum[i]; i++) {
  181.             if (isalpha(cksum[i]) && islower(cksum[i]))
  182.                 cksum[i] = toupper(cksum[i]);
  183.         }
  184.         (void) sprintf(CksumErrMsg, "Computed %s; read %s.",
  185.             cksum, &DumpLine[len - 4]);
  186.         return(1);
  187.     }
  188.     return(0);
  189. }
  190.  
  191.  
  192. /*
  193.  * CheckESC() - check for ESC
  194.  */
  195.  
  196. int
  197. CheckESC()
  198. {
  199.     int ch;
  200.  
  201.     if (kbhit()) {
  202.         if ((ch = getch()) == 0)
  203.             ch = getch();
  204.         if (ch == ESC)
  205.             return(1);
  206.         putch(BELL);
  207.     }
  208.     return(0);
  209. }
  210.  
  211.  
  212. /*
  213.  * CheckFilNm() - check file name
  214.  */
  215.  
  216. static int
  217. CheckFileNm(fn)
  218.     char *fn;            /* file name to check */
  219. {
  220.     char *cp;
  221.     short err = 0;
  222.     short fnl;
  223.     short lc, p, rc;
  224.     char *mp, msg[80];
  225.  
  226. /*
  227.  * Skip leading alpha, followed by a colon -- i.e., a drive specification.
  228.  */
  229.     fnl = strlen(fn);
  230.     if (fnl > 1 && isalpha(*fn) && fn[1] == ':')
  231.         cp = fn + 2;
  232.     else
  233.         cp = fn;
  234. /*
  235.  * Check the file path components -- i.e., those between / and \.
  236.  *
  237.  * The left part (the name) may have no more than 8 characters.
  238.  * The right part (the extension) may have no more than 3 characters.
  239.  * There may be one period, separating the name and extension.
  240.  * The characters must be alphanumeric or special characters from the set:
  241.  *
  242.  *    _ ^ $ ~ ! # % & - { } @ ` ' ( )
  243.  */
  244.     (void) strcpy(msg, "has ");
  245.     mp = &msg[strlen(msg)];
  246.     while (err == 0 && *cp) {
  247.         if (*cp == '/' || *cp == '\\') {
  248.             cp++;
  249.         continue;
  250.         }
  251.         lc = p = rc = 0;
  252.         while (*cp) {
  253.         switch (*cp) {
  254.         /*
  255.          * These are the legal special characters.
  256.          */
  257.         case '_':
  258.         case '^':
  259.         case '$':
  260.         case '~':
  261.         case '!':
  262.         case '#':
  263.         case '%':
  264.         case '&':
  265.         case '-':
  266.         case '{':
  267.         case '}':
  268.         case '@':
  269.         case '`':
  270.         case '\'':
  271.         case ')':
  272.         case '(':
  273.             break;
  274.         /*
  275.          * The / and \ end a component.
  276.          */
  277.         case '/':
  278.         case '\\':
  279.             err = -1;
  280.             break;
  281.         /*
  282.          * The period separates the name and extension.
  283.          */
  284.         case '.':
  285.             if (p) {
  286.             (void) strcpy(mp, "more than one period.");
  287.             err = 1;
  288.             } else if (lc == 0) {
  289.             (void) strcpy(mp,
  290.                 "nothing to the left of the period.");
  291.             err = 1;
  292.             break;
  293.             } else
  294.             p = 1;
  295.             break;
  296.         /*
  297.          * Letters (either case) and numbers are legal.
  298.          */
  299.         default:
  300.             if (isalnum(*cp))
  301.             break;
  302.             (void) strcpy(mp, "an illegal character.");
  303.             err = 1;
  304.         }
  305.         /*
  306.          * Stop on error or end of component.  Skip a period.
  307.          */
  308.         if (err)
  309.             break;
  310.         if (*cp++ == '.')
  311.             continue;
  312.         /*
  313.          * The name may have 8 characters; the extension, 3.
  314.          */
  315.         if ( ! p) {
  316.             if (lc > 7) {
  317.             (void) strcpy(mp,
  318.                 "more than 8 characters in the name part.");
  319.             err = 1;
  320.             } else
  321.             lc++;
  322.         } else {
  323.             if (rc > 2) {
  324.             (void) strcpy(mp,
  325.                 "more than 3 characters in the extension.");
  326.             err = 1;
  327.             } else
  328.             rc++;
  329.         }
  330.         }
  331.     /*
  332.      * Continue after the end of a component; stop on an error.
  333.      */
  334.         if (err == -1) {
  335.         err = 0;
  336.         continue;
  337.         }
  338.         if (err)
  339.         break;
  340.     }
  341. /*
  342.  * Return if no error; warn if there was one.
  343.  */
  344.     if (err == 0)
  345.         return(0);
  346.     (void) WarnMsg(11, (short)((Vc.numtextcols - fnl)/2 + 1), fn,
  347.         13, (short)((Vc.numtextcols - strlen(msg))/2 + 1), msg, 0);
  348.     return(1);
  349. }
  350.  
  351.  
  352. /*
  353.  * DumpMtr() - dump the meter's memory
  354.  */
  355.  
  356. void
  357. DumpMtr()
  358. {
  359.     int err, i, len;
  360.     char dt, msg[32];
  361.  
  362.     if (GetDumpType(&dt) == 0)
  363.         return;
  364.     if ( ! DumpLc && dt != 'r') {
  365.         for (;;) {
  366.         if (WaitRdy() == 0) {
  367.             CloseDump();
  368.             return;
  369.         }
  370.         DispMenu(DumpSt, NULL);
  371.         if (WaitCmd("DMP", 'P') == 0) {
  372.             (void) strcpy(DumpLine, "Dump command failed.");
  373.             DispMenu(DumpErr,
  374.                 "Press ESC to exit; any other key to retry.");
  375.             if ((char)WaitAnyKey() == ESC) {
  376.                 CloseDump();
  377.                 return;
  378.             }
  379.             continue;
  380.         }
  381.         _clearscreen(_GCLEARSCREEN);
  382.         PromptMsg("Press ESC to exit.");
  383.         len = GetDataLn(DumpLine, DUMPLL);
  384.         if (CheckCksum(len)) {
  385.             (void) WarnCksum(2);
  386.             CloseDump();
  387.             (void) EraseDump();
  388.             return;
  389.         }
  390.         if (StoreDumpLn()) {
  391.             CloseDump();
  392.             (void) EraseDump();
  393.             return;
  394.         }
  395.         if ( ! ParseHdr()) {
  396.             if ((char)WarnDumpHdr() == ESC) {
  397.                 CloseDump();
  398.                 (void) EraseDump();
  399.                 return;
  400.             }
  401.         }
  402.         _settextposition(SMROW, RDYCOL);
  403.         _outtext("Header record read.");
  404.         for (i = 0;;) {
  405.             if (CheckESC()) {
  406.                 CloseDump();
  407.                 (void) EraseDump();
  408.                 return;
  409.             }
  410.             len = GetDataLn(DumpLine, DUMPLL);
  411.             if (DumpLine[0] != 'P')
  412.                 break;
  413.             if (CheckCksum(len)) {
  414.                 (void) WarnCksum(2);
  415.                 CloseDump();
  416.                 (void) EraseDump();
  417.                 return;
  418.             }
  419.             if (StoreDumpLn()) {
  420.                 CloseDump();
  421.                 (void) EraseDump();
  422.                 return;
  423.             }
  424.             if (i == 0) {
  425.                 ClearRow(SMROW, RDYCOL);
  426.                 (void) sprintf(msg,
  427.                     "Record %3d read.", DumpLc - 1);
  428.                 _settextposition(SMROW, RDYCOL);
  429.                 i = 1;
  430.             } else {
  431.                 _settextposition(SMROW, RDYCOL+7);
  432.                 (void) sprintf(msg, "%3d", DumpLc - 1);
  433.             }
  434.             _outtext(msg);
  435.         }
  436.         if (Ndump+1 != DumpLc)
  437.             WarnDumpLen();
  438.         break;
  439.         }
  440.     }
  441.     switch (dt) {
  442.     case 'f':
  443.         WrDumpF();
  444.         break;
  445.     case 'g':
  446.     case 'G':
  447.         DrawGraph((dt == 'g') ? 0 : 1);
  448.         break;
  449.     case 'r':
  450.         ReadDump();
  451.         break;
  452.     case 's':
  453.         DispDumpLns();
  454.     }
  455. }
  456.  
  457.  
  458. /*
  459.  * DispDumpLns() - display dump lines
  460.  */
  461.  
  462. static void
  463. DispDumpLns()
  464. {
  465.     char *bf, bot[80], *cp;
  466.     int cpl, i, j, k, l, lps;
  467.  
  468.     if (DumpLc == 0)
  469.         return;
  470.     cpl = Vc.numtextcols;
  471.     lps = Vc.numtextrows;
  472.     if ((bf = (char *)malloc((size_t)(cpl + 1))) == NULL) {
  473.         _clearscreen(_GCLEARSCREEN);
  474.         _settextposition(12, 20);
  475.         _outtext("DispDump: no temporary line space");
  476.         return;
  477.     }
  478.  
  479.     i = 0;
  480.     for (;;) {
  481.  
  482.     /*
  483.      * Display a screenload.
  484.      */
  485.         _clearscreen(_GCLEARSCREEN);
  486.         for (j = 1; j < lps && (i+j-1) < DumpLc;  j++) {
  487.             for (cp = DumpLp[i+j-1], k = 0; k < cpl; cp++) {
  488.                 if (*cp == '"')
  489.                     continue;
  490.                 if (*cp == '\0')
  491.                     break;
  492.                 bf[k++] = *cp;
  493.             }
  494.             bf[k] = '\0';
  495.             _settextposition(j, 1);
  496.             _outtext(bf);
  497.         }
  498.         (void) sprintf(bot,
  499.           "(%d of %d) Press ESC or X to exit; Page Up/Down; Arrow Up/Down.",
  500.           i+1, DumpLc);
  501.         PromptMsg(bot);
  502.     /*
  503.      * Wait for a command.
  504.      */
  505.         for (k = 1; k;) {
  506.             switch((char)WaitAnyKey()) {
  507.             case ESC:
  508.             case 'x':
  509.             case 'X':
  510.                 return;
  511.             case PGDN:
  512.                 if ((i + lps - 1) < DumpLc) {
  513.                     i += lps - 1;
  514.                     k = 0;
  515.                 } else
  516.                     putch(BELL);
  517.                 break;
  518.             case PGUP:
  519.                 if (i > 0) {
  520.                     i -= lps - 1;
  521.                     if (i < 0)
  522.                         i = 0;
  523.                     k = 0;
  524.                 } else
  525.                     putch(BELL);
  526.                 break;
  527.             case UARW:
  528.                 if (i > 0) {
  529.                     i--;
  530.                     k = 0;
  531.                 } else
  532.                     putch(BELL);
  533.                 break;
  534.             case DARW:
  535.                 if (i < (DumpLc - 1)) {
  536.                     i++;
  537.                     k = 0;
  538.                     break;
  539.                 }
  540.                 /* fall through */
  541.             default:
  542.                 putch(BELL);
  543.             }
  544.         }
  545.     }
  546. } 
  547.  
  548.  
  549. /*
  550.  * EraseDump() -- erase dump
  551.  */
  552.  
  553. static void
  554. EraseDump()
  555. {
  556.     int i;
  557.  
  558.     for (i = 0; i < DumpLc; i++) {
  559.         (void) free(DumpLp[i]);
  560.         DumpLp[i] = NULL;
  561.     }
  562.     DumpLc = Ndump = 0;
  563. }
  564.  
  565.  
  566. /*
  567.  * GetDataLn(s, n) - get meter data line
  568.  */
  569.  
  570. int
  571. GetDataLn(s, n)
  572.     char *s;
  573.     int n;
  574. {
  575.     char c, msg[128];
  576.     int err, i;
  577.  
  578.     for (i = 0;;) {
  579.         if (CheckESC()) {
  580.             s[0] = '\0';
  581.             return(0);
  582.         }
  583.         (void) check_com(&c, &err);
  584.         if ( ! err && c) {
  585.             if (c == CR)
  586.                 break;
  587.             if (c == LF)
  588.                 continue;
  589.             if (i+1 >= n)
  590.                 break;
  591.             s[i++] = c;
  592.         } else if (err == 6)
  593.             continue;
  594.         else if (err)
  595.             RcvErr(err);
  596.     }
  597.     s[i] = '\0';
  598.     return(i);
  599. }
  600.  
  601.  
  602. /*
  603.  * GetDumpType() - get dump type
  604.  */
  605.  
  606. static int
  607. GetDumpType(ty)
  608.     char *ty;            /* type response */
  609. {
  610.     char ch, fn[DUMPFNL];
  611.     short i, m;
  612.     struct stat sbuf;
  613.  
  614.     Dumpfs = Graphfs = NULL;
  615.     for (m = 0;;) {
  616.         if ( ! m) {
  617.             (void) sprintf(FormatBuf,
  618.             "Q - change dump format to %s from %s",
  619.             Qp ? "raw" : "QuattroPro",
  620.             Qp ? "QuattroPro" : "raw");
  621.             if (Qp)
  622.             (void) sprintf(CheckDump,
  623.                     "C - %sdump check, error, and high readings",
  624.                 Ckdump ? "" : "don't ");
  625.             else
  626.             CheckDump[0] = '\0';
  627.             if (DumpLc) {
  628.             (void) sprintf(EraseBuf,
  629.                 "E - erase %d records from dump buffer",
  630.                 DumpLc);
  631.             (void) sprintf(DumpFile,
  632.                 "F - dump %d records to file", DumpLc);
  633.             (void) sprintf(GraphBuf,
  634.                 "G - graph %d records", DumpLc);
  635.             ReadBuf[0] = '\0';
  636.             (void) sprintf(DumpScreen,
  637.                 "S - dump %d records to screen", DumpLc);
  638.             } else {
  639.             EraseBuf[0] = '\0';
  640.             (void) strcpy(DumpFile, "F - dump to file");
  641.             (void) strcpy(GraphBuf, "G - graph");
  642.             (void) strcpy(ReadBuf, "R - read from file");
  643.             (void) strcpy(DumpScreen, "S - dump to screen");
  644.             }
  645.             if (Gttl[0] != '\0') {
  646.             if (ExpandTtl())
  647.                 (void) sprintf(GraphTtl, "Error: %s",
  648.                     TtlErrMsg);
  649.             else
  650.                 (void) sprintf(GraphTtl, "\"%s\"", Exttl);
  651.             } else
  652.             GraphTtl[0] = '\0';
  653.             DispMenu(DumpType, NULL);
  654.             m = 1;
  655.         }
  656.         switch((char)WaitAnyKey()) {
  657.  
  658.         case 'x':
  659.         case 'X':
  660.         case ESC:
  661.             return(0);
  662.         case 'c':
  663.         case 'C':
  664.             Ckdump = Ckdump ? 0 : 1;
  665.             m = 0;
  666.             break;
  667.         case 'e':
  668.         case 'E':
  669.             if ( ! DumpLc)
  670.                 putch(BELL);
  671.             else {
  672.                 (void) EraseDump();
  673.                 m = 0;
  674.             }
  675.             break;
  676.         case 'f':
  677.         case 'F':
  678.             (void) strcpy(fn, Qp ? DumpfnQ : DumpfnR);
  679.             if (GetInp(21, 5, "Name?", fn, fn, sizeof(fn)) == 0)
  680.                 return(0);
  681.             if (CheckFileNm(fn)) {
  682.                 m = 0;
  683.                 break;
  684.             }
  685.             if (stat(fn, &sbuf) == 0) {
  686.                 if (WarnExist(fn, &sbuf) == 0)
  687.                     return(0);
  688.             }
  689.             if ((Dumpfs = fopen(fn, "w+t")) != NULL) {
  690.                 (void) strcpy(Qp ? DumpfnQ : DumpfnR, fn);
  691.                 *ty = 'f';
  692.                 return(1);
  693.             }
  694.             WarnCantOpen(fn);
  695.             m = 0;
  696.             break;
  697.         case 'g':
  698.         case 'G':
  699.             DispMenu(GraphType, NULL);
  700.             if ((ch = (char)WaitAnyKey()) == ESC)
  701.                 return(0);
  702.             switch (ch) {
  703.             case 'f':
  704.             case 'F':
  705.                 (void) strcpy(fn, Graphfn);
  706.                 if (GetInp(21, 5, "Name?", fn, fn, sizeof(fn))
  707.                 == 0)
  708.                     return(0);
  709.                 if (CheckFileNm(fn))
  710.                     break;
  711.                 if (stat(fn, &sbuf) == 0) {
  712.                     if (WarnExist(fn, &sbuf) == 0)
  713.                         return(0);
  714.                 }
  715.                 if ((Graphfs = fopen(fn, "w+t")) != NULL) {
  716.                     (void) strcpy(Graphfn, fn);
  717.                     *ty = 'G';
  718.                     return(1);
  719.                 }
  720.                 WarnCantOpen(fn);
  721.                 break;
  722.             case 's':
  723.             case 'S':
  724.                 *ty = 'g';
  725.                 return(1);
  726.             default:
  727.                 putch(BELL);
  728.             }
  729.             m = 0;
  730.             break;
  731.         case 'q':
  732.         case 'Q':
  733.             Qp = (Qp == 1) ? 0 : 1;
  734.             m = 0;
  735.             break;
  736.         case 'r':
  737.         case 'R':
  738.             (void) strcpy(fn, DumpfnR);
  739.             if (GetInp(21, 5, "Name?", fn, fn, sizeof(fn)) == 0)
  740.                 return(0);
  741.             if (CheckFileNm(fn)) {
  742.                 m = 0;
  743.                 break;
  744.             }
  745.             if ((Rdumpfs = fopen(fn, "r+t")) != NULL) {
  746.                 (void) strcpy(DumpfnR, fn);
  747.                 *ty = 'r';
  748.                 return(1);
  749.             }
  750.             WarnCantOpen(fn);
  751.             m = 0;
  752.             break;
  753.         case 's':
  754.         case 'S':
  755.             *ty = 's';
  756.             return(1);
  757.         case 't':
  758.         case 'T':
  759.             if (GetInp(21, 7, "Title?", Gttl, GraphTtl, GTTLLNL)
  760.             == 0)
  761.                 return(0);
  762.             (void) strcpy(Gttl, GraphTtl);
  763.             m = 0;
  764.             break;
  765.         default:
  766.             putch(BELL);
  767.         }
  768.     }
  769. }
  770.  
  771.  
  772. /*
  773.  * InitDump() - initialize dump
  774.  */
  775.  
  776. void
  777. InitDump()
  778. {
  779.     (void) strcpy(DumpfnQ, DEFQDMPF);
  780.     (void) strcpy(DumpfnR, DEFRDMPF);
  781.     (void) strcpy(Graphfn, DEFGRAPHF);
  782. }
  783.  
  784.  
  785.  
  786. /*
  787.  * GetDispLn(s) - get meter display line
  788.  */
  789.  
  790. static int
  791. GetDispLn(s, n)
  792.     char *s;            /* destination buffer */
  793.  
  794. #if    defined(UNIX)
  795.     int n;                /* destination buffer length */
  796. #else
  797.     short n;            /* destination buffer length */
  798. #endif
  799.  
  800. {
  801.     char c;
  802.     int err, i;
  803.  
  804.     for (i = 0;;) {
  805.         if (CheckESC()) {
  806.             s[0] = '\0';
  807.             return(0);
  808.         }
  809.         (void) check_com(&c, &err);
  810.         if ( ! err && c) {
  811.             if (c == CR) {
  812.                 s[i] = '\0';
  813.                 return(1);
  814.             }
  815.             if (i < n - 1)
  816.                 s[i++] = c;
  817.             else {
  818.                 s[i] = '\0';
  819.                 return(0);
  820.             }
  821.         } else if (err == 6)
  822.             continue;
  823.         else if (err) {
  824.             RcvErr(err);
  825.             return(0);
  826.         }
  827.     }
  828. }
  829.  
  830.  
  831. /*
  832.  * Rcverr() - handle receive error
  833.  */
  834.  
  835. static void
  836. RcvErr(err)
  837.     int err;
  838. {
  839.     char msg[64];
  840.  
  841.     (void) sprintf(msg, "Meter receive error %d", err);
  842.     _clearscreen(_GCLEARSCREEN);
  843.     _settextposition(12, 20);
  844.     _outtext(msg);
  845. }
  846.  
  847.  
  848. /*
  849.  * ReadDump() - read dump from file
  850.  */
  851.  
  852. static void
  853. ReadDump()
  854. {
  855.     char *cp, *rv;
  856.     int i, len;
  857.     short err = 0;
  858.  
  859. /*
  860.  * Read, parse and store the dump header line.
  861.  */
  862.     if ((rv = fgets(DumpLine, DUMPLL, Rdumpfs)) != NULL) {
  863.         if ((cp = strrchr(DumpLine, '\n')) != NULL) {
  864.             *cp = '\0';
  865.             len = cp - DumpLine;
  866.         } else {
  867.             DumpLine[DUMPLL-1] = '\0';
  868.             len = strlen(DumpLine);
  869.         }
  870.         if (CheckCksum(len)) {
  871.             if ((char)WarnCksum(1) == ESC) {
  872.                 CloseDump();
  873.                 (void) EraseDump();
  874.                 return;
  875.             }
  876.         }
  877.         if (StoreDumpLn()) {
  878.             CloseDump();
  879.             (void) EraseDump();
  880.             return;
  881.         }
  882.     } else {
  883.         DumpLine[0] = '\0';
  884.         len = 0;
  885.     }
  886.     if (rv == NULL || ! ParseHdr()) {
  887.  
  888.     /*
  889.      * Handle bad dump header line.
  890.      */
  891.         i = WarnDumpHdr();
  892.         if (DumpLc)
  893.             (void) EraseDump();
  894.         if ((char)i == ESC) {
  895.             CloseDump();
  896.             return;
  897.         }
  898.         err = 1;
  899.     }
  900. /*
  901.  * Read and store the dump lines.
  902.  */
  903.     while (fgets(DumpLine, DUMPLL, Rdumpfs) != NULL) {
  904.         if ((cp = strrchr(DumpLine, '\n')) != NULL) {
  905.             *cp = '\0';
  906.             len = cp - DumpLine;
  907.         } else {
  908.             DumpLine[DUMPLL-1] = '\0';
  909.             len = strlen(DumpLine);
  910.         }
  911.         if (CheckCksum(len)) {
  912.             if ((char)WarnCksum(1) == ESC) {
  913.                 CloseDump();
  914.                 (void) EraseDump();
  915.                 return;
  916.             }
  917.         }
  918.         if (StoreDumpLn()) {
  919.             err = 1;
  920.             break;
  921.         }
  922.     }
  923.     CloseDump();
  924.     if (err == 0 && (Ndump+1 != DumpLc))
  925.         WarnDumpLen();
  926. }
  927.  
  928.  
  929. /*
  930.  * StoreDumpLn() - store dump line via DumpLp[]
  931.  */
  932.  
  933. static int
  934. StoreDumpLn()
  935. {
  936.     char *cp;
  937.     int i;
  938.     size_t l;
  939.     char msg[128];
  940.  
  941.     if (DumpLc >= DUMPNL) {
  942.         (void) sprintf(msg, "Dump buffer is full (limit = %d).",
  943.             DUMPNL);
  944. store_warn:
  945.         i = WarnMsg(12, (short)(((Vc.numtextcols - strlen(msg))/2)+1),
  946.             msg, 14, (short)(((Vc.numtextcols - strlen(DumpLine))/2)+1),
  947.             DumpLine, 1);
  948.         return(((char)i == ESC) ? 1 : 0);
  949.     }
  950.     cp = DumpLine;
  951.     if (*cp == 'P') {
  952.         cp++;
  953.         if (*cp == ' ')
  954.             cp++;
  955.     }
  956.     l = (size_t)(strlen(cp) + 1);
  957.     if ((DumpLp[DumpLc] = (char *)malloc(l)) == NULL) {
  958.         (void) sprintf(msg, "No memory for dump line number %d.",
  959.             DumpLc);
  960.         goto store_warn;
  961.     }
  962.     (void) strcpy(DumpLp[DumpLc], cp);
  963.     DumpLc++;
  964.     return(0);
  965. }
  966.  
  967.  
  968. /*
  969.  * WaitRdy() - wait for the meter to become ready
  970.  */
  971.  
  972. int
  973. WaitRdy()
  974. {
  975.     char buf[16];
  976.     int r;
  977.  
  978.     DispMenu(DumpRdy, NULL);
  979.     OpenCom();
  980.     reset_buffer();
  981.     for (;;) {
  982.         if (CheckESC())
  983.             return(0);
  984.         if (buffer_length == 0)
  985.             continue;
  986.         if (GetDispLn(buf, sizeof(buf)) == 0)
  987.             return(0);
  988.         if (strcmp(buf, "INSERT")  == 0        /* ENGL */
  989.         ||  strcmp(buf, "INSERT.") == 0        /* ESPAN */
  990.         ||  strcmp(buf, "INSER. ") == 0        /* FRANC and ITALI */
  991.         ||  strcmp(buf, "IN    ")  == 0        /* NEDER */
  992.         ||  strcmp(buf, "INSIRA")  == 0        /* PORT */
  993.         ||  strcmp(buf, "SATTIN")  == 0        /* SVENS */
  994.         ||  strcmp(buf, "EINLEG")  == 0        /* DEUTS */
  995.         ||  strcmp(buf, ")))   ")  == 0)    /* SYMB */
  996.             break;
  997.     }
  998.     return(GetDispLn(buf, sizeof(buf)));
  999. }
  1000.  
  1001.  
  1002. /*
  1003.  * TrimSpaces() - trim leading and trailing spaces from string
  1004.  */
  1005.  
  1006. static void
  1007. TrimSpaces(s)
  1008.     char *s;            /* string address */
  1009. {
  1010.     char *s1, *s2;
  1011.  
  1012.     for (s1 = s2 = s; *s1; s1++) {
  1013.         if (s2 > s || *s1 != ' ')
  1014.             *s2++ = *s1;
  1015.     }
  1016.     while (s2 > s) {
  1017.         if (*(s2 - 1) != ' ')
  1018.             break;
  1019.         s2--;
  1020.     }
  1021.     *s2 = '\0';
  1022. }
  1023.  
  1024.  
  1025. /*
  1026.  * WarnCantOpen() - issue can't open file warning
  1027.  */
  1028.  
  1029. static void
  1030. WarnCantOpen(f)
  1031.     char *f;            /* file name */
  1032. {
  1033.     char msg[80];
  1034.  
  1035.     (void) sprintf(msg, "Can't open %s", f);
  1036.     (void) WarnMsg(12, 1, msg, 0, 0, NULL, 0);
  1037. }
  1038.  
  1039.  
  1040. /*
  1041.  * WarnCksum()
  1042.  */
  1043.  
  1044. static int
  1045. WarnCksum(f)
  1046.  
  1047. #ifdef    UNIX
  1048.     int f;            /* prompt flag for WarnMsg() */
  1049. #else
  1050.     short f;        /* prompt flag for WarnMsg() */
  1051. #endif
  1052.  
  1053. {
  1054.     char m1[80], m2[80];
  1055.  
  1056.     (void) strcpy(m1, "Checksum doesn't match for dump ");
  1057.     if (DumpLc)
  1058.         (void) sprintf(m2, "record %d.  ", DumpLc);
  1059.     else
  1060.         (void) strcpy(m2, "header record.  ");
  1061.     (void) strcat(m1, m2);
  1062.     (void) strcat(m1, CksumErrMsg);
  1063.     return(WarnMsg(12, (short)(((Vc.numtextcols - strlen(m1))/2)+1), m1,
  1064.         14, (short)(((Vc.numtextcols - strlen(DumpLine))/2)+1),
  1065.         DumpLine, f));
  1066. }
  1067.  
  1068.  
  1069. /*
  1070.  * WarnDumpHdr()
  1071.  */
  1072.  
  1073. static int
  1074. WarnDumpHdr()
  1075. {
  1076.     return(WarnMsg(12, 30, "Bad dump header line:", 14,
  1077.         (short)(((Vc.numtextcols - strlen(DumpLine))/2)+1),
  1078.         DumpLine, 1));
  1079. }
  1080.  
  1081.  
  1082. /*
  1083.  * WarnDumpLen() - warn about incorrect dump length
  1084.  */
  1085.  
  1086. static void
  1087. WarnDumpLen()
  1088. {
  1089.     char msg[80];
  1090.  
  1091.     (void) sprintf(msg,
  1092.         "Dump length incorrect: %d records expected, %d received.",
  1093.         Ndump, DumpLc - 1);
  1094.     (void) WarnMsg(12, 11, msg, 0, 0, NULL, 0);
  1095. }
  1096.  
  1097.  
  1098. /*
  1099.  * WarnExist() - warn that the dump file exists
  1100.  */
  1101.  
  1102. static int
  1103. WarnExist(d, s)
  1104.     char *d;            /* dump file name */
  1105.     struct stat *s;            /* stat buffer */
  1106. {
  1107.     char msg[80];
  1108.  
  1109.     _clearscreen(_GCLEARSCREEN);
  1110.     (void) sprintf(msg, "%s exists.", d);
  1111.     _settextposition(11, (short)((Vc.numtextcols - strlen(msg))/2 + 1));
  1112.     _outtext(msg);
  1113.     (void) sprintf(msg, "It is %ld bytes long.", s->st_size);
  1114.     _settextposition(13, (short)((Vc.numtextcols - strlen(msg))/2 + 1));
  1115.     _outtext(msg);
  1116.     PromptMsg("Press ESC to exit; any other key to overwrite.");
  1117.     if ((char)WaitAnyKey() == ESC)    
  1118.         return(0);
  1119.     return(1);
  1120. }
  1121.  
  1122.  
  1123. /*
  1124.  * WarnMsg() - issue warning message
  1125.  */
  1126.  
  1127. int
  1128. WarnMsg(r1, c1, m1, r2, c2, m2, f)
  1129.  
  1130. #if    defined(UNIX)
  1131.     int r1;                /* first message row */
  1132.     int c1;                /* first message column */
  1133.     char *m1;            /* first message */
  1134.     int r2;                /* second message row */
  1135.     int c2;                /* second message column */
  1136.     char *m2;            /* second message */
  1137.     int f;                /* prompt flag: 0 = any continue
  1138.                      *        1 = ESC abort
  1139.                      *        2 = any abort */
  1140. #else
  1141.     short r1;            /* first message row */
  1142.     short c1;            /* first message column */
  1143.     char *m1;            /* first message */
  1144.     short r2;            /* second message row */
  1145.     short c2;            /* second message column */
  1146.     char *m2;            /* second message */
  1147.     short f;            /* prompt flag: 0 = any continue
  1148.                      *        1 = ESC abort
  1149.                      *        2 = any abort */
  1150. #endif
  1151.  
  1152. {
  1153.     char *p;
  1154.  
  1155.     _clearscreen(_GCLEARSCREEN);
  1156.     _settextposition(r1, c1);
  1157.     _outtext(m1);
  1158.     if (m2) {
  1159.         _settextposition(r2, c2);
  1160.         _outtext(m2);
  1161.     }
  1162.     switch (f) {
  1163.     case 0:
  1164.         p = "Press any key to continue.";
  1165.         break;
  1166.     case 1:
  1167.         p = "Press ESC to exit; any other key to continue.";
  1168.         break;
  1169.     default:
  1170.         p = "Press any key to abort.";
  1171.     }
  1172.     PromptMsg(p);
  1173.     return(WaitAnyKey());
  1174. }
  1175.  
  1176.  
  1177. /*
  1178.  * WrDumpF() -- write dump lines to dump file
  1179.  */
  1180.  
  1181. static void
  1182. WrDumpF()
  1183. {
  1184.  
  1185. #if    defined(UNIX)
  1186.     int i;
  1187. #else
  1188.     short i;
  1189. #endif
  1190.  
  1191.     if (Qp) {
  1192.         for (i = 1; i < DumpLc; i++) {
  1193.             if (ParseDumpLn(i, 0) == 0)
  1194.                 break;
  1195.             (void) TrimSpaces(Date);
  1196.             if (Ckdump == 0 && Rtype != RDREG)
  1197.                 continue;
  1198.             (void) TrimSpaces(Time);
  1199.             (void) fprintf(Dumpfs, "%s,%s,%6.2f\n", Date, Time,
  1200.                 Rval);
  1201.         }
  1202.     } else {
  1203.         for (i = 0; i < DumpLc; i++)
  1204.             (void) fprintf(Dumpfs, "%s\n", DumpLp[i]);
  1205.     }
  1206.     (void) fclose(Dumpfs);
  1207.     Dumpfs = NULL;
  1208. }
  1209.