home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / g / cpm68k.diff < prev    next >
Text File  |  2020-01-01  |  18KB  |  716 lines
  1. *** gcmdline.c    Sun Dec 26 20:05:38 1999
  2. --- ../gkermit68/GCMDLINE.C    Tue Mar 12 23:10:51 2002
  3. ***************
  4. *** 35,41 ****
  5.   
  6.   extern int nfils, parity, text, backup, rpsiz, urpsiz, timint;
  7.   extern int literal, quiet, keep, streamok, nomodes, manual, xonxoff, noxonxoff;
  8. ! extern char ttname[], *cmerrp, *cmarg, *cmarg2;
  9.   extern FILE * db;
  10.   
  11.   /* Variables exported from this module */
  12. --- 35,41 ----
  13.   
  14.   extern int nfils, parity, text, backup, rpsiz, urpsiz, timint;
  15.   extern int literal, quiet, keep, streamok, nomodes, manual, xonxoff, noxonxoff;
  16. ! extern char ttname[], *cmarg, *cmarg2;
  17.   extern FILE * db;
  18.   
  19.   /* Variables exported from this module */
  20. ***************
  21. *** 193,198 ****
  22. --- 193,202 ----
  23.           text = 0;
  24.           break;
  25.   
  26. + #ifdef CPM68K
  27. +       /* CP/M doesn't support case-sensitive args so allow 't' */
  28. +       case 't':
  29. + #endif
  30.         case 'T':            /* Text file transfer */
  31.           manual = 1;
  32.           text = 1;
  33. ***************
  34. *** 228,235 ****
  35.           }
  36.           if (db) {
  37.           extern char * versio, * build;
  38. !         if (!versio) versio = "";
  39. !         if (!build) build = "";
  40.           debug = 1;
  41.           setbuf(db,NULL);
  42.           fprintf(db,"%s: %s\n",
  43. --- 232,239 ----
  44.           }
  45.           if (db) {
  46.           extern char * versio, * build;
  47. !         if (versio == (char *)NULL) versio = "";
  48. !         if (build == (char *)NULL) build = "";
  49.           debug = 1;
  50.           setbuf(db,NULL);
  51.           fprintf(db,"%s: %s\n",
  52. ***************
  53. *** 237,243 ****
  54. --- 241,249 ----
  55.               (*build ? build : "BUILD UNKNOWN")
  56.               );
  57.           fprintf(db,"MAXPATHLEN = %d\n",MAXPATHLEN);
  58. + #ifndef NOGETENV
  59.           if (gptr) fprintf(db,"GKERMIT=\"%s\"\n",gptr);
  60. + #endif
  61.           }
  62.           break;
  63.   
  64. ***************
  65. *** 334,344 ****
  66.   VOID
  67.   usage() {
  68.       extern char * versio, * build, * url, * email;
  69. !     if (!versio) versio = "";
  70.       if (!*versio) versio = "gkermit UNKNOWN VERSION";
  71. !     if (!build) build = "UNKNOWN BUILD";
  72. !     if (!url) url = "";
  73. !     if (!email) email = "";
  74.       fprintf(stderr,"%s: %s.\n",versio,build);
  75.       fprintf(stderr,"Usage:  gkermit [ options ]\n");
  76.       fprintf(stderr,"Options:\n");
  77. --- 340,350 ----
  78.   VOID
  79.   usage() {
  80.       extern char * versio, * build, * url, * email;
  81. !     if (versio == (char *)NULL) versio = "";
  82.       if (!*versio) versio = "gkermit UNKNOWN VERSION";
  83. !     if (build == (char *)NULL) build = "UNKNOWN BUILD";
  84. !     if (url == (char *)NULL) url = "";
  85. !     if (email == (char *)NULL) email = "";
  86.       fprintf(stderr,"%s: %s.\n",versio,build);
  87.       fprintf(stderr,"Usage:  gkermit [ options ]\n");
  88.       fprintf(stderr,"Options:\n");
  89. *** gkermit.h    Sun Dec 26 21:25:52 1999
  90. --- ../gkermit68/GKERMIT.H    Thu Mar 14 22:03:37 2002
  91. ***************
  92. *** 27,36 ****
  93.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  94.   */
  95.   
  96. ! #ifndef _GKERMIT_H
  97. ! #define _GKERMIT_H
  98.   
  99.   #include <stdio.h>
  100.   
  101.   /* Kermit protocol definitions */
  102.   
  103. --- 27,39 ----
  104.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  105.   */
  106.   
  107. ! #ifndef _GKERM_H
  108. ! #define _GKERM_H
  109.   
  110. + /* avoid including stdio twice on CP/M-68K */
  111. + #ifndef CPM68K
  112.   #include <stdio.h>
  113. + #endif
  114.   
  115.   /* Kermit protocol definitions */
  116.   
  117. ***************
  118. *** 90,96 ****
  119. --- 93,101 ----
  120.   #ifdef __STDC__
  121.   #define VOID void
  122.   #else
  123. + #ifndef CPM68K        /* CP/M-68K 1.3 has void */
  124.   #define VOID int
  125. + #endif
  126.   #endif /* __STDC__ */
  127.   
  128.   /* SVORPOSIX = System V or POSIX */
  129. ***************
  130. *** 231,236 ****
  131. --- 236,248 ----
  132.   _MYPROTOTYPE( VOID usage, (void) );    /* Give usage message */
  133.   _MYPROTOTYPE( int gwart, (void) );    /* State table switcher */
  134.   
  135. + #ifdef CPM68K
  136. + /* function prototypes for CP/M-68K */
  137. + _MYPROTOTYPE( FILE *fopen, (void) );
  138. + _MYPROTOTYPE( FILE *fopenb, (void) );
  139. + _MYPROTOTYPE( char *malloc, (void) );
  140. + #endif
  141. + 
  142.   /* Externs */
  143.   
  144.   extern int errno;
  145. ***************
  146. *** 238,243 ****
  147.   extern int debug;
  148.   #endif /* _GKERMIT_C */
  149.   
  150. ! #endif /* _GKERMIT_H */
  151.   
  152.   /* End gkermit.h */
  153. --- 250,255 ----
  154.   extern int debug;
  155.   #endif /* _GKERMIT_C */
  156.   
  157. ! #endif /* _GKERM_H */
  158.   
  159.   /* End gkermit.h */
  160. *** gproto.w    Sun Dec 26 20:05:38 1999
  161. --- ../gkermit68/GPROTO.W    Thu Mar 14 22:05:11 2002
  162. ***************
  163. *** 33,39 ****
  164.   _MYPROTOTYPE( int closof, (void) );    /* Close output file */
  165.   _MYPROTOTYPE( VOID errpkt, (char *) );    /* Send Error packet */
  166.   
  167. ! extern char * xdata, *rdatap, **cmlist, *cmarg, *rpar(), strbuf[], filnam[];
  168.   extern int start, bctu, bctr, delay, cx, cz, failure, attributes, datalen;
  169.   extern int streamok, streaming, timint;
  170.   extern FILE * db;
  171. --- 33,39 ----
  172.   _MYPROTOTYPE( int closof, (void) );    /* Close output file */
  173.   _MYPROTOTYPE( VOID errpkt, (char *) );    /* Send Error packet */
  174.   
  175. ! extern char * xdata, *rdatap, **cmlist, *cmarg, *rpar(), filnam[];
  176.   extern int start, bctu, bctr, delay, cx, cz, failure, attributes, datalen;
  177.   extern int streamok, streaming, timint;
  178.   extern FILE * db;
  179. ***************
  180. *** 41,47 ****
  181.   static int x;
  182.   
  183.   static VOID
  184. ! streamon() {                /* Start streaming if negotiated */
  185.       x = 0;
  186.       if (streamok > 0) {
  187.       streaming = 1;
  188. --- 41,47 ----
  189.   static int x;
  190.   
  191.   static VOID
  192. ! stremon() {                /* Start streaming if negotiated */
  193.       x = 0;
  194.       if (streamok > 0) {
  195.       streaming = 1;
  196. ***************
  197. *** 72,78 ****
  198.           if (sfile() < 0) {        /* Yes, open it, send F packet, */
  199.           errpkt("sfile");
  200.       } else {            /* No error */
  201. !         streamon();
  202.           BEGIN ssfil;
  203.       }
  204.       } else {                /* No files to send, */
  205. --- 72,78 ----
  206.           if (sfile() < 0) {        /* Yes, open it, send F packet, */
  207.           errpkt("sfile");
  208.       } else {            /* No error */
  209. !         stremon();
  210.           BEGIN ssfil;
  211.       }
  212.       } else {                /* No files to send, */
  213. ***************
  214. *** 148,154 ****
  215.       spar(rdatap);            /* Set parameters from it */
  216.       ack1(rpar());            /* ACK with our parameters */
  217.       bctu = bctr;            /* Switch to negotiated block check */
  218. !     streamon();
  219.       BEGIN srfil;            /* Wait for file or EOT */
  220.   }
  221.   
  222. --- 148,154 ----
  223.       spar(rdatap);            /* Set parameters from it */
  224.       ack1(rpar());            /* ACK with our parameters */
  225.       bctu = bctr;            /* Switch to negotiated block check */
  226. !     stremon();
  227.       BEGIN srfil;            /* Wait for file or EOT */
  228.   }
  229.   
  230. ***************
  231. *** 160,166 ****
  232.       } else {
  233.       encstr(filnam);
  234.       ack1(xdata);
  235. !     streamon();
  236.       BEGIN sratt;
  237.       }
  238.   }
  239. --- 160,166 ----
  240.       } else {
  241.       encstr(filnam);
  242.       ack1(xdata);
  243. !     stremon();
  244.       BEGIN sratt;
  245.       }
  246.   }
  247. *** gunixio.c    Sun Dec 26 23:32:26 1999
  248. --- ../gkermit68/GUNIXIO.C    Tue Mar 12 23:10:51 2002
  249. ***************
  250. *** 70,79 ****
  251. --- 70,83 ----
  252.   #endif /* POSIX */
  253.   
  254.   #include <ctype.h>            /* Character types */
  255. + #ifndef CPM68K
  256.   #include <sys/types.h>            /* Needed e.g. by <stat.h> */
  257. + #endif
  258.   #include <signal.h>            /* Interrupts */
  259.   #include <setjmp.h>            /* Longjumps */
  260. + #ifndef CPM68K
  261.   #include <sys/stat.h>            /* File exist, file size */
  262. + #endif
  263.   #include <errno.h>            /* Error symbols */
  264.   #include "gkermit.h"            /* gkermit definitions */
  265.   
  266. ***************
  267. *** 142,147 ****
  268. --- 146,175 ----
  269.   #endif /* USE_GETCHAR */
  270.   #endif /* DUMBIO */
  271.   
  272. + #ifdef CPM68K
  273. + 
  274. + /* extracted from <osif.h> (including it in full results in name clashes) */
  275. + #define __OSIF(fn,arg) __BDOS((fn),(LONG)(arg))    /* CPM68K does it this way  */
  276. + #define EXIT        0    /* Exit to BDOS             */
  277. + #define CONIN        1    /* direct echoing con input */
  278. + #define CONOUT        2    /* Direct console output    */
  279. + #define LSTOUT        5    /* Direct list device output*/
  280. + #define CONIO        6    /* Direct console I/O       */
  281. + #define C_WRITESTR    9    /* Console string output    */
  282. + #define CONBUF        10    /* Read console buffer      */
  283. + #define C_STAT        11    /* Get console status       */
  284. + #define S_BDOSVER    12    /* Get System BDOS Ver Num  */
  285. + /* end of extract from <osif.h> */
  286. + 
  287. + #define SCOUNT    163000        /* sleep time constant for a 33MHz 68020 */
  288. + #define ACOUNT    10000        /* alarm time constant */
  289. + static int atime;
  290. + static long acount;
  291. + 
  292. + extern int text;        /* 0=binary, 1=text */
  293. + 
  294. + #endif /* CPM68K */
  295. + 
  296.   /* Header file deficiencies section... */
  297.   
  298.   #ifndef R_OK
  299. ***************
  300. *** 271,277 ****
  301.   
  302.   VOID
  303.   logerr(s) char * s; {            /* Log text and errno */
  304. !     if (!s) s = "";
  305.       if (!debug) return;
  306.       if (db) fprintf(db,"%s: errno = %d\n",s,errno);
  307.   }
  308. --- 299,305 ----
  309.   
  310.   VOID
  311.   logerr(s) char * s; {            /* Log text and errno */
  312. !     if (s == (char *)NULL) s = "";
  313.       if (!debug) return;
  314.       if (db) fprintf(db,"%s: errno = %d\n",s,errno);
  315.   }
  316. ***************
  317. *** 473,480 ****
  318. --- 501,512 ----
  319.       }
  320.   #else
  321.       if (xonxoff) {
  322. + #ifdef CPM68K
  323. +     if (debug) fprintf(db,"ttpkt CPM68K can't do Xon/Xoff!\n");
  324. + #else
  325.       ttraw.sg_flags |= TANDEM;
  326.       if (debug) fprintf(db,"ttpkt BSD Xon/Xoff\n");
  327. + #endif /* CPM68K */
  328.       }
  329.   #endif /* SETXONXOFF */
  330.       ttraw.sg_flags &= ~(ECHO|CRMOD);    /* No echo, etc */
  331. ***************
  332. *** 550,556 ****
  333. --- 582,590 ----
  334.       x = ioctl(0,TCFLSH,0);
  335.   #else
  336.   #ifdef BSD
  337. + #ifndef CPM68K
  338.       x = ioctl(0,TIOCFLUSH,&n);
  339. + #endif /* CPM68K */
  340.   #endif /* BSD */
  341.   #endif /* SYSV */
  342.   #endif /* POSIX */
  343. ***************
  344. *** 569,575 ****
  345.   
  346.    Call with:
  347.      dest - where to put it
  348. !    max  - maximum length
  349.      timo - timeout (seconds, 0 = none)
  350.      eol  - packet terminator
  351.      turn - half-duplex line turnaround character to wait for, 0 = none
  352. --- 603,609 ----
  353.   
  354.    Call with:
  355.      dest - where to put it
  356. !    maxl - maximum length
  357.      timo - timeout (seconds, 0 = none)
  358.      eol  - packet terminator
  359.      turn - half-duplex line turnaround character to wait for, 0 = none
  360. ***************
  361. *** 582,590 ****
  362.   
  363.   int
  364.   #ifdef __STDC__
  365. ! ttinl(char * dest, int max, int timo, char eol, char soh, int turn)
  366.   #else
  367. ! ttinl(dest,max,timo,eol,soh,turn) int max, timo, turn; char eol, soh, *dest;
  368.   #endif /* __STDC__ */
  369.   {
  370.       int n = 0, x = 0, flag = 0, rc = 0, ccn = 0; /* Local variables */
  371. --- 616,624 ----
  372.   
  373.   int
  374.   #ifdef __STDC__
  375. ! ttinl(char * dest, int maxl, int timo, char eol, char soh, int turn)
  376.   #else
  377. ! ttinl(dest,maxl,timo,eol,soh,turn) int maxl, timo, turn; char eol, soh, *dest;
  378.   #endif /* __STDC__ */
  379.   {
  380.       int n = 0, x = 0, flag = 0, rc = 0, ccn = 0; /* Local variables */
  381. ***************
  382. *** 607,617 ****
  383. --- 641,665 ----
  384.       } else {                /* Otherwise... */
  385.       while (1) {            /* Read until we have a packet */
  386.   #ifdef DUMBIO
  387. + #ifdef CPM68K
  388. +         /* use direct console I/O in order to implement a
  389. +          * timeout counter
  390. +          */
  391. +         if (timo) {
  392. +             if (__OSIF(CONIO, 0xfe) == 0) {
  393. +             /* no char ready, decrement timeout counter */
  394. +             tttimo();
  395. +             continue;
  396. +         }
  397. +         }
  398. +         c = (char)__OSIF(CONIO, 0xff);    /* blocking read */
  399. + #else
  400.           x = read(0,&c,1);        /* Dumb blocking read byte loop */
  401.           if (x < 0) {
  402.           logerr("ttinl XX read 1");
  403.           rc = -2;
  404.           }
  405. + #endif CPM68K
  406.   #else
  407.   #ifdef USE_GETCHAR
  408.           errno = 0;
  409. ***************
  410. *** 710,716 ****
  411.             continue;            /* Skip stuff between packets */
  412.           flag = 1;            /* Have SOH */
  413.   
  414. !         if (n >= max) {
  415.           if (debug) fprintf(db,"ttinl overflow\n");
  416.           rc = -2;
  417.           goto xttinl;
  418. --- 758,764 ----
  419.             continue;            /* Skip stuff between packets */
  420.           flag = 1;            /* Have SOH */
  421.   
  422. !         if (n >= maxl) {
  423.           if (debug) fprintf(db,"ttinl overflow\n");
  424.           rc = -2;
  425.           goto xttinl;
  426. ***************
  427. *** 822,829 ****
  428. --- 870,879 ----
  429.       while (n > 0) {            /* Send the packet with write() */
  430.       i = write(1,&s[m],n);        /* Allowing for partial results */
  431.       if (i < 0) {
  432. + #ifdef EWOULDBLOCK
  433.           if (errno == EWOULDBLOCK)    /* and even no results at all.. */
  434.             continue;
  435. + #endif
  436.           logerr("ttol write");
  437.           return(-1);
  438.       }
  439. ***************
  440. *** 853,858 ****
  441. --- 903,933 ----
  442.   
  443.   long
  444.   zchki(fn) char * fn; {            /* Check if file is readable */
  445. + #ifdef CPM68K
  446. +     int fd;
  447. +     long fsize, _filesz();
  448. + 
  449. +     /* CP/M-68K doesn't have stat().
  450. +      * Instead, we have to open the file and then use _filesz().
  451. +      */
  452. +     if (fn == (char *)NULL)
  453. +     return(-1);
  454. +     errno = 0;
  455. +     if (text)
  456. +     fd = open(fn,0);        /* text mode */
  457. +     else
  458. +     fd = openb(fn,0);        /* binary mode */
  459. +     if (fd == -1) {
  460. +     if (debug)
  461. +       fprintf(db,"zchki open %s errno = %d\n",fn,errno);
  462. +     return(-1);
  463. +     }
  464. +     fsize = _filesz(fd);
  465. +     close(fd);
  466. +     if (debug)
  467. +       fprintf(db,"zchki fsize = %ld\n",fsize);    /* GH */
  468. +     return(fsize);
  469. + #else    /* CPM68K */
  470.       struct stat buf;
  471.       if (!fn) return(-1);
  472.       if (stat(fn,&buf) < 0)
  473. ***************
  474. *** 869,874 ****
  475. --- 944,950 ----
  476.       return(-2);
  477.       }
  478.       return(buf.st_size);
  479. + #endif    /* CPM68K */
  480.   }
  481.   
  482.   int
  483. ***************
  484. *** 876,882 ****
  485.       int i, x;
  486.       char * s;
  487.   
  488. !     if (!fn)                /* Defend against empty name */
  489.         fn = "";
  490.       if (!*fn)
  491.         return(-1);
  492. --- 952,958 ----
  493.       int i, x;
  494.       char * s;
  495.   
  496. !     if (fn == (char *)NULL)        /* Defend against empty name */
  497.         fn = "";
  498.       if (!*fn)
  499.         return(-1);
  500. ***************
  501. *** 899,912 ****
  502. --- 975,1004 ----
  503.         s = ".";
  504.       }
  505.       errno = 0;
  506. + #ifdef CPM68K
  507. +     /* checking for write access to '.' is meaningless */
  508. +     if (*s == '.') {
  509. +     x = 0;
  510. +     } else {
  511. +         x = access(s,W_OK);        /* Check access of path. */
  512. +     }
  513. + #else
  514.       x = access(s,W_OK);            /* Check access of path. */
  515. + #endif
  516.       if (debug) fprintf(db,"zchko(%s) x = %d errno = %d\n",s,x,errno);
  517.       return((x < 0) ? -1 : 0);           /* and return. */
  518.   }
  519.   
  520.   int
  521.   zopeni(name) char *name; {        /* Open existing file for input */
  522. + #ifdef CPM68K
  523. +     if (text)
  524. +     ifp = fopen(name,"r");        /* open in text mode */
  525. +     else
  526. +     ifp = fopenb(name,"r");        /* open in binary mode */
  527. + #else
  528.       ifp = fopen(name,"r");
  529. + #endif
  530.       if (debug) fprintf(db,"zopeni %s: %d\n",name, ifp ? 0 : errno);
  531.       filelength = zchki(name);
  532.       if (filelength < 0)
  533. ***************
  534. *** 919,925 ****
  535. --- 1011,1024 ----
  536.   int
  537.   zopeno(name) char *name; {        /* Open new file for output */
  538.       errno = 0;
  539. + #ifdef CPM68K
  540. +     if (text)
  541. +     ofp = fopen(name,"w");        /* text mode */
  542. +     else
  543. +     ofp = fopenb(name,"w");        /* binary mode */
  544. + #else
  545.       ofp = fopen(name,"w");
  546. + #endif
  547.       if (debug) fprintf(db,"zopeno %s: %d\n",name, ofp ? 0 : errno);
  548.       if (ofp) {
  549.       strncpy(ofile,name,MAXPATHLEN);
  550. ***************
  551. *** 998,1013 ****
  552.   
  553.   int
  554.   zbackup(fn) char * fn; {        /* Back up existing file */
  555.       struct stat buf;
  556.       int i, j, k, x, state, flag;
  557.       char *p, newname[MAXPATHLEN+12];
  558.   
  559. !     if (!fn)                /* Watch out for null pointers. */
  560.         return(-1);
  561.       if (!*fn)                /* And empty names. */
  562.         return(-1);
  563.       if (stat(fn,&buf) < 0)        /* If file doesn't exist */
  564.         return(0);            /* no need to back it up. */
  565.   
  566.       i = strlen(fn);            /* Get length */
  567.       if (i > MAXPATHLEN)            /* Guard buffer */
  568. --- 1097,1120 ----
  569.   
  570.   int
  571.   zbackup(fn) char * fn; {        /* Back up existing file */
  572. + #ifndef CPM68K
  573.       struct stat buf;
  574. + #endif
  575.       int i, j, k, x, state, flag;
  576.       char *p, newname[MAXPATHLEN+12];
  577.   
  578. !     if (fn == (char *)NULL)        /* Watch out for null pointers. */
  579.         return(-1);
  580.       if (!*fn)                /* And empty names. */
  581.         return(-1);
  582. + #ifdef CPM68K
  583. +     /* CP/M-68K doesn't have stat(), use access() instead */
  584. +     if (access(fn,0) < 0)
  585. +     return(0);
  586. + #else
  587.       if (stat(fn,&buf) < 0)        /* If file doesn't exist */
  588.         return(0);            /* no need to back it up. */
  589. + #endif
  590.   
  591.       i = strlen(fn);            /* Get length */
  592.       if (i > MAXPATHLEN)            /* Guard buffer */
  593. ***************
  594. *** 1057,1064 ****
  595. --- 1164,1183 ----
  596.       if ((x + k + 3) > MAXPATHLEN)
  597.         x = MAXPATHLEN - k - 3;
  598.       sprintf(&newname[x],".~%d~",i); /* Make a backup name */
  599. + #ifdef CPM68K
  600. +     if (access(newname,0) < 0) {
  601. + #else
  602.       if (stat(newname,&buf) < 0) {    /* If it doesn't exist */
  603. + #endif
  604.           errno = 0;
  605. + #ifdef CPM68K
  606. +     /* CP/M-68K doesn' have link(), use rename() instead */
  607. +         if (rename(fn,newname) < 0) {
  608. +         if (debug)
  609. +           fprintf(db,"zbackup failed: rename(%s,%s): %d\n",fn,newname,errno);
  610. +         return(-1);
  611. + 
  612. + #else
  613.           if (link(fn,newname) <  0) { /* Rename old file to backup name */
  614.           if (debug)
  615.             fprintf(db,"zbackup failed: link(%s): %d\n",newname,errno);
  616. ***************
  617. *** 1067,1072 ****
  618. --- 1186,1192 ----
  619.           if (debug)
  620.             fprintf(db,"zbackup failed: unlink(%s): %d\n",fn,errno);
  621.           return(-1);
  622. + #endif
  623.           } else {
  624.           if (debug)
  625.             fprintf(db,"zbackup %s: OK\n",newname);
  626. ***************
  627. *** 1084,1089 ****
  628. --- 1204,1211 ----
  629.       int acase = 0, flag = 0, n = 0;
  630.       char * p;
  631.   
  632. +     if (debug)
  633. +       fprintf(db, "zrtol pktnam=%s\n", pktnam);    /* GH */
  634.       if (literal) {
  635.       strncpy(lclnam,pktnam,maxlen);
  636.       } else {
  637. ***************
  638. *** 1170,1172 ****
  639. --- 1292,1348 ----
  640.       zincnt--;                /* Return first byte. */
  641.       return(*zinptr++ & 0xff);
  642.   }
  643. + #ifdef CPM68K
  644. + /*
  645. +  * a crude sleep()
  646. +  */
  647. + sleep(sec) int sec;
  648. + {
  649. +     int i, a, b, c;
  650. +     long j;
  651. + 
  652. +     a = 101;
  653. +     b = 101;
  654. +     for (i = 0; i < sec; i++) {
  655. +         for (j = 0; j < SCOUNT; j++) {
  656. +             c = a * b;    /* compiles to 'muls' */
  657. +             b = c / a;    /* compiles to 'divs' */
  658. +         }
  659. +     }
  660. +     return(0);
  661. + }
  662. + /*
  663. +  * CP/M-68K has no timers so doesn't support a real alarm()
  664. +  * function. This just sets the timeout for tttimo()
  665. +  */
  666. + alarm(sec) int sec;
  667. + {
  668. +     atime = sec;
  669. +     acount = ACOUNT;
  670. +     return(0);
  671. + }
  672. + /*
  673. +  * timer for ttinl()
  674. +  */
  675. + tttimo()
  676. + {
  677. +     int a, b, c;
  678. + 
  679. +     if (atime == 0) {
  680. +     return(0);        /* no alarm set */
  681. +     }
  682. +     a = 101;
  683. +     b = 101;
  684. +     c = a * b;            /* compiles to 'muls' */
  685. +     b = c / a;            /* compiles to 'divs' */
  686. +     if (--acount == 0) {
  687. +         if (--atime == 0) {
  688. +         timerh(0);        /* timeout */
  689. +     }
  690. +     acount = ACOUNT;    /* reload timer */
  691. +     }
  692. +     return(0);
  693. + }
  694. + 
  695. + #endif /* CPM68K */
  696. + 
  697. *** gwart.c    Fri Dec 17 17:04:22 1999
  698. --- ../gkermit68/GWART.C    Thu Mar 14 22:08:30 2002
  699. ***************
  700. *** 437,443 ****
  701.           fprintf(stderr,"Can't open %s\n",argv[1]);
  702.           fatal("unreadable input file");
  703.       }
  704. !     } else infile = stdin;
  705.   
  706.       if (argc > 2) {
  707.       if ((outfile = fopen(argv[2],"w")) == NULL) {
  708. --- 437,443 ----
  709.           fprintf(stderr,"Can't open %s\n",argv[1]);
  710.           fatal("unreadable input file");
  711.       }
  712. !     } else infile = (FILE *)stdin;
  713.   
  714.       if (argc > 2) {
  715.       if ((outfile = fopen(argv[2],"w")) == NULL) {
  716.