home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / cpm / cpm68k / arc68k.arc / ARCMISC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-11-27  |  6.4 KB  |  220 lines
  1.  
  2. /*
  3.  *      arcmisc.c       1.1
  4.  *
  5.  *      Author: Thom Henderson
  6.  *      Original System V port: Mike Stump
  7.  *      Enhancements, Bug fixes, and cleanup: Chris Seaman
  8.  *      Date: Fri Mar 20 09:57:02 1987
  9.  *      Last Mod.       3/21/87
  10.  *
  11.  */
  12.  
  13. /*
  14.  * ARC - Archive utility - ARCMISC
  15.  * 
  16.  * Description:
  17.  *      This file contains miscellaneous routines for string
  18.  *      management, file management, and program control.
  19.  */
  20.  
  21. #include "arc.h"
  22. #include <ctype.h>
  23.  
  24. INT rempath(nargs,arg)               /* remove paths from filenames */
  25. INT nargs;                           /* number of names */
  26. char *arg[];                         /* pointers to names */
  27. {
  28.     char *i, *strrchr();             /* string index, reverse indexer */
  29.     INT n;                           /* index */
  30.  
  31.     for(n=0; n<nargs; n++)           /* for each supplied name */
  32.     {
  33.         i=strrchr(arg[n],'/');       /* search for end of path */
  34.         if(i)                        /* if path was found */
  35.             arg[n] = i+1;            /* then skip it */
  36.     }
  37. }
  38.  
  39. /* make a file name using a template */
  40. char *makefnam(rawfn,template,result)
  41. char *rawfn;                /* the original file name */
  42. char *template;             /* the template data */
  43. char *result;               /* where to place the result */
  44. {
  45.     char *arc_ext;          /* possible existing extension */
  46.     char *i, *strrchr();             /* string indexing stuff */
  47.  
  48.     arc_ext = ".arc";
  49.     i = strrchr(rawfn,'.');          /* strip 'arc' extension from filename */
  50.     if (i)
  51.      *i = '\0';
  52.  
  53.     strncpy(result,rawfn,10);        /* rebuild it using supplied template */
  54.     strcat(result,template);
  55.     return result;
  56. }
  57.  
  58. /*  convert a string to upper case  */
  59. upper(s)
  60. register char *s;
  61. {
  62.     while (*s = toupper(*s)) ++s;
  63. }
  64.  
  65. setmem(dest,size,c)
  66. char *dest,c;
  67. INT size;
  68. {
  69.     register i;
  70.  
  71.     for (i = 0; i < size; dest[i] = c, i++);
  72. }
  73.  
  74. abort(s,arg1,arg2,arg3)                /* something went wrong...QUIT!! */
  75. char *s;
  76. {
  77.     char tname1[STRLEN], tname2[STRLEN];
  78.  
  79.     sprintf(tname1,"%s.crn",arctemp);
  80.     sprintf(tname2,"%s.cvt",arctemp);
  81.  
  82.     unlink(bakname);                   /* remove all possible temp files */
  83.     unlink(newname);
  84.     unlink(tname1);
  85.     unlink(tname2);
  86.  
  87.     fprintf(stderr,"arc: ");           /* explain things to the user */
  88.     fprintf(stderr,s,arg1,arg2,arg3);
  89.     fprintf(stderr,"\n");
  90.     exit(1);                           /* quit */
  91. }
  92.  
  93. #ifndef CPM68K
  94. rename(o, n)
  95. char *o, *n;
  96. {
  97.     char ofcb[36], nfcb[36];
  98.     struct {
  99.         char *f;
  100.         char *s;
  101.     } as;
  102.  
  103.     as.f = ofcb;
  104.     as.s = o;
  105.     bdosp(70,&as);        /* get fcb for old name */
  106.     as.f = nfcb;
  107.     as.s = n;
  108.     bdosp(70,&as);        /* get correct format of newname */
  109.     strcpy(&ofcb[16],nfcb);
  110.     bdosp(23,ofcb);
  111.     return 0;
  112. /*
  113.     printf("rename not implemented. Archive name is %s\n",o);
  114.     return(link(o, n) || unlink(o));
  115. */
  116. }
  117. #endif
  118.  
  119. makenames(rawfn)
  120. char *rawfn;
  121. {
  122.     char pathtemp[STRLEN];             /* temporary path holder */
  123.     char nametemp[STRLEN];             /* temporary arcname holder */
  124.     char *buf;                         /* temporary pointer */
  125.     char *strrchr();                   /* string indexing junk */
  126.     long getpid();                     /* process id function */
  127.  
  128.     strcpy(pathtemp,rawfn);
  129.     if (buf = strrchr(rawfn,'/'))    /* if names are part of paths */
  130.     {                                  /* lots to do */
  131.         buf++;
  132.         pathtemp[strlen(rawfn)-strlen(buf)] = 0;
  133.         makefnam(buf,".arc",nametemp);             /* make 'arcname' */
  134.         makefnam(buf,".bak",nametemp);             /* make 'bakname' */
  135.         sprintf(arcname,"%s%s",pathtemp,nametemp);
  136.         sprintf(bakname,"%s%s",pathtemp,nametemp);
  137.         sprintf(arctemp,"%s.A%ld",pathtemp,getpid());
  138.     }
  139.     else                               /* not so much to do */
  140.     {
  141.         makefnam(rawfn,".arc",arcname);
  142.         makefnam(rawfn,".bak",bakname);
  143.         sprintf(arctemp,"Arc%ld",getpid());
  144.     }
  145.     sprintf(newname,"%s.arc",arctemp);
  146. }
  147.  
  148. onintr()                               /* SIGNAL was caught */
  149. {
  150.     abort("User Requested Abort");
  151. }
  152.  
  153. /*
  154.  * This function sorts the command line file arguments.  Needed since
  155.  * the add, update, etc., function does no sorting, and could result in
  156.  * multiple archive entries for the same file name.
  157.  */
  158. sortarg(num,arg)                       /* sort argument list, remove dups */
  159. int num;
  160. char *arg[];
  161. {
  162.     char *temp;                        /* temporary pointer */
  163.     INT top, seek;                     /* placeholders for sorting */
  164.     INT dups;                      /* how many duplicates are there */
  165.     char *strrchr(), *i;               /* string indexing stuff */
  166.     char *buf1, *buf2;                 /* pointers for strcmp to use */
  167.  
  168.     /* sort the arguments, ignoring pathnames */
  169.  
  170.     dups = 0;
  171.     for (top = 0; top<(num-1); top++)
  172.         for (seek=top+1; seek<num; seek++) {
  173.             buf1 = arg[top];
  174.             if (i = strrchr(arg[top],'/')) 
  175.         buf1 = i + 1;
  176.  
  177.             buf2 = arg[seek];
  178.             if (i = strrchr(arg[seek],'/')) 
  179.         buf2 = i + 1;
  180.  
  181.             if (strcmp(buf1,buf2) > 0) {
  182.                 temp = arg[top];
  183.                 arg[top] = arg[seek];
  184.                 arg[seek] = temp;
  185.             }
  186.         }
  187.  
  188.     /* find any occurences of 'arcname', and remove them */
  189.  
  190.     for (top=0; top<num; top++) {
  191.         while (strcmp(arg[top],arcname) == 0) {
  192.             for (seek=top; seek<num; seek++)
  193.                 arg[seek] = arg[seek + 1];
  194.             arg[--num] = '\0';
  195.             dups++;
  196.         }
  197.      }
  198.     /* find any other duplicate arguments (ignoring pathnames), */
  199.     /* and remove the second and subsequent occurences */
  200.  
  201.     for (top = 0;top < num-1;top++) {
  202.         buf1 = arg[top];
  203.         buf2 = arg[top + 1];
  204.         if (i = strrchr(arg[top],'/'))
  205.        buf1 = i + 1;
  206.         if (i = strrchr(arg[top + 1],'/')) 
  207.        buf2 = i + 1;
  208.         while (strcmp(buf1,buf2) == 0) {
  209.             for (seek=top+1; seek<num; seek++)
  210.                 arg[seek] = arg[seek+1];
  211.             arg[--num] = '\0';
  212.             buf2 = arg[top + 1];
  213.             if (i = strrchr(arg[top + 1],'/')) 
  214.         buf2 = i + 1;
  215.             dups++;
  216.         }
  217.     }
  218.     return(dups);              /* tell main() how many we found */
  219. }
  220.