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