home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / cpm / heath / teledt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1983-09-09  |  17.7 KB  |  997 lines
  1. /*
  2.     TELEDIT.C    v1.1        (see TELEDIT.DOC)
  3.  
  4.     A telecommunications program using Ward Christensen's
  5.     "MODEM" File Transfer Protocol.
  6.  
  7.      Modified by Nigel Harrison and Leor Zolman from XMODEM.C,
  8.     which was written by:  Jack M. Wierda,
  9.                modified by Roderick W. Hart and William D. Earnest
  10.  
  11.     Note that Modem port numbers, masks, etc., are taken from BDSCIO.H,
  12.     which must have the correct values for your system.    
  13. */
  14.  
  15. /*
  16.     Converted to HDOS by Al Bolduc
  17. */
  18.  
  19. #include    console.h
  20. #include    printf.h
  21.  
  22. /*
  23.     The following three defines must be customized by the user:
  24. */
  25. #define HC    "\33H*"            /* Home cursor and print a "*"    */
  26. #define    SPECIAL    '^'-0x40        /* Gets out of terminal mode    */
  27. #define    CPUCLK    2            /* CPU clock rate, in MHz     */
  28.  
  29. /*
  30.     The rest of the defines need not be modified
  31. */
  32.  
  33. #define    EOF    -1
  34. #define    NULL    0
  35. #define    TRUE    1
  36. #define    FALSE    0
  37. #define    ERROR    -1
  38. #define    BUFSIZ    256
  39. #define    CPMEOF    0X1A
  40. #define    MDATA    0330
  41. #define    MSTAT    0335
  42. #define    CLEARS    "\033E"
  43. #define    SECSIZ    128
  44. #define    NSECTS    2
  45. #define    MAXLINE    100
  46. #define    SOH 1
  47. #define    EOT 4
  48. #define    ACK 6
  49. #define    ERRORMAX 10
  50. #define    RETRYMAX 10
  51. #define    LF 10
  52. #define    CR 13
  53. #define    SPS 1500                   /*loops per second */
  54. #define    NAK 21
  55. #define    TIMEOUT -1
  56. #define    TBFSIZ NSECTS*SECSIZ
  57. #define    ML 1000                /* maximum source lines */
  58.  
  59. char linebuf[MAXLINE];            /* string buffer */
  60. char fnambuf[50];            /* name of file for text collection */
  61. int nlines, nl;                /* number of lines    */
  62. int linect;                /* current line    */
  63. char fflg;                /* text collection file flag */
  64. char echoflg;                /* whether to echo        */
  65. char sflg;                /* transmit flag        */
  66. char    *textbuf;            /* Text buffer            */
  67. char    *textend;            /* End of text buffer        */
  68. unsigned    textind;        /* Index into text buffer    */
  69. int    baud = 300;            /* Baudrate (set to default)    */
  70.  
  71. int moready()    /* return TRUE if the modem is ready for output */
  72. {
  73.     return(in(MSTAT) & 040);
  74. }
  75.  
  76. int miready()     /* return TRUE if input is present on the modem */
  77. {
  78.     return (in(MSTAT) & 01);
  79. }
  80.  
  81. send(data)    /* send char to modem */
  82. char data;
  83. {
  84.     while(!moready())
  85.         ;
  86.     out(data,MDATA);
  87. }
  88.  
  89. main(argc,argv)
  90. char *argv[];
  91. {
  92.     int i, j, k, l;            /* scratch integers */
  93.     char *lineptr[ML];        /* allow ML source lines */
  94.     char *inl[ML];            /* inserted line pointers */
  95.     char *p;            /* scratch pointer */
  96.     int    fdes;            /* I/O file descriptor */
  97.     int  inchar;            /* collect characters at inchar */
  98.     char *alloc();            /* storage allocator */
  99.     char *getm();            /* memory procuror */
  100.  
  101.     linect = nlines = i = 0;
  102.     fflg = echoflg = FALSE;
  103.     lineptr[i] = (char *)NULL;
  104.     init();
  105.  
  106.     while(1)
  107.     {
  108.         lnmode();
  109.         printf(CLEARS);
  110.         printf("Teledit ver 1.1\n\n");
  111.  
  112.         printf("\tT: Terminal mode - no text collection\n");
  113.         printf("\tX: terminal mode with teXt collection\n");
  114.         printf("\t\tIn terminal mode:\n");
  115.         printf("\t\tSPECIAL (control-^): return to menu\n");
  116.         printf("\t\tcontrol-E: enter editor\n");
  117.         printf("\tB: Baudrate (currently set to: %d)\n",baud);
  118.         printf("\tG: toGgle echo mode (currently set to: %secho)\n",
  119.         echoflg ? "" : "no ");
  120.         printf("\tE: Edit collected text\n");
  121.         printf("\tF: Flush text buffer to text collection file\n");
  122.         printf("\tS: Send a file, MODEM protocol\n");
  123.         printf("\tR: Receive a file, MODEM protocol\n");   
  124.         printf("\tQ: quit\n");
  125.         printf("\tSPECIAL: send SPECIAL char to modem\n");
  126.         printf("\nCommand: ");
  127.         chmode();
  128.  
  129.         inchar = 0XDF & getchar();
  130.         putchar(inchar);
  131.         putchar('\n');
  132.  
  133.         switch(inchar)
  134.         {
  135.         case SPECIAL:
  136.             send(SPECIAL);
  137.             break;
  138.         case 'T':
  139.             rawmode();
  140.             terminal();
  141.             break;
  142.         case 'X':
  143.             if (fflg)
  144.     printf("Text collection already in effect (filename '%s')\n", fnambuf);
  145.             else
  146.             {
  147.                 printf("Collection text filename = ");
  148.                 gets(fnambuf);
  149.  
  150.                 printf("Wait...");
  151.                 if((fdes = fopen(fnambuf,"r")) != NULL)
  152.                 {    
  153.                     fclose(fdes);
  154.                     printf("\nFile already exists; do you want to ");
  155.                     if(!ask("overwrite it"))       
  156.                         break;
  157.                 }
  158.                 else
  159.                     fclose(fdes);
  160.                 if((fdes = fopen(fnambuf, "w")) == NULL)
  161.                 {    
  162.                     printf("\nCan't create %s", fnambuf);
  163.                     break;
  164.                 }
  165.  
  166.                 fflg = TRUE;    
  167.             }
  168.             printf("\nReady\n");
  169.  
  170.             rawmode();    
  171.             while(1)    
  172.             {    
  173.                 if(miready())
  174.                 {    
  175.                     putchar (inchar = 0177 & in(MDATA));
  176.  
  177.                     if(i > (MAXLINE + 5))
  178.                         inchar = CR;
  179.                     if(inchar >= ' ')
  180.                         linebuf[i++] = inchar;
  181.                     else
  182.                     {    
  183.                         if(inchar == CR)
  184.                         {    
  185.                             linebuf[i++] = '\n';
  186.                             linebuf[i] = NULL;
  187.                             p = getm(linebuf);
  188.                             if(p == NULL) continue;
  189.                             lineptr[nlines++] = p;
  190.                             lineptr[nlines] = NULL;
  191.                             if(nlines > 500) putchar('\7');
  192.                             i = 0;
  193.                         }
  194.                         else if(inchar == '\t' || in == '\f')
  195.                             linebuf[i++] = inchar;
  196.                         else
  197.                             continue;
  198.                     }
  199.                 }
  200.                 if(inchar = chrdy())
  201.                 {
  202.                     if(echoflg)
  203.                         putchar(inchar);
  204.  
  205.                     if(inchar == SPECIAL)
  206.                         break;
  207.                     else if(inchar == ('E' & 037))
  208.                     {
  209.                         chmode();
  210.                         ed(lineptr);
  211.                         printf("Terminal mode:\n\n");
  212.                         rawmode();
  213.                     }
  214.                     else
  215.                         send(inchar);
  216.                 }
  217.             }
  218.             break;
  219.         
  220.         case 'S':
  221.         case 'R':
  222.             printf("File to %s = ", (inchar == 'S') ? "send" : "receive");
  223.             gets(linebuf);
  224.  
  225.             if(inchar == 'R')
  226.                 readfile(linebuf);
  227.             else
  228.             {
  229.                 if((fdes = fopen(linebuf, "r")) == NULL)
  230.                 {    
  231.                     printf("\7Teledit: can't open %s\n", linebuf);
  232.                     break;
  233.                 }
  234.                 sendfile(linebuf);
  235.             }
  236.             putchar(7);            /* beep when done */
  237.             sleep(15);
  238.             break;
  239.         
  240.         case 'E':
  241.             ed(lineptr);
  242.             break;
  243.         
  244.         case 'F':
  245.             dump(lineptr,fdes);
  246.             break;
  247.  
  248.         case 'B':
  249.             printf("Baudrate: ");
  250.             gets(linebuf);
  251.             baud = atoi(linebuf);
  252.             if(baud < 300 || baud > 9600)
  253.                 baud = 300;
  254.             initmod();
  255.             break;
  256.  
  257.         case 'G':
  258.             echoflg = !echoflg;
  259.             break;
  260.  
  261.         case 'Q':
  262.             if (fflg) {
  263.                 printf("\nSave file \"%s\" to ",fnambuf);
  264.                 if (ask("disk"))
  265.                 {    
  266.                     dump(lineptr,fdes);
  267.                     fclose(fdes);
  268.                 }
  269.             }
  270.             lnmode();
  271.             out(0,MDATA + 4);
  272.             exit();
  273.         }
  274.     }
  275. }
  276.  
  277. init() {    /* Initialize modem and allocate memory */
  278.     unsigned    size;
  279.  
  280.     size = 0XFF00 & (szofram() - 1000);
  281.     textbuf = alloc(size);
  282.     textend = textbuf + size;
  283.     textind = 0;
  284.            initmod();
  285. }
  286.  
  287. initmod() {    /* Initialize modem port */
  288.     int    tmp;
  289.  
  290.     tmp = 11520 / (baud / 10);
  291. #asm
  292.     DI
  293. #endasm
  294.     out(0,MDATA + 1);        /* Disable interupts    */
  295.     out(0200,MDATA + 3);        /* Divisor latch access    */
  296.     out(tmp & 0377,MDATA);        /* LSB            */
  297.     out((tmp >> 8) & 0377,MDATA + 1);  /* MSB        */
  298.     out(3,MDATA + 3);        /* * bits        */
  299.     out(1,MDATA + 4);        /* Turn on DTR        */
  300.     in(MDATA);            /* Clear USART        */
  301. #asm
  302.     EI
  303. #endasm
  304. }
  305.  
  306. dump(lineptr,fdes)    /* dump text buffer    */
  307. char *lineptr[];
  308. int    fdes;
  309. {
  310.     int i;
  311.  
  312.     for(i = 0; lineptr[i] != NULL; i++)
  313.         if(fprintf(fdes,lineptr[i]) == ERROR)
  314.             printf("\n\7Error writing txt, disk full?\n");
  315.  
  316.     lineptr[0] = linect = nlines = textind = 0;
  317. }
  318.  
  319. ed(lineptr)    /* editor */
  320. char **lineptr;
  321. {
  322.     char inchar, *inl[ML], *p;
  323.     int i, j, k, l,fdes;
  324.  
  325.     if(!fflg)
  326.     {    
  327.         printf("\n\7No text buffer to edit.\n");
  328.         return;
  329.     }
  330.     
  331.     printf("\nedit\n*");
  332.     nl = 22;
  333.  
  334.     while (inchar = getchar()) {
  335.         putchar(inchar);
  336.         switch (tolower(inchar)) {
  337.         case 'a':
  338.             printf("Filename to yank = ");
  339.             gets(linebuf);
  340.             if((fdes = fopen(linebuf, "r")) == NULL) {
  341.                 printf ("\r  Cannot open %s.\r*", linebuf);
  342.                 continue;
  343.             }
  344.  
  345.             for(i = 0; fgets(linebuf,fdes); i++) {
  346.                 inl[i] = getm(linebuf);
  347.                 if(inl[i] == NULL) break;
  348.             }
  349.  
  350.             inl[i] = NULL;
  351.             iblock(lineptr, inl, linect);
  352.             show (lineptr, linect, nl);
  353.             continue;
  354.         case 'b':
  355.             linect = 0;
  356.             show (lineptr, linect, nl);
  357.             continue;
  358.         case 'q':
  359.             printf(CLEARS);
  360.             return;
  361.         case 'f':
  362.             gets(linebuf);
  363.             if((i = find(lineptr, linect)) >= 0) {
  364.                 linect = i;
  365.                 show (lineptr, linect, nl);
  366.             }
  367.             else if((i = find(lineptr, 0)) >= 0) {
  368.                 linect = i;
  369.                 show (lineptr, linect, nl);
  370.             }
  371.             else
  372.             {    
  373.                 printf(HC);
  374.                 printf("  not found\r*");
  375.             }
  376.             continue;
  377.         case 'i':
  378.             j = min(linect, 5);
  379.             if(j == 0)
  380.                 printf(CLEARS);
  381.             else {
  382.                 show(lineptr, (linect - j), j);
  383.                 j++;
  384.                 printf("\b ");
  385.                 for(; j; j--)
  386.                     putchar('\n');
  387.             }
  388.             while(1) {
  389.                 gets(linebuf);
  390.                 for(i = 0; linebuf[i]; i++)  
  391.                     if(linebuf[i] == EOF)  
  392.                         break;
  393.                 if(linebuf[i] == EOF) break;
  394.                 linebuf[i++] = '\n';
  395.                 linebuf[i] = NULL;
  396.                 inl[j++] = getm(linebuf);
  397.             }
  398.             inl[j] = NULL;
  399.             iblock(lineptr, inl, linect);
  400.             show (lineptr, linect, nl);
  401.             continue;
  402.         case 'k':
  403.             putchar('\n');
  404.             show1(lineptr, linect);
  405.             kill(lineptr, linect, 1);
  406.             continue;
  407.         case 'l':
  408.             gets(linebuf);
  409.             if((i = lfind(lineptr, linect)) >= 0) {
  410.                 linect = i;
  411.                 show(lineptr, linect, nl);
  412.             }
  413.             else if((i = lfind(lineptr, 0)) >= 0) {
  414.                 linect = i;
  415.                 show(lineptr, linect, nl);
  416.             }
  417.             else {
  418.                 printf(HC);
  419.                 printf("  not found\r*");
  420.             }
  421.             continue;
  422.         case 'o':
  423.             putchar('\n');
  424.             i = linect;
  425.             while(gets(linebuf)) {
  426.                 for(j = 0; linebuf[j]; j++)
  427.                     if(linebuf[j] == EOF) break;
  428.                 if(linebuf[j] == EOF) break;
  429.                 linebuf[j++] = '\n';
  430.                 linebuf[j] = NULL;
  431. /*
  432.                 if(lineptr[i])
  433.                     free(lineptr[i]);
  434.  
  435. */
  436.                 lineptr[i++] = getm(linebuf);
  437.                 if(i > nlines) lineptr[++nlines] = NULL;
  438.             }
  439.             show (lineptr, linect, nl);
  440.             continue;
  441.         case 'p':
  442.             linect = min((linect + nl), nlines);
  443.             show (lineptr, linect, nl);
  444.             continue;
  445.         case 's':
  446.             gets(linebuf);
  447.             nl = max((atoi(linebuf)), 1);
  448.             show (lineptr, linect, nl);
  449.             continue;
  450.         case 'z':
  451.             linect = nlines;
  452.             show(lineptr, linect, nl);
  453.             continue;
  454.         case '1': 
  455.         case '2': 
  456.         case '3': 
  457.         case '4': 
  458.         case '5':
  459.         case '6': 
  460.         case '7': 
  461.         case '8': 
  462.         case '9': 
  463.         case '-':
  464.             linebuf[0] = inchar;
  465.             for (i = 1; (isdigit(inchar = getchar())); i++)
  466.                 linebuf[i] = inchar;
  467.             linebuf[i] = NULL;
  468.             i = atoi(linebuf);
  469.             if (i < 0)
  470.                 j = max((linect + i), 0);
  471.             else
  472.                 j = min((linect + i), nlines);
  473.             inchar = tolower(inchar);
  474.             if(j > linect && inchar == 'k')
  475.                 kill(lineptr, linect, (j - linect));
  476.             else
  477.                 linect = j;
  478.             if (inchar == 'p') linect = max((linect-nl), 0);
  479.             show (lineptr, linect, nl);
  480.             continue;
  481.         case '#':
  482.             printf (" of lines: %d\r*", nlines);
  483.             continue;
  484.         case '\n':
  485.             if (lineptr[linect] != NULL) {
  486.                 show1(lineptr, linect);
  487.                 linect++;
  488.             }
  489.             else
  490.                 printf (HC);
  491.             continue;
  492.         case ' ':
  493.             if(linect)
  494.                 linect--;
  495.             show(lineptr, linect, nl);
  496.             continue;
  497.         case ('E'&037):
  498.             send(inchar);
  499.             printf("\n^E sent\n");
  500.             return;
  501.         default:
  502.             printf(" ?\r*");
  503.         }
  504.     }
  505. }
  506.  
  507. shocrt(sec,try,tot)
  508. int sec,try,tot;
  509. {
  510.     if(sflg)
  511.         printf("Sending #%d (Try=%d Errs=%d)  \r", sec, try, tot);
  512.     else
  513.         printf("Awaiting #%d (Try=%d, Errs=%d)  \r", sec, try, tot);
  514.  
  515.     if(try && tot) putchar('\n');
  516. }
  517.  
  518. receive(seconds)
  519. int seconds;
  520. { 
  521.     int lpc,seccnt;
  522.     for (lpc = 0; lpc < CPUCLK; lpc++)
  523.     { 
  524.         seccnt = seconds * SPS;
  525.         while (!miready() && seccnt--);
  526.         if(seccnt >= 0)
  527.         { 
  528.             return(in(MDATA));   
  529.         }
  530.     }
  531.     return(TIMEOUT);
  532. }
  533.  
  534. purgeline()
  535. { 
  536.     while (miready())
  537.         in(MDATA);    /* purge the receive register    */
  538. }
  539.  
  540. readfile(file)
  541. char *file;
  542. { 
  543.     int j, firstchar, sectnum, sectcurr, sectcomp, errors;
  544.     int toterr,checksum;
  545.     int errorflag, fd;
  546.     int bufctr;
  547.     char buffer[BUFSIZ];
  548.  
  549.     sflg = FALSE;
  550.     fd = fopen(file,"w");
  551.  
  552.     if(fd == NULL)
  553.     {    
  554.         printf("Teledit: cannot create %s\n", file);
  555.         exit(1);
  556.     }
  557.  
  558.     printf("\nReady to receive %s\n", file);
  559.     sectnum = 0;
  560.     errors = 0;
  561.     toterr = 0;
  562.     bufctr = 0;
  563.     purgeline();
  564.     shocrt(0,0,0);
  565.     send(NAK);
  566.     do
  567.         { 
  568.         errorflag = FALSE;
  569.         do
  570.             firstchar = receive (10);
  571.         while(firstchar != SOH && firstchar != EOT && firstchar != TIMEOUT);
  572.  
  573.         if(firstchar == TIMEOUT)
  574.             errorflag = TRUE;
  575.         if(firstchar == SOH)
  576.         { 
  577.             sectcurr = receive (1);
  578.             sectcomp = receive (1);
  579.             if((sectcurr + sectcomp) == 255)
  580.             { 
  581.                 if(sectcurr == sectnum + 1)
  582.                 { 
  583.                     checksum = 0;
  584.                     for(j = bufctr;j < (bufctr + SECSIZ);j++)
  585.                     { 
  586.                         buffer[j] = receive (1);
  587.                         checksum = (checksum + buffer[j]) & 0xff;
  588.                     }
  589.                     if(checksum == receive (1))
  590.                     { 
  591.                         errors = 0;
  592.                         sectnum = sectcurr;
  593.                         bufctr = bufctr + SECSIZ;
  594.                         if(bufctr == TBFSIZ)
  595.                         { 
  596.                             bufctr = 0;
  597.                             write(fd, buffer, TBFSIZ);
  598.                         }
  599.                         shocrt(sectnum,errors,toterr);
  600.                         send(ACK);
  601.                     }
  602.                     else
  603.                         errorflag = TRUE;
  604.                 }
  605.                 else
  606.                     if(sectcurr == sectnum)
  607.                     { 
  608.                         do;
  609.                         while(receive (1) != TIMEOUT) 
  610.                             ;
  611.                         send(ACK);
  612.                     }
  613.                     else
  614.                         errorflag = TRUE;
  615.             }
  616.             else
  617.                 errorflag = TRUE;
  618.         }
  619.         if(errorflag == TRUE)
  620.         { 
  621.             errors++;
  622.             if(sectnum)
  623.                 toterr++;
  624.             while(receive (1) != TIMEOUT);
  625.             shocrt(sectnum,errors,toterr);
  626.             send(NAK);
  627.         }
  628.     }
  629.     while(firstchar != EOT && errors != ERRORMAX);
  630.  
  631.     if((firstchar == EOT) && (errors < ERRORMAX))
  632.     { 
  633.         send(ACK);
  634.         while(bufctr < TBFSIZ)
  635.             buffer[bufctr++] = 0;
  636.         write(fd, buffer, TBFSIZ);
  637.         printf("\nDone -- returning to menu:\n");
  638.     }
  639.     else
  640.         printf("\n\7Aborting\n\n");
  641.     fclose(fd);
  642. }
  643.  
  644. sendfile(file)
  645. char *file;
  646. { 
  647.     char *npnt;
  648.     int j, sectnum, sectors, attempts;
  649.     int toterr,checksum;
  650.     int bufctr, fd;
  651.     char buffer[BUFSIZ];
  652.  
  653.     sflg = TRUE;
  654.     fd = fopen(file,"r");
  655.  
  656.     if(fd == NULL)
  657.     { 
  658.         printf("\nTeledit: %s not found\n", file);
  659.         return;
  660.     }
  661. /*
  662.     else
  663.         printf("\nFile is %d sectors long.\n",rcfsiz(fd));
  664. */
  665.  
  666.     purgeline();
  667.     attempts=0;
  668.     toterr = 0;
  669.     shocrt(0,0,0);
  670.  
  671.     while((receive (10) != NAK) && (attempts != 8))
  672.     { 
  673.         attempts++;
  674.         shocrt(0,attempts,0);
  675.     }
  676.     if (attempts == 8)
  677.     { 
  678.         printf("\nTimed out awaiting initial NAK\n");
  679.         exit();
  680.     }
  681.     attempts = 0;
  682.     sectnum = 1;
  683.         
  684.     while((sectors = read(fd, buffer, BUFSIZ)) && (attempts != RETRYMAX))
  685.     { 
  686.         if(sectors == -1)
  687.         { 
  688.             printf("\nFile read error.\n");
  689.             break;
  690.         }
  691.         else
  692.         { 
  693.             sectors /= SECSIZ;
  694.             bufctr = 0;
  695.             do
  696.                 { 
  697.                 attempts = 0;
  698.                 do
  699.                     { 
  700.                     shocrt(sectnum,attempts,toterr);
  701.                     send(SOH);
  702.                     send(sectnum);
  703.                     send(-sectnum-1);
  704.                     checksum = 0;
  705.                     for(j = bufctr;j < (bufctr + SECSIZ);j++)
  706.                     { 
  707.                         send(buffer[j]);
  708.                         checksum = (checksum + buffer[j]) & 0xff;
  709.                     }
  710.                     send(checksum);
  711.                     purgeline();
  712.                     attempts++;
  713.                     toterr++;
  714.                 }
  715.                 while((receive (10) != ACK) && (attempts != RETRYMAX));
  716.                 bufctr = bufctr + SECSIZ;
  717.                 sectnum++;
  718.                 sectors--;
  719.                 toterr--;
  720.             }
  721.             while((sectors != 0) && (attempts != RETRYMAX));
  722.         }
  723.     }
  724.     if(attempts == RETRYMAX)
  725.         printf("\nNo ACK on sector, aborting\n");
  726.     else
  727.     { 
  728.         attempts = 0;
  729.         do
  730.             { 
  731.             send(EOT);
  732.             purgeline();
  733.             attempts++;
  734.         }
  735.         while((receive (10) != ACK) && (attempts != RETRYMAX));
  736.         if(attempts == RETRYMAX)
  737.             printf("\nNo ACK on EOT, aborting\n");
  738.     } 
  739.     fclose(fd);
  740.     printf("\nDone -- Returning to menu:\n");
  741. }
  742.  
  743. ask(s)
  744. char *s;
  745. {
  746.  
  747.     char c;
  748.  
  749. again:    
  750.     printf("%s (y/n)? ", s);
  751.     c = 0XDF & getchar();
  752.     putchar(c);
  753.     if(c == 'Y') {
  754.         printf("es\n");
  755.         return 1;
  756.     }
  757.  
  758.     else if(c == 'N')
  759.         printf("o\n");
  760.     else
  761.     {
  762.         printf("  \7Yes or no, please...\n");
  763.         goto again;
  764.     }
  765.     return 0;
  766. }
  767.  
  768. find(lineptr, linect)    /*Find a line having the pattern in linebuf        */
  769. char *lineptr[];
  770. int linect;
  771. {
  772.     int i;
  773.  
  774.     for(i = linect; lineptr[i] != NULL; i++)
  775.         if(pat(lineptr[i], linebuf) >= 0)
  776.             return(i);
  777.     return(-1);
  778. }
  779.  
  780. kill(lineptr, linect, nl)    /* erase lines */
  781. char *lineptr[];
  782. int linect, nl;
  783. {
  784.     int i, j;
  785.  
  786.     for (i = linect; lineptr[i] != NULL && nl > 0; i++, nl--) {
  787. /*
  788.         free(lineptr[i]);
  789. */
  790.         nlines--;
  791.     }
  792.     lineptr[linect] = NULL;
  793.     if(lineptr[i] != NULL) {
  794.         j = (nlines - linect) * 2;
  795.         movmem(&lineptr[i], &lineptr[linect], j + 2); 
  796.     }
  797. }
  798.  
  799. lfind(lineptr, linect)         /* find pattern at beginning of a line */
  800. char *lineptr[];
  801. int linect;
  802. {
  803.     int i, j;
  804.     char line[MAXLINE];
  805.  
  806.     j = strlen(linebuf);
  807.     for (i = linect; lineptr[i] != NULL; i++) {
  808.         strcpy(line, lineptr[i]);
  809.         line[j] = NULL;
  810.         if(strcmp(line, linebuf) == 0)
  811.             return i;
  812.     }
  813.     return -1;
  814. }
  815.  
  816.  
  817. pat(s, t)    /* pattern match..*/
  818. char s[], t[];
  819. {
  820.     int i, j, k;
  821.  
  822.     for(i = 0; s[i] != '\0'; i++)
  823.     {
  824.         for(j = i, k=0; t[k] != '\0' && s[j] == t[k]; j++, k++)
  825.             ;
  826.         if(t[k] == '\0')
  827.             return(i);
  828.     }
  829.     return(-1);
  830. }
  831.  
  832. show (lineptr, linect, nl)    /* screen current frame */
  833. char *lineptr[];
  834. int linect, nl;
  835. {
  836.     int i;
  837.  
  838.     printf (CLEARS);
  839.     putchar('\n');
  840.  
  841.     for (i = linect; i < (linect+nl) && lineptr[i] != NULL; i++)
  842.         printf("%s", lineptr[i]);
  843.     printf (HC);
  844.     return(i);
  845. }
  846.  
  847. show1(lineptr, linect)
  848. char **lineptr;
  849. int linect;
  850. {
  851.     int i;
  852.  
  853.     for(i = 0; i < nl; i++)
  854.         putchar('\n');
  855.  
  856.     if((linect + nl) >= nlines)
  857.         putchar('\n');
  858.     else
  859.         printf("%s", lineptr[linect+nl]);
  860.  
  861.     printf(HC);
  862.  
  863.     for(i = 0; i < 78; i++)
  864.         putchar(' ');
  865.  
  866.     printf("\r*");
  867. }
  868.  
  869. terminal()    /* terminal mode, no text */
  870. {
  871.     int inchar;
  872.  
  873.     while(1)
  874.     {
  875.         if(miready())
  876.             putchar(in(MDATA));
  877.         if(inchar = chrdy())
  878.         {
  879.             if(echoflg)
  880.                 putchar(inchar);
  881.  
  882.             if(inchar == SPECIAL)
  883.                 return;
  884.             else
  885.                 send(inchar);
  886.         }
  887.     }
  888. }
  889.  
  890. char *getm(line)    /* get memory for line, store it, return pointer */
  891. char line[];
  892. {
  893.     int    strsiz;
  894.     char    *p;
  895.  
  896.     strsiz = strlen(line) + 1;
  897.     if((textbuf + textind + strsiz) < textend) {
  898.         p = textbuf + textind;
  899.         textind += strsiz;
  900.         strcpy(p, line);
  901.     } else
  902.         p = 0;
  903.     return(p);
  904. }
  905.  
  906. iblock(rb, ib, cl)        /* insert block ib into rb at cl */
  907. char *rb[], *ib[];
  908. int cl;
  909. {
  910.     int i, j;
  911.  
  912.     j = 0;
  913.     if (rb[cl]) {
  914.         for (i = 0; ib[i]; i++)
  915.             ;
  916.         j = (nlines - cl) * 2;
  917.         movmem (&rb[cl], &rb[cl+i], j + 2);
  918.     }
  919.     for (i = 0; ib[i]; i++, cl++)
  920.         rb[cl] = ib[i];
  921.     if(!j) rb[cl] = NULL;
  922.     nlines += i;
  923.     return cl;    /* return new current line */
  924. }
  925.  
  926. gets(str)    /* Get a string from the console */
  927. char    *str; {
  928.  
  929.     lnmode();
  930.     while((*str = getchar()) != '\n')
  931.         str++;
  932.     *str = 0;
  933.     chmode();
  934. }
  935.  
  936. fgets(str,fdes)    /* Get a string from a file */
  937. char    *str;
  938. int    fdes; {
  939.  
  940.     while((*str = getc(fdes)) != '\n' && *str != EOF)
  941.         str++;
  942.     if(*str == EOF)
  943.         return(NULL);
  944.     else {
  945.         *str++ = '\n';
  946.         *str = 0;
  947.         return(str);
  948.     }
  949. }
  950.  
  951. sleep(seconds)
  952. int    seconds; {
  953.     int    i;
  954.  
  955.     while(seconds--)
  956.         for(i = 0 ; i < SPS ; i++)
  957.             ;
  958. }
  959.  
  960. tolower(c)    /* Convert c to lower case */
  961. char    c; {
  962.  
  963.     if(c >= 'A' && c <= 'Z')
  964.         c += 040;
  965.     return(c);
  966. }
  967.  
  968. isdigit(c)    /* Test if c is a digit */
  969. char    c; {
  970.  
  971.     if(c >= '0' && c <= '9')
  972.         return(1);
  973.     else
  974.         return(0);
  975. }
  976.  
  977. max(a,b)    /* Return Maximum */
  978. int    a,b; {
  979.  
  980.     return( (a > b) ? a : b);
  981. }
  982.  
  983. min(a,b)    /* Return minimum */
  984. int    a,b; {
  985.  
  986.     return( (a < b) ? a : b);
  987.  
  988. }
  989.  
  990. movmem(add1,add2,count)        /* Move memory */
  991. char    *add1,*add2;
  992. int    count; {
  993.  
  994.     while(count--)
  995.         *add2++ = *add1++;
  996. }
  997.