home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 28 / amigaformatcd28.iso / -seriously_amiga- / archivers / arcppc / src / arcmisc.c < prev    next >
C/C++ Source or Header  |  1998-04-23  |  9KB  |  479 lines
  1. /*
  2.  * Miscellaneous routines to get ARC running on non-MSDOS systems...
  3.  * $Header: arcmisc.c,v 1.8 88/07/31 18:50:56 hyc Exp $ 
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <ctype.h>
  8. #include "arc.h"
  9.  
  10. #if    MSDOS
  11. #include <dir.h>
  12. #include <stat.h>
  13. #endif
  14.  
  15. #if    GEMDOS
  16. #include <osbind.h>
  17. #include <stat.h>
  18. char           *index(), *rindex();
  19.  
  20. void 
  21. exitpause()
  22. {
  23.     while (Cconis())
  24.         Cnecin();
  25.     fprintf(stderr, "Press any key to continue: ");
  26.     fflush(stderr);
  27.     Cnecin();
  28.     fprintf(stderr, "\n");
  29. }
  30.  
  31. int
  32. chdir(dirname)
  33.     char           *dirname;
  34. {
  35.     char           *i;
  36.     int             drv;
  37.  
  38.     i = dirname;
  39.     if ((i = index(dirname, ':')) != NULL) {
  40.         drv = i[-1];
  41.         i++;        /* Move past device spec */
  42.         if (drv > '\'')
  43.             drv -= 'a';
  44.         else
  45.             drv -= 'A';
  46.         if (drv >= 0 && drv < 16)
  47.             Dsetdrv(drv);
  48.     }
  49.     if (*i != '\0')
  50.         return (Dsetpath(i));
  51. }
  52. #endif
  53.  
  54. #if    UNIX
  55. #include <sys/types.h>
  56. #include <sys/dir.h>
  57. #include <sys/stat.h>
  58.     int    rename(), unlink();
  59. #endif
  60.  
  61. #if    SYSV
  62. #include <dirent.h>
  63. #define DIRECT dirent
  64. #else
  65. #define DIRECT direct
  66. #endif
  67.  
  68. #if    BSD
  69. char    *
  70. memset(s, c, n)        /* oops. Thought it was standard BSD, but my Sun */
  71.     char    *s;    /* fooled me again. -- hyc */
  72.     int    c, n;
  73. {
  74.     register int i;
  75.     for(i=0;i<n;i++)
  76.         s[i]=c;
  77.     return(s);
  78. }
  79. #endif
  80.  
  81. char           *strcpy(), *strcat(), *malloc();
  82. int             strlen(), strcmp(), match();
  83.  
  84. int
  85. move(oldnam, newnam)
  86.     char           *oldnam, *newnam;
  87. {
  88.     FILE           *fopen(), *old, *new;
  89. #if    !MTS
  90.     struct stat     oldstat;
  91. #endif
  92.     char           *strcpy();
  93.     void        filecopy();
  94. #if    GEMDOS
  95.     if (Frename(0, oldnam, newnam))
  96. #else
  97.     if (rename(oldnam, newnam))
  98. #endif
  99. #if    !MTS
  100.     {
  101.         if (stat(oldnam, &oldstat))    /* different partition? */
  102.             return (-1);
  103.         old = fopen(oldnam, OPEN_R);
  104.         if (old == NULL)
  105.             return (-1);
  106.         new = fopen(newnam, OPEN_W);
  107.         if (new == NULL)
  108.             return (-1);
  109.         filecopy(old, new, oldstat.st_size);
  110.         return(unlink(oldnam));
  111.     }
  112.     return 0;
  113. #else
  114.     return(-1);
  115. #endif
  116. }
  117.  
  118. static void
  119. _makefn(source, dest)
  120.     char           *source;
  121.     char           *dest;
  122. {
  123.     int             j;
  124. #if    MSDOS
  125.     char           *setmem();
  126. #else
  127.     char           *memset();
  128. #endif
  129.  
  130.     setmem(dest, 17, 0);    /* clear result field */
  131.     for (j = 0; *source && *source != '.'; ++source)
  132.         if (j < 8)
  133.             dest[j++] = *source;
  134.     for (j = 9; *source; ++source)
  135.         if (j < 13)
  136.             dest[j++] = *source;
  137. }
  138. /*
  139.  * make a file name using a template 
  140.  */
  141.  
  142. char           *
  143. makefnam(rawfn, template, result)
  144.     char           *rawfn;    /* the original file name */
  145.     char           *template;    /* the template data */
  146.     char           *result;    /* where to place the result */
  147. {
  148.     char            et[17], er[17], rawbuf[STRLEN], *i, *rindex();
  149.  
  150.     *rawbuf = 0;
  151.     strcpy(rawbuf, rawfn);
  152. #if    MTS
  153.     i = rawbuf;
  154.     if (rawbuf[0] == tmpchr[0]) {
  155.         i++;
  156.         strcpy(rawfn, i);
  157.     } else
  158. #endif
  159.     if ((i = rindex(rawbuf, CUTOFF))) {
  160.         i++;
  161.         strcpy(rawfn, i);
  162.     }
  163. #if    DOS
  164.     else if ((i = rindex(rawbuf, ':'))) {
  165.         i++;
  166.         strcpy(rawfn, i);
  167.     }
  168. #endif
  169.     if (i)
  170.         *i = 0;
  171.     else
  172.         *rawbuf = 0;
  173.  
  174.     _makefn(template, et);
  175.     _makefn(rawfn, er);
  176.     *result = 0;        /* assure no data */
  177.     strcat(result, rawbuf);
  178.     strcat(result, er[0] ? er : et);
  179.     strcat(result, er[9] ? er + 9 : et + 9);
  180.     return ((char *) &result[0]);
  181. }
  182.  
  183. #if    MSDOS || SYSV
  184.  
  185. int
  186. alphasort(dirptr1, dirptr2)
  187.     struct DIRECT **dirptr1, **dirptr2;
  188. {
  189.     return (strcmp((*dirptr1)->d_name, (*dirptr2)->d_name));
  190. }
  191.  
  192. #endif
  193.  
  194. void
  195. upper(string)
  196.     char           *string;
  197. {
  198.     char           *p;
  199.  
  200.     for (p = string; *p; p++)
  201.         if (islower(*p))
  202.             *p = toupper(*p);
  203. }
  204. /* VARARGS1 */
  205. void
  206. abort(s, arg1, arg2, arg3)
  207.     char           *s;
  208. {
  209.     fprintf(stderr, "ARC: ");
  210.     fprintf(stderr, s, arg1, arg2, arg3);
  211.     fprintf(stderr, "\n");
  212. #if    UNIX
  213.     perror("UNIX");
  214. #endif
  215. #if    GEMDOS
  216.     exitpause();
  217. #endif
  218.     exit(1);
  219. }
  220.  
  221. #if    !MTS
  222.  
  223. char           *
  224. gcdir(dirname)
  225.     char           *dirname;
  226.  
  227. {
  228.     char           *getwd();
  229. #if    GEMDOS
  230.     int             drv;
  231.     char           *buf;
  232. #endif
  233.     if (dirname == NULL || strlen(dirname) == 0)
  234.         dirname = (char *) malloc(1024);
  235.  
  236. #if    !GEMDOS
  237.     getwd(dirname);
  238. #else
  239.     buf = dirname;
  240.     *buf++ = (drv = Dgetdrv()) + 'A';
  241.     *buf++ = ':';
  242.     Dgetpath(buf, 0);
  243. #endif
  244.     return (dirname);
  245. }
  246.  
  247. #if    UNIX
  248. char           *pattern;    /* global so that fmatch can use it */
  249. #endif
  250.  
  251. char           *
  252. dir(filename)        /* get files, one by one */
  253.     char           *filename;    /* template, or NULL */
  254. {
  255. #if    GEMDOS
  256.     static int      Nnum = 0;
  257.     static DMABUFFER dbuf, *saved;
  258.     char           *name;
  259.  
  260.     if (Nnum == 0) {    /* first call */
  261.         saved = (DMABUFFER *) Fgetdta();
  262.         Fsetdta(&dbuf);
  263.         if (Fsfirst(filename, 0) == 0) {
  264.             name = malloc(FNLEN);
  265.             strcpy(name, dbuf.d_fname);
  266.             Nnum++;
  267.             return (name);
  268.         } else {
  269.             Fsetdta(saved);
  270.             return (NULL);
  271.         }
  272.     } else {
  273.         if (Fsnext() == 0) {
  274.             name = malloc(FNLEN);
  275.             strcpy(name, dbuf.d_fname);
  276.             return (name);
  277.         } else {
  278.             Nnum = 0;
  279.             Fsetdta(saved);
  280.             return (NULL);
  281.         }
  282.     }
  283. }
  284. #else
  285.     static struct DIRECT **namelist;
  286.     static char   **NameList;
  287.     static char    namecopy[STRLEN], *dirname;
  288. #if    UNIX
  289.     int             alphasort();
  290.     int             scandir();
  291. #endif                /* UNIX */
  292.     int             fmatch(), free();
  293.     static int      Nnum = 0, ii;
  294.     char        *rindex();
  295.  
  296.  
  297.     if (Nnum == 0) {    /* first call */
  298.         strcpy(namecopy,filename);
  299.         if(pattern=rindex(namecopy,CUTOFF)) {
  300.             *pattern = 0;
  301.             pattern++;
  302.             dirname = namecopy;
  303.         } else {
  304.             pattern = filename;
  305.             dirname = ".";
  306.         }
  307.         Nnum = scandir(dirname, &namelist, fmatch, alphasort);
  308.         NameList = (char **) malloc(Nnum * sizeof(char *));
  309.         for (ii = 0; ii < Nnum; ii++) {
  310.             (NameList)[ii] = malloc(strlen(namelist[ii]->d_name) + 1);
  311.             strcpy((NameList)[ii], namelist[ii]->d_name);
  312.         }
  313.         ii = 0;
  314.     }
  315.     if (ii >= Nnum) {    /* all out of files */
  316.         if (Nnum) {    /* there were some files found */
  317.             for (ii = 0; ii < Nnum; ii++)
  318.                 free(namelist[ii]);
  319.             free(namelist);
  320.         }
  321.         Nnum = 0;
  322.         return (NULL);
  323.     } else {
  324.         return ((NameList)[ii++]);
  325.     }
  326. }
  327.  
  328. /*
  329.  * Filename match - here, * matches everything 
  330.  */
  331.  
  332. int
  333. fmatch(direntry)
  334.     struct DIRECT  *direntry;
  335. {
  336.     char           *string;
  337.  
  338.     string = direntry->d_name;
  339.  
  340.     if (!strcmp(pattern, "") || !strcmp(pattern, "*.*") || !strcmp(pattern, "*"))
  341.         return (1);
  342.     return (match(string, pattern));
  343. }
  344. #endif                /* GEMDOS */
  345. #else
  346. /* dir code for MTS under Bell Labs C... */
  347.  
  348. char           *
  349. dir(filepattern)
  350.     char           *filepattern;    /* template or NULL */
  351. {
  352.     char           *malloc(), *index();
  353. #if    USECATSCAN
  354.     fortran void    catscan(), fileinfo();
  355.  
  356.     struct catname {
  357.         short           len;
  358.         char            name[257];
  359.     }               pattern;
  360.  
  361.     struct catval {
  362.         int             maxlen;
  363.         int             actlen;
  364.         char            name[257];
  365.     }               catreturn;
  366.  
  367.     char           *i;
  368.     int             j, RETCODE;
  369.  
  370.     static int      catptr = 0;
  371.     static int      catflag = 0x200;
  372.     static int      cattype = 1;
  373.     static int      patflag = 0;
  374.  
  375.     catreturn.maxlen = 256;
  376.  
  377.     if (patflag) {
  378.         patflag = 0;
  379.         catptr = 0;
  380.         return (NULL);
  381.     }
  382.     if (filepattern) {
  383.         strcpy(pattern.name, filepattern);
  384.         pattern.len = strlen(filepattern);
  385.         if (!index(filepattern, '?'))
  386.             patflag = 1;
  387.     }
  388.     if (patflag) {
  389.         fileinfo(&pattern, &cattype, "CINAME  ", &catreturn, _retcode RETCODE);
  390.         catptr = RETCODE ? 0 : 1;
  391.     } else
  392.         catscan(&pattern, &catflag, &cattype, &catreturn, &catptr);
  393.  
  394.     if (!catptr)
  395.         return (NULL);
  396.     else {
  397.         char           *k;
  398.  
  399.         k = index(catreturn.name, ' ');
  400.         if (k)
  401.             *k = 0;
  402.         else {
  403.             j = catreturn.actlen;
  404.             catreturn.name[j] = 0;
  405.         }
  406.         k = catreturn.name;
  407.         if (catreturn.name[0] == tmpchr[0])
  408.             k++;
  409.         else if ((k = index(catreturn.name, sepchr[0])))
  410.             k++;
  411.         else
  412.             k = catreturn.name;
  413.         j = strlen(k);
  414.         i = malloc(++j);
  415.         strcpy(i, k);
  416.         return (i);
  417.     }
  418. #else
  419.     fortran void    gfinfo();
  420.     static char     gfname[24];
  421.     static char     pattern[20];
  422.     static int      gfdummy[2] = {
  423.                       0, 0
  424.     },              gfflags;
  425.     int             i, RETCODE;
  426.     char           *j, *k;
  427.  
  428.     if (filepattern) {
  429.         strcpy(pattern, filepattern);
  430.         strcat(pattern, " ");
  431.         for (i = 20; i < 24; i++)
  432.             gfname[i] = '\0';
  433.         if (index(pattern, '?'))
  434.             gfflags = 0x0C;
  435.         else
  436.             gfflags = 0x09;
  437.     } else if (gfflags == 0x09)
  438.         return (NULL);
  439.  
  440.     gfinfo(pattern, gfname, &gfflags, gfdummy, gfdummy, gfdummy, _retcode RETCODE);
  441.     if (RETCODE)
  442.         return (NULL);
  443.     else {
  444.         k = index(gfname, ' ');
  445.         *k = '\0';
  446.         k = gfname;
  447.         if (gfname[0] == tmpchr[0])
  448.             k++;
  449.         else if ((k = index(gfname, sepchr[0])))
  450.             k++;
  451.         else
  452.             k = gfname;
  453.         i = strlen(k);
  454.         j = malloc(++i);
  455.         strcpy(j, k);
  456.         return (j);
  457.     }
  458. #endif
  459. }
  460.  
  461. int
  462. unlink(path)
  463.     char           *path;    /* name of file to delete */
  464. {
  465.     fortran void    destroy();
  466.     int             RETCODE;
  467.  
  468.     char            name[258];
  469.  
  470.     strcpy(name, path);
  471.     strcat(name, " ");
  472.     destroy(name, _retcode RETCODE);
  473.     if (RETCODE)
  474.         return (-1);
  475.     else
  476.         return (0);
  477. }
  478. #endif
  479.