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