home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / cpmug / cpmug050.ark / FROMCPM.C < prev    next >
Encoding:
C/C++ Source or Header  |  1984-04-29  |  4.0 KB  |  158 lines
  1. /*
  2. TITLE           read CPM format file from floppy dirve to standard output.
  3. AUTHOR          Robert A. Van Valzah   7/31/80
  4. LAST REVISOR    R. A. V.  04/03/80
  5. DISCLAIMER      This code was hacked together quickly and is far from
  6.                 optimal.  Correctness has been tested, but is not
  7.                 guaranteed!
  8. */
  9.  
  10. #include <stdio.h>
  11.  
  12. #define OSTRKS 2
  13.  
  14. int fd;  /* floppy disk file descriptor */
  15. int stt[26] = {                 /* sector translation (skew factor) table */
  16.          1,  7, 13, 19,
  17.         25,  5, 11, 17,
  18.         23,  3,  9, 15,
  19.         21,  2,  8, 14,
  20.         20, 26,  6, 12,
  21.         18, 24,  4, 10,
  22.         16, 22
  23.         };
  24. struct FCB {
  25.         char filetype;
  26.         char name[8];
  27.         char ext[3];
  28.         char reel;
  29.         char xx[2];
  30.         char rcnt;
  31.         char dm[16];
  32. };
  33. struct FCB dirbuf[4];
  34. int dbi;        /* dirbuf index to desired file */
  35. char buf[128];  /* disk data buffer */
  36. int nr;         /* next record number to read */
  37. struct FCB sfcb;
  38.  
  39. main(argc, argv)
  40. int argc;
  41. char *argv[];
  42. {
  43. int i, rs;
  44. char *sp, *dp;  /* source and destination pointers */
  45.  
  46.         if (argc!=2) {
  47.                 printf("Usage:  %s CPMfilename\n", argv[0]);
  48.                 exit(1);
  49.         }
  50.         fd=open("/dev/floppy",0);
  51.         argv++;
  52.         strcpy(sfcb.name, "           ");
  53.         sp = *argv;
  54.         dp = sfcb.name;
  55.         while (*sp && *sp!='.') {       /* pack name into sfcb */
  56.                 *dp++ = *sp<'a' ? *sp++ : (*sp++)-040 ;
  57.         }
  58.         if (*sp++ == '.') {             /* pack in ext if present */
  59.                 dp = sfcb.ext;
  60.                 while (*sp) {
  61.                         *dp++ = *sp<'a' ? *sp++ : (*sp++)-040 ;
  62.                 }
  63.         }
  64.         sfcb.reel = 0;
  65.         cpmOpen(sfcb);
  66.         if (dbi==-1) {
  67.                 printf("not found\n");
  68.                 exit (1);
  69.         }
  70.         rs = -1;
  71.         while (rs) {
  72.                 rs = cpmRead(buf);
  73.                 if (rs)
  74.                         for (i=0 ; i<=127 ; i++) {
  75.                                 if (buf[i]==26) exi t(0);
  76.                                 if (buf[i]==13) continue;
  77.                                 putchar(buf[i]);
  78.                         }
  79.         }
  80. }
  81.  
  82. /* simulate CPM read buffer call */
  83. cpmRead(buf)
  84. char *buf;
  85. {
  86. int dmap;
  87.         dmap = dirbuf[dbi].dm[nr/8];
  88.         if (dmap<0) dmap += 256;        /***HACK to get around sign extention */
  89.         if (dmap) {
  90.                 rdsec(dmap, nr%8, buf);
  91.                 nr++;
  92.                 if (nr == 128) {
  93.                         nr = 0;
  94.                         sfcb.reel++;
  95.                         cpmOpen(sfcb);
  96.                 }
  97.                 return (-1);
  98.         } else {
  99.                 return (0);
  100.         }
  101. }
  102.  
  103. /* simulate CPM open file function */
  104. cpmOpen(sfcb)
  105. struct FCB sfcb;
  106. {
  107. int grp, rec;
  108.         nr = 0;
  109.         for (grp=0 ; grp<2 ; grp++) {
  110.                 for (rec=0 ; rec <8 ; rec++) {
  111.                         rdsec(grp, rec, dirbuf);
  112.                         srchSec(sfcb);
  113.                         if (dbi!=-1) {
  114.                                 return;
  115.                         }
  116.                 }
  117.         }
  118.         return;
  119. }
  120.  
  121. srchSec(sfcb)
  122. struct FCB sfcb;
  123. {
  124.         for (dbi=0 ; dbi<=3 ; dbi++) {
  125.                 if  (srchFcb(sfcb, dirbuf[dbi]) == 0) {
  126.                         return;
  127.                 }
  128.         }
  129.         dbi = -1;
  130.         return;
  131. }
  132.  
  133. srchFcb(sfcb, fcb)
  134. struct FCB sfcb, fcb;
  135. {
  136. int i;
  137.         if (fcb.filetype==0) {
  138.                 for (i=0 ; i<=11 ; i++)         /* match name and reel */
  139.                         if (fcb.name[i]!=sfcb.name[i])
  140.                                 return (-1);
  141.                 return (0);
  142.         } else
  143.                 return (-1);
  144. }
  145.  
  146. rdsec(group, rec, buf)
  147. int group, rec;
  148. char *buf;
  149. {
  150. int offset, voffset, sec, trk;
  151.         voffset = group*8+rec;
  152.         sec = stt[voffset % 26];
  153.         trk = voffset / 26 + OSTRKS;
  154.         offset = (trk*26+sec-1)*128;
  155.         lseek(fd, offset, 0);
  156.         read(fd, buf, 128);
  157. }
  158.