home *** CD-ROM | disk | FTP | other *** search
/ Transactor / Transactor_27_1988_Transactor_Publishing.d64 / shellram.sda / TWINCOPY.C < prev   
Text File  |  2023-02-26  |  4KB  |  213 lines
  1. #include <stdio.h>
  2.  
  3. char indev;
  4. char outdev;
  5. char verbose;
  6. main(argc,argv)
  7. unsigned argc;
  8. char **av;
  9. {SHIFT-+}
  10.   int fcopy();
  11.   unsigned i;
  12.   char **argv;
  13.  
  14.   argv = av;
  15.   argc = init(argc,&argv);
  16.   for (i = 1; i < argc; ++i)
  17.     glob(argv[i],&fcopy);
  18. {SHIFT--}
  19.  
  20. init(argc,argv)
  21. {SHIFT-+}
  22.   extern char sysdev, wrkdev;
  23.  
  24.  
  25.   indev = sysdev;
  26.   outdev = wrkdev;
  27.   verbose = 0;
  28.   return argc;
  29. {SHIFT--}
  30.  
  31. /*
  32.  * eventually make this invoke function
  33.  * for each file in the work directory
  34.  * which matches "pattern"
  35.  *
  36.  * caveat: opendir() does not work with
  37.  *  RAM disk
  38.  * 2nd caveat: we copy FROM system disk
  39.  */
  40. glob(pattern, pfunc)
  41. char *pattern;
  42. int (*pfunc)();
  43. {SHIFT-+}
  44.   (*pfunc)(pattern);
  45. {SHIFT--}
  46.  
  47. #define CHKIN 0xffc6
  48. #define CHKOUT 0xffc9
  49. #define CLRCHN 0xffcc
  50. static char blflag;
  51. static char mlgetb[] = {SHIFT-+}
  52. 0x20, 0xCF, 0xFF, /* t1 jsr   chrin   */
  53. 0x91, 0xFB,       /*    sta   ($fb),y */
  54. 0xC8,             /*    iny           */
  55. 0x20, 0xB7, 0xFF, /*    jsr   readst  */
  56. 0xD0, 0x04,       /*    bne   t2      */
  57. 0xC4, 34,         /*    cpy   34      */
  58. 0xD0, 0xF1,       /*    bne   t1      */
  59. 0x60,             /* t2 rts           */
  60. {SHIFT--};
  61. unsigned
  62. getblk(buffer, size, fid)
  63. char *buffer;
  64. unsigned size;
  65. FILE fid;
  66. {SHIFT-+}
  67.   static char a, x, y;
  68.   unsigned n;
  69.  
  70.   if (blflag) return 0;
  71.   /* zero page usage:  see Power C Manual */
  72.   *((char **)0xfb) = buffer;
  73.   *((char *)34) = size;
  74.   sys(CLRCHN, &a, &x, &y);
  75.   x = fid;
  76.   sys(CHKIN, &a, &x, &y);
  77.   y = 0;
  78.   sys(mlgetb, &a, &x, &y);
  79.   n = y;
  80.   if (a != 0) blflag = a;
  81.   sys(CLRCHN, &a, &x, &y);
  82.   return n;
  83. {SHIFT--}
  84.  
  85. static char mlputb[] = {SHIFT-+}
  86. 0xB1, 34,         /* t1 lda   (34),y  */
  87. 0x20, 0xD2, 0xFF, /*    jsr   chrout  */
  88. 0xC8,             /*    iny           */
  89. 0xC4, 0xFB,       /*    cpy   $fb     */
  90. 0xD0, 0xF6,       /*    bne   t1      */
  91. 0x60,             /*    rts           */
  92. {SHIFT--};
  93.  
  94. unsigned
  95. putblk(buffer, n, fid)
  96. char *buffer;
  97. unsigned n;
  98. FILE fid;
  99. {SHIFT-+}
  100.   static char a, x, y;
  101.  
  102.   if (n == 0) return 0;
  103.   *((char **)34) = buffer;
  104.   *((char *)0xfb) = n;
  105.   sys(CLRCHN, &a, &x, &y);
  106.   x = fid;
  107.   sys(CHKOUT, &a, &x, &y);
  108.   y = 0;
  109.   sys(mlputb, &a, &x, &y);
  110.   sys(CLRCHN, &a, &x, &y);
  111.   return n;
  112. {SHIFT--}
  113.  
  114. static char buff[256];
  115. int
  116. fcopy(name)
  117. char *name;
  118. {SHIFT-+}
  119.   FILE openin(), openout();
  120.   FILE infid, outfid;
  121.   unsigned n;
  122.   auto unsigned type;
  123.  
  124.   type = 0;
  125.   if (verbose)
  126.     printf("copy %s from device %d to work\n",name,indev);
  127.   infid = 5;
  128.   if ((infid = openin(indev,3,name,&type)) == 0)
  129.     printf("can't open %s for input\n", name);
  130.   else if ((outfid = openout(name,type)) == 0 {CBM-*}{CBM-*}
  131.     ferror())
  132.     printf("can't open %s for output\n", name);
  133.   else {SHIFT-+}
  134. /*
  135.  * sorry, this isn't fast enough!
  136.  *
  137.  *  while((c = fgetc(infid)) != EOF)
  138.  *    fputc(c, outfid);
  139.  */
  140.     blflag = 0;
  141.     while ((n = getblk(buff,254,infid)) != 0)
  142.       putblk(buff,n,outfid);
  143.   {SHIFT--}
  144.   fclose(infid);
  145.   fclose(outfid);
  146. {SHIFT--}
  147.  
  148. /*
  149.  * openin - special
  150.  *   opens file on given device, and
  151.  *   attempts to determine input type
  152.  *   by the icky method of repeated
  153.  *   open attempts
  154.  *
  155.  * unfortunately this will be slow
  156.  */
  157. openin(dev,secadd,name,ptype)
  158. unsigned dev;
  159. unsigned secadd;
  160. char *name;
  161. unsigned *ptype;
  162. {SHIFT-+}
  163.   extern char wrkdev;
  164.   auto char nambuf[30];
  165.   register FILE rfid;
  166.   register char *tstr;
  167.   register unsigned fe;
  168.  
  169.   device(dev);
  170.   *ptype = 0;
  171.   tstr = index(name, ',');
  172.   if (tstr != NULL &&
  173.     *++tstr != '\0' && *tstr != 'r') {SHIFT-+}
  174.     rfid = fopen(name,"r");  /* leave *ptype 0 */
  175.     device(wrkdev);
  176.     return rfid;
  177.   {SHIFT--}
  178.  
  179.   for (tstr = "spu"; *tstr != '\0'; ++tstr) {SHIFT-+}
  180.     sprintf(nambuf,"%s,%c", name, *tstr);
  181.     rfid = fopen(nambuf,"r");
  182.     fe = ferror();
  183.     if (rfid != 0 && fe == 0) {SHIFT-+}
  184.       *ptype = *tstr;
  185.       device(wrkdev);
  186.       return rfid;
  187.     {SHIFT--}
  188.     else
  189.       fclose(rfid);
  190.   {SHIFT--}
  191.   device(wrkdev);
  192.   return 0;
  193. {SHIFT--}
  194.  
  195. /*
  196.  * openout - special to do fopen of
  197.  *  specified type
  198.  */
  199. FILE
  200. openout(name,type)
  201. char *name;
  202. unsigned type;
  203. {SHIFT-+}
  204.   auto char nambuf[30];
  205.  
  206.   if (type != 0) {SHIFT-+}
  207.     sprintf(nambuf,"%s,%c", name, type);
  208.     name = nambuf;
  209.   {SHIFT--}
  210.   return fopen(name,"w");
  211.   
  212. {SHIFT--}
  213.