home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c019 / 2.ddi / SOURCE / ZIP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-10  |  37.7 KB  |  1,266 lines
  1. /*
  2.  
  3.  Copyright (C) 1990-1993 Mark Adler, Richard B. Wales, Jean-loup Gailly,
  4.  Kai Uwe Rommel and Igor Mandrichenko.
  5.  Permission is granted to any individual or institution to use, copy, or
  6.  redistribute this software so long as all of the original files are included,
  7.  that it is not sold for profit, and that this copyright notice is retained.
  8.  
  9. */
  10.  
  11. /*
  12.  *  zip.c by Mark Adler.
  13.  */
  14.  
  15. #include "revision.h"
  16. #include "zip.h"
  17. #include "crypt.h"
  18. #ifdef VMS
  19. #  include "VMSmunch.h"
  20. #endif
  21. #if (defined(MSDOS) && !defined(__GO32__)) || defined(__human68k__)
  22. #  include <process.h>
  23. #endif
  24. #include <signal.h>
  25.  
  26. #ifdef MACOS
  27. #  include <console.h>
  28. #endif
  29.  
  30. #define MAXCOM 256      /* Maximum one-line comment size */
  31.  
  32.  
  33. /* Local option flags */
  34. #define DELETE  0
  35. #define ADD     1
  36. #define UPDATE  2
  37. #define FRESHEN 3
  38. local int action = ADD; /* one of ADD, UPDATE, FRESHEN, or DELETE */
  39. local int comadd = 0;   /* 1=add comments for new files */
  40. local int zipedit = 0;  /* 1=edit zip comment and all file comments */
  41. local int latest = 0;   /* 1=set zip file time to time of latest file */
  42. local ulg before = 0;   /* 0=ignore, else exclude files before this time */
  43. local int test = 0;     /* 1=test zip file with unzip -t */
  44. local int tempdir = 0;  /* 1=use temp directory (-b) */
  45.  
  46. /* Temporary zip file name and file pointer */
  47. local char *tempzip;
  48. local FILE *tempzf;
  49.  
  50. /* Local functions */
  51.  
  52. local void freeup  OF((void));
  53. local void leave   OF((int));
  54. local void handler OF((int));
  55. local void license OF((void));
  56. local void help    OF((void));
  57. local void zipstdout OF((void));
  58. local void check_zipfile OF((char *zipname));
  59. local void get_filters OF((int argc, char **argv));
  60.       int  main     OF((int, char **));
  61. local int count_args OF((char *s));
  62. local void envargs   OF((int *Pargc, char ***Pargv, char *envstr));
  63.  
  64.  
  65.  
  66. local void freeup()
  67. /* Free all allocations in the found list and the zfiles list */
  68. {
  69.   struct flist far *f;  /* steps through found list */
  70.   struct zlist far *z;  /* pointer to next entry in zfiles list */
  71.  
  72.   for (f = found; f != NULL; f = fexpel(f))
  73.     ;
  74.   while (zfiles != NULL)
  75.   {
  76.     z = zfiles->nxt;
  77.     free((voidp *)(zfiles->name));
  78.     if (zfiles->zname != zfiles->name)
  79.       free((voidp *)(zfiles->zname));
  80.     if (zfiles->ext)
  81.       free((voidp *)(zfiles->extra));
  82.     if (zfiles->cext && zfiles->cextra != zfiles->extra)
  83.       free((voidp *)(zfiles->cextra));
  84.     if (zfiles->com)
  85.       free((voidp *)(zfiles->comment));
  86.     farfree((voidp far *)zfiles);
  87.     zfiles = z;
  88.     zcount--;
  89.   }
  90. }
  91.  
  92.  
  93. local void leave(e)
  94. int e;                  /* exit code */
  95. /* Process -o and -m options (if specified), free up malloc'ed stuff, and
  96.    exit with the code e. */
  97. {
  98.   int r;                /* return value from trash() */
  99.   ulg t;                /* latest time in zip file */
  100.   struct zlist far *z;  /* pointer into zfile list */
  101.  
  102.   /* If latest, set time to zip file to latest file in zip file */
  103.   if (latest && zipfile && strcmp(zipfile, "-"))
  104.   {
  105.     diag("changing time of zip file to time of latest file in it");
  106.     /* find latest time in zip file */
  107.     if (zfiles == NULL)
  108.        warn("zip file is empty, can't make it as old as latest entry", "");
  109.     else {
  110.       t = 0;
  111.       for (z = zfiles; z != NULL; z = z->nxt)
  112.         /* Ignore directories in time comparisons */
  113.         if (t < z->tim && z->zname[z->nam-1] != '/')
  114.           t = z->tim;
  115.       /* set modified time of zip file to that time */
  116.       if (t != 0)
  117.         stamp(zipfile, t);
  118.       else
  119.         warn(
  120.          "zip file has only directories, can't make it as old as latest entry",
  121.          "");
  122.     }
  123.   }
  124.   if (tempath != NULL)
  125.   {
  126.     free((voidp *)tempath);
  127.     tempath = NULL;
  128.   }
  129.   if (zipfile != NULL)
  130.   {
  131.     free((voidp *)zipfile);
  132.     zipfile = NULL;
  133.   }
  134.  
  135.  
  136.   /* If dispose, delete all files in the zfiles list that are marked */
  137.   if (dispose)
  138.   {
  139.     diag("deleting files that were added to zip file");
  140.     if ((r = trash()) != ZE_OK)
  141.       err(r, "was deleting moved files and directories");
  142.   }
  143.  
  144.  
  145.   /* Done! */
  146.   freeup();
  147. #ifdef VMS
  148.   exit(0);
  149. #else /* !VMS */
  150.   exit(e);
  151. #endif /* ?VMS */
  152. }
  153.  
  154.  
  155. void err(c, h)
  156. int c;                  /* error code from the ZE_ class */
  157. char *h;                /* message about how it happened */
  158. /* Issue a message for the error, clean up files and memory, and exit. */
  159. {
  160.   static int error_level;
  161.   if (error_level++ > 0) exit(0);  /* avoid recursive err() */
  162.  
  163.   if (h != NULL) {
  164.     if (PERR(c))
  165.       perror("zip error");
  166.     fflush(mesg);
  167.     fprintf(stderr, "\nzip error: %s (%s)\n", errors[c-1], h);
  168.   }
  169.   if (tempzip != NULL)
  170.   {
  171.     if (tempzip != zipfile) {
  172.       if (tempzf != NULL)
  173.         fclose(tempzf);
  174. #ifndef DEBUG
  175.       destroy(tempzip);
  176. #endif
  177.       free((voidp *)tempzip);
  178.     } else {
  179.       /* -g option, attempt to restore the old file */
  180.       int k = 0;                        /* keep count for end header */
  181.       ulg cb = cenbeg;                  /* get start of central */
  182.       struct zlist far *z;  /* steps through zfiles linked list */
  183.  
  184.       fprintf(stderr, "attempting to restore %s to its previous state\n",
  185.          zipfile);
  186.       fseek(tempzf, cenbeg, SEEK_SET);
  187.       tempzn = cenbeg;
  188.       for (z = zfiles; z != NULL; z = z->nxt)
  189.       {
  190.         putcentral(z, tempzf);
  191.         tempzn += 4 + CENHEAD + z->nam + z->cext + z->com;
  192.         k++;
  193.       }
  194.       putend(k, tempzn - cb, cb, zcomlen, zcomment, tempzf);
  195.       tempzf = NULL;
  196.       fclose(tempzf);
  197.     }
  198.   }
  199.   if (key != NULL)
  200.     free((voidp *)key);
  201.   if (tempath != NULL)
  202.     free((voidp *)tempath);
  203.   if (zipfile != NULL)
  204.     free((voidp *)zipfile);
  205.   freeup();
  206. #ifdef VMS
  207.   c = 0;
  208. #endif
  209.   exit(c);
  210. }
  211.  
  212.  
  213. void error(h)
  214.   char *h;
  215. /* Internal error, should never happen */
  216. {
  217.   err(ZE_LOGIC, h);
  218. }
  219.  
  220. local void handler(s)
  221. int s;                  /* signal number (ignored) */
  222. /* Upon getting a user interrupt, turn echo back on for tty and abort
  223.    cleanly using err(). */
  224. {
  225. #if !defined(MSDOS) && !defined(__human68k__)
  226.   echon();
  227.   putc('\n', stderr);
  228. #endif /* !MSDOS */
  229.   err(ZE_ABORT, "aborting");
  230.   s++;                                  /* keep some compilers happy */
  231. }
  232.  
  233.  
  234. void warn(a, b)
  235. char *a, *b;            /* message strings juxtaposed in output */
  236. /* Print a warning message to stderr and return. */
  237. {
  238.   if (noisy) fprintf(stderr, "zip warning: %s%s\n", a, b);
  239. }
  240.  
  241.  
  242. local void license()
  243. /* Print license information to stdout. */
  244. {
  245.   extent i;             /* counter for copyright array */
  246.  
  247.   for (i = 0; i < sizeof(copyright)/sizeof(char *); i++) {
  248.     printf(copyright[i], "zip");
  249.     putchar('\n');
  250.   }
  251.   for (i = 0; i < sizeof(disclaimer)/sizeof(char *); i++)
  252.     puts(disclaimer[i]);
  253. }
  254.  
  255.  
  256. local void help()
  257. /* Print help (along with license info) to stdout. */
  258. {
  259.   extent i;             /* counter for help array */
  260.  
  261.   /* help array */
  262.   static char *text[] = {
  263. "",
  264. "Zip %s (%s). Usage:",
  265. "zip [-options] [-b path] [-t mmddyy] [-n suffixes] [zipfile list] [-xi list]",
  266. "  The default action is to add or replace zipfile entries from list, which",
  267. "  can include the special name - to compress standard input.",
  268. "  If zipfile and list are omitted, zip compresses stdin to stdout.",
  269. "  -f   freshen: only changed files  -u   update: only changed or new files",
  270. "  -d   delete entries in zipfile    -m   move into zipfile (delete files)",
  271. "  -k   simulate PKZIP made zipfile  -g   allow growing existing zipfile",
  272. "  -r   recurse into directories     -j   junk (don't record) directory names",
  273. "  -0   store only                   -l   convert LF to CR LF (-ll CR LF to LF)",
  274. "  -1   compress faster              -9   compress better",
  275. "  -q   quiet operation              -v   verbose operation",
  276. "  -c   add one-line comments        -z   add zipfile comment",
  277. "  -b   use \"path\" for temp file     -t   only do files after \"mmddyy\"",
  278. "  -@   read names from stdin        -o   make zipfile as old as latest entry",
  279. "  -x   exclude the following names  -i   include only the following names",
  280. #ifdef VMS
  281. " \"-F\"  fix zipfile(-FF try harder) \"-D\"  do not add directory entries",
  282. " \"-T\"  test zipfile integrity      \"-L\"  show software license",
  283. "  -w   append the VMS version number to the name stored in the zip file",
  284. " \"-V\"  save VMS file attributes",
  285. #else
  286. "  -F   fix zipfile (-FF try harder) -D   do not add directory entries",
  287. "  -T   test zipfile integrity       -L   show software license",
  288. #endif /* VMS */
  289. #ifdef OS2
  290. "  -E   use the .LONGNAME Extended attribute (if found) as filename",
  291. #endif /* OS2 */
  292. #ifdef S_IFLNK
  293. "  -y   store symbolic links as the link instead of the referenced file",
  294. #endif /* !S_IFLNK */
  295. #if defined(MSDOS) || defined(OS2)
  296. "  -$   include volume label         -S   include system and hidden files",
  297. #endif
  298. #ifdef CRYPT
  299. "  -e   encrypt  (-ee verify key)    -n   don't compress these suffixes"
  300. #else
  301. "  -h   show this help               -n   don't compress these suffixes"
  302. #endif
  303.   };
  304.  
  305.   for (i = 0; i < sizeof(copyright)/sizeof(char *); i++)
  306.   {
  307.     printf(copyright[i], "zip");
  308.     putchar('\n');
  309.   }
  310.   for (i = 0; i < sizeof(text)/sizeof(char *); i++)
  311.   {
  312.     printf(text[i], VERSION, REVDATE);
  313.     putchar('\n');
  314.   }
  315. }
  316.  
  317.  
  318. /* Do command line expansion for MSDOS, VMS, ATARI, and AMIGA but not OS/2 */
  319. #if defined(MSVMS) || defined(AMIGA)
  320. #  define PROCNAME(n) (action==ADD||action==UPDATE?wild(n):procname(n))
  321. #else /* !MSVMS */
  322. #  define PROCNAME(n) procname(n)
  323. #endif /* ?MSVMS */
  324.  
  325. local void zipstdout()
  326. /* setup for writing zip file on stdout */
  327. {
  328.   int r;
  329.   mesg = stderr;
  330.   if (isatty(1))
  331.     err(ZE_PARMS, "cannot write zip file to terminal");
  332.   if ((zipfile = malloc(4)) == NULL)
  333.     err(ZE_MEM, "was processing arguments");
  334.   strcpy(zipfile, "-");
  335.   if ((r = readzipfile()) != ZE_OK)
  336.     err(r, zipfile);
  337. }
  338.  
  339.  
  340. local void check_zipfile(zipname)
  341.   char *zipname;
  342.   /* Invoke unzip -t on the given zip file */
  343. {
  344. #if (defined(MSDOS) && !defined(__GO32__)) || defined(__human68k__)
  345.    if (spawnlp(P_WAIT, "unzip", "unzip", verbose ? "-t" : "-tqq",
  346.                zipname, NULL)) {
  347. #else
  348.    char cmd[128];
  349.    strcpy(cmd, "unzip -t ");
  350.    if (!verbose) strcat(cmd, "-qq ");
  351.    strcat(cmd, zipname);
  352. # ifdef VMS
  353.    if (!system(cmd)) {
  354. # else
  355.    if (system(cmd)) {
  356. # endif
  357. #endif
  358.      fprintf(mesg, "test of %s FAILED\n", zipfile);
  359.      err(ZE_TEST, "original files unmodified");
  360.    }
  361.    if (noisy)
  362.      fprintf(mesg, "test of %s OK\n", zipfile);
  363. }
  364.  
  365. local void get_filters(argc, argv)
  366.   int argc;               /* number of tokens in command line */
  367.   char **argv;            /* command line tokens */
  368. /* Counts number of -i or -x patterns, sets patterns and pcount */
  369. {
  370.   int i;
  371.   int flag = 0;
  372.  
  373.   pcount = 0;
  374.   for (i = 1; i < argc; i++) {
  375.     if (argv[i][0] == '-') {
  376.       if (strrchr(argv[i], 'i') != NULL) {
  377.         flag = 'i';
  378.       } else if (strrchr(argv[i], 'x') != NULL) {
  379.         flag = 'x';
  380.       } else {
  381.         flag = 0;
  382.       }
  383.     } else if (flag) {
  384.       if (patterns != NULL) {
  385.         patterns[pcount].zname = ex2in(argv[i], 0, (int *)NULL);
  386.         patterns[pcount].select = flag;
  387.         if (flag == 'i') icount++;
  388.       }
  389.       pcount++;
  390.     }
  391.   }
  392.   if (pcount == 0 || patterns != NULL) return;
  393.   patterns = (struct plist*) malloc(pcount * sizeof(struct plist));
  394.   if (patterns == NULL)
  395.     err(ZE_MEM, "was creating pattern list");
  396.   get_filters(argc, argv);
  397. }
  398.  
  399.  
  400. int main(argc, argv)
  401. int argc;               /* number of tokens in command line */
  402. char **argv;            /* command line tokens */
  403. /* Add, update, freshen, or delete zip entries in a zip file.  See the
  404.    command help in help() above. */
  405. {
  406.   int a;                /* attributes of zip file */
  407.   ulg c;                /* start of central directory */
  408.   int d;                /* true if just adding to a zip file */
  409.   char *e;              /* malloc'd comment buffer */
  410.   struct flist far *f;  /* steps through found linked list */
  411.   int i;                /* arg counter, root directory flag */
  412.   int k;                /* next argument type, marked counter,
  413.                            comment size, entry count */
  414.   ulg n;                /* total of entry len's */
  415.   int o;                /* true if there were any ZE_OPEN errors */
  416.   char *p;              /* steps through option arguments */
  417.   char *pp;             /* temporary pointer */
  418.   int r;                /* temporary variable */
  419.   int s;                /* flag to read names from stdin */
  420.   ulg t;                /* file time, length of central directory */
  421.   struct zlist far *v;  /* temporary variable */
  422.   struct zlist far * far *w;    /* pointer to last link in zfiles list */
  423.   FILE *x, *y;          /* input and output zip files */
  424.   struct zlist far *z;  /* steps through zfiles linked list */
  425.   char *zipbuf;         /* stdio buffer for the zip file */
  426.   FILE *comment_stream; /* set to stderr if anything is read from stdin */
  427.  
  428. #if defined(__IBMC__) && defined(__DEBUG_ALLOC__)
  429.   {
  430.     extern void DebugMalloc(void);
  431.     atexit(DebugMalloc);
  432.   }
  433. #endif
  434.  
  435.   mesg = (FILE *) stdout; /* cannot be made at link time for VMS */
  436.   comment_stream = (FILE *)stdin;
  437.  
  438.   init_upper();           /* build case map table */
  439.  
  440. #ifdef MACOS
  441.    argc = ccommand(&argv);
  442. #endif
  443.  
  444.   /* Process arguments */
  445.   diag("processing arguments");
  446.   if (argc == 1 && isatty(1))
  447.   {
  448.     help();
  449.     exit(0);
  450.   }
  451.   envargs(&argc, &argv, "ZIPOPT"); /* get options from environment */
  452.  
  453.   zipfile = tempzip = NULL;
  454.   tempzf = NULL;
  455.   d = 0;                        /* disallow adding to a zip file */
  456.   signal(SIGINT, handler);
  457. #ifdef SIGTERM                  /* AMIGADOS and others have no SIGTERM */
  458.   signal(SIGTERM, handler);
  459. #endif
  460.   k = 0;                        /* Next non-option argument type */
  461.   s = 0;                        /* set by -@ if -@ is early */
  462.  
  463.   get_filters(argc, argv);      /* scan first the -x and -i patterns */
  464.  
  465.   for (i = 1; i < argc; i++)
  466.   {
  467.     if (argv[i][0] == '-')
  468.       if (argv[i][1])
  469.         for (p = argv[i]+1; *p; p++)
  470.           switch(*p)
  471.           {
  472.             case '0':
  473.               method = STORE; level = 0; break;
  474.             case '1':  case '2':  case '3':  case '4':
  475.             case '5':  case '6':  case '7':  case '8':  case '9':
  476.                         /* Set the compression efficacy */
  477.               level = *p - '0';  break;
  478.             case 'b':   /* Specify path for temporary file */
  479.               tempdir = 1;
  480.               if (k != 0)
  481.                 err(ZE_PARMS, "use -b before zip file name");
  482.               else
  483.                 k = 1;          /* Next non-option is path */
  484.               break;
  485.             case 'c':   /* Add comments for new files in zip file */
  486.               comadd = 1;  break;
  487.             case 'd':   /* Delete files from zip file */
  488.               if (action != ADD)
  489.                 err(ZE_PARMS, "specify just one action");
  490.               action = DELETE;
  491.               break;
  492.             case 'D':   /* Do not add directory entries */
  493.               dirnames = 0; break;
  494.             case 'e':   /* Encrypt */
  495. #ifndef CRYPT
  496.               err(ZE_PARMS, "encryption not supported");
  497. #else /* CRYPT */
  498.               e = key == NULL ? (char *)NULL : key;
  499.               if ((key = malloc(PWLEN+1)) == NULL)
  500.                 err(ZE_MEM, "was getting encryption password");
  501.               if (getp(e == NULL ? "Enter password: " : "Verify password: ",
  502.                        key, PWLEN+1) == NULL)
  503.                 err(ZE_PARMS, "stderr is not a tty");
  504.               if (e != NULL)
  505.               {
  506.                 r = strcmp(key, e);
  507.                 free((voidp *)e);
  508.                 if (r)
  509.                   err(ZE_PARMS, "password not verified");
  510.               }
  511. #endif /* ?CRYPT */
  512.               break;
  513.             case 'F':   /* fix the zip file */
  514.               fix++; latest = 1; break;
  515.             case 'f':   /* Freshen zip file--overwrite only */
  516.               if (action != ADD)
  517.                 err(ZE_PARMS, "specify just one action");
  518.               action = FRESHEN;
  519.               break;
  520.             case 'g':   /* Allow appending to a zip file */
  521.               d = 1;  break;
  522.             case 'h': case 'H': case '?':  /* Help */
  523.               help();
  524.               leave(ZE_OK);
  525.             case 'j':   /* Junk directory names */
  526.               pathput = 0;  break;
  527.             case 'k':   /* Make entries using DOS names (k for Katz) */
  528.               dosify = 1;  break;
  529.             case 'l':   /* Translate end-of-line */
  530.               translate_eol++; break;
  531.             case 'L':   /* Show license, version */
  532.               license();
  533.               leave(ZE_OK);
  534.             case 'm':   /* Delete files added or updated in zip file */
  535.               dispose = 1;  break;
  536.             case 'n':   /* Don't compress files with a special suffix */
  537.               special = NULL; /* will be set at next argument */
  538.               break;
  539.             case 'o':   /* Set zip file time to time of latest file in it */
  540.               latest = 1;  break;
  541.             case 'p':   /* Store path with name */
  542.               break;            /* (do nothing as annoyance avoidance) */
  543.             case 'q':   /* Quiet operation */
  544.               noisy = 0;  break;
  545.             case 'r':   /* Recurse into subdirectories */
  546.               recurse = 1;  break;
  547.             case 'S':
  548.               hidden_files = 1;
  549.               break;
  550.             case 't':   /* Exclude files earlier than specified date */
  551.               if (before)
  552.                 err(ZE_PARMS, "can only have one -t");
  553.               k = 2;  break;
  554.             case 'T':   /* test zip file */
  555.               test = 1; break;
  556.             case 'u':   /* Update zip file--overwrite only if newer */
  557.               if (action != ADD)
  558.                 err(ZE_PARMS, "specify just one action");
  559.               action = UPDATE;
  560.               break;
  561.             case 'v':   /* Mention oddities in zip file structure */
  562.               verbose++;
  563.               break;
  564. #ifdef VMS
  565.             case 'V':   /* Store in VMS format */
  566.               vms_native = 1; break;
  567.             case 'w':   /* Append the VMS version number */
  568.               vmsver = 1;  break;
  569. #endif /* VMS */
  570.             case 'i':   /* Include only the following files */
  571.             case 'x':   /* Exclude following files */
  572.               if (k != 4 &&
  573.                   (k != 3 || (action != UPDATE && action != FRESHEN)))
  574.                 err(ZE_PARMS, "nothing to select from");
  575.               k = 5;
  576.               break;
  577. #ifdef S_IFLNK
  578.             case 'y':   /* Store symbolic links as such */
  579.               linkput = 1;  break;
  580. #endif /* S_IFLNK */
  581.             case 'z':   /* Edit zip file comment */
  582.               zipedit = 1;  break;
  583. #if defined(MSDOS) || defined(OS2)
  584.             case '$':   /* Include volume label */
  585.               volume_label = 1; break;
  586. #endif
  587.             case '@':   /* read file names from stdin */
  588.               comment_stream = NULL;
  589.               if (k < 3)        /* zip file not read yet */
  590.                 s = 1;          /* defer -@ until after zipfile read */
  591.               else if (strcmp(zipfile, "-") == 0)
  592.                 err(ZE_PARMS, "can't use - and -@ together");
  593.               else              /* zip file read--do it now */
  594.                 while ((pp = getnam(errbuf)) != NULL)
  595.                 {
  596.                   if ((r = PROCNAME(pp)) != ZE_OK)
  597.                     if (r == ZE_MISS)
  598.                       warn("name not matched: ", pp);
  599.                     else
  600.                       err(r, pp);
  601.                 }
  602.               break;
  603. #ifdef OS2
  604.             case 'E':
  605.               /* use the .LONGNAME EA (if any) as the file's name. */
  606.               use_longname_ea = 1;
  607.               break;
  608. #endif
  609.             default:
  610.             {
  611.               sprintf(errbuf, "no such option: %c", *p);
  612.               err(ZE_PARMS, errbuf);
  613.             }
  614.           }
  615.       else              /* just a dash */
  616.         switch (k)
  617.         {
  618.         case 0:
  619.           zipstdout();
  620.           k = 3;
  621.           if (s)
  622.             err(ZE_PARMS, "can't use - and -@ together");
  623.           break;
  624.         case 1:
  625.           err(ZE_PARMS, "invalid path");
  626.           break;
  627.         case 2:
  628.           err(ZE_PARMS, "invalid time");
  629.           break;
  630.         case 3:  case 4:
  631.           comment_stream = NULL;
  632.           if ((r = PROCNAME(argv[i])) != ZE_OK)
  633.             if (r == ZE_MISS)
  634.               warn("name not matched: ", argv[i]);
  635.             else
  636.               err(r, argv[i]);
  637.           if (k == 3)
  638.             k = 4;
  639.         }
  640.     else                /* not an option */
  641.     {
  642.       if (special == NULL)
  643.         special = argv[i];
  644.       else if (k == 5)
  645.         break; /* -i and -x arguments already scanned */
  646.       else switch (k)
  647.       {
  648.         case 0:
  649.           if ((zipfile = ziptyp(argv[i])) == NULL)
  650.             err(ZE_MEM, "was processing arguments");
  651.           if ((r = readzipfile()) != ZE_OK)
  652.             err(r, zipfile);
  653.           k = 3;
  654.           if (s)
  655.           {
  656.             while ((pp = getnam(errbuf)) != NULL)
  657.             {
  658.               if ((r = PROCNAME(pp)) != ZE_OK)
  659.                 if (r == ZE_MISS)
  660.                   warn("name not matched: ", pp);
  661.                 else
  662.                   err(r, pp);
  663.             }
  664.             s = 0;
  665.           }
  666.           break;
  667.         case 1:
  668.           if ((tempath = malloc(strlen(argv[i]) + 1)) == NULL)
  669.             err(ZE_MEM, "was processing arguments");
  670.           strcpy(tempath, argv[i]);
  671.           k = 0;
  672.           break;
  673.         case 2:
  674.         {
  675.           int yy, mm, dd;       /* results of sscanf() */
  676.  
  677.           if (sscanf(argv[i], "%2d%2d%2d", &mm, &dd, &yy) != 3 ||
  678.               mm < 1 || mm > 12 || dd < 1 || dd > 31)
  679.             err(ZE_PARMS, "invalid date entered for -t option");
  680.           before = dostime(yy + (yy < 80 ? 2000 : 1900), mm, dd, 0, 0, 0);
  681.           k = 0;
  682.           break;
  683.         }
  684.         case 3:  case 4:
  685.           if ((r = PROCNAME(argv[i])) != ZE_OK)
  686.             if (r == ZE_MISS)
  687.               warn("name not matched: ", argv[i]);
  688.             else
  689.               err(r, argv[i]);
  690.           if (k == 3)
  691.             k = 4;
  692.       }
  693.     }
  694.   }
  695.   if (k < 3) {               /* zip used as filter */
  696.     zipstdout();
  697.     comment_stream = NULL;
  698.     if ((r = procname("-")) != ZE_OK)
  699.       if (r == ZE_MISS)
  700.         warn("name not matched: ", "-");
  701.       else
  702.         err(r, "-");
  703.     k = 4;
  704.     if (s)
  705.       err(ZE_PARMS, "can't use - and -@ together");
  706.   }
  707.  
  708.   /* Clean up selections */
  709.   if (k == 3 && (action == UPDATE || action == FRESHEN)) {
  710.     for (z = zfiles; z != NULL; z = z->nxt) {
  711.       /* if -u or -f with no args, do all */
  712.       z->mark = pcount ? filter(z->zname) : 1;
  713.     }
  714.   }
  715.   if ((r = check_dup()) != ZE_OK)     /* remove duplicates in found list */
  716.     if (r == ZE_PARMS)
  717.       err(r, "cannot repeat names in zip file");
  718.     else
  719.       err(r, "was processing list of files");
  720.  
  721.   if (zcount)
  722.     free((voidp *)zsort);
  723.  
  724.   /* Check option combinations */
  725.   if (special == NULL) 
  726.     err(ZE_PARMS, "missing suffix list");
  727.   if (level == 9 || !strcmp(special, ";") || !strcmp(special, ":"))
  728.     special = NULL; /* compress everything */
  729.  
  730.   if (action == DELETE && (method != BEST || dispose || recurse ||
  731.       key != NULL || comadd || zipedit))
  732.     err(ZE_PARMS, "invalid option(s) used with -d");
  733.   if (linkput && dosify)
  734.     {
  735.       warn("can't use -y with -k, -y ignored", "");
  736.       linkput = 0;
  737.     }
  738.   if (test && !strcmp(zipfile, "-")) {
  739.     warn("can't use -T on stdout, -T ignored", "");
  740.   }
  741.   if ((action != ADD || d) && !strcmp(zipfile, "-"))
  742.     err(ZE_PARMS, "can't use -d,-f,-u or -g on stdout\n");
  743. #ifdef VMS
  744.   if (vms_native && translate_eol)
  745.     err(ZE_PARMS, "can't use -V with -l");
  746. #endif
  747.   if (zcount == 0 && (action != ADD || d))
  748.     warn(zipfile, " not found or empty");
  749.  
  750.  
  751.   /* If -b not specified, make temporary path the same as the zip file */
  752. #if defined(MSDOS) || defined(__human68k__) || defined(AMIGA)
  753.   if (tempath == NULL && ((p = strrchr(zipfile, '/')) != NULL ||
  754. #  ifdef MSDOS
  755.                           (p = strrchr(zipfile, '\\')) != NULL ||
  756. #  endif
  757.                           (p = strrchr(zipfile, ':')) != NULL))
  758.   {
  759.     if (*p == ':')
  760.       p++;
  761. #else
  762.   if (tempath == NULL && (p = strrchr(zipfile, '/')) != NULL)
  763.   {
  764. #endif
  765.     if ((tempath = malloc((int)(p - zipfile) + 1)) == NULL)
  766.       err(ZE_MEM, "was processing arguments");
  767.     r = *p;  *p = 0;
  768.     strcpy(tempath, zipfile);
  769.     *p = (char)r;
  770.   }
  771.  
  772.   /* For each marked entry, if not deleting, check if it exists, and if
  773.      updating or freshening, compare date with entry in old zip file.
  774.      Unmark if it doesn't exist or is too old, else update marked count. */
  775.   diag("stating marked entries");
  776.   k = 0;                        /* Initialize marked count */
  777.   for (z = zfiles; z != NULL; z = z->nxt)
  778.     if (z->mark) {
  779.       if (action != DELETE &&
  780.                 ((t = filetime(z->name, (ulg *)NULL, (long *)NULL)) == 0 ||
  781.                  t < before ||
  782.                  ((action == UPDATE || action == FRESHEN) && t <= z->tim)))
  783.       {
  784.         z->mark = 0;
  785.         z->trash = t && t >= before;    /* delete if -um or -fm */
  786.         if (verbose) {
  787.           fprintf(mesg, "zip diagnostic: %s %s\n", z->name,
  788.                  z->trash ? "up to date" : "missing or early");
  789.         }
  790.       }
  791.       else
  792.         k++;
  793. #if 0
  794.       fprintf(mesg, "t %ld, z->tim %ld, t-tim %ld\n", t, z->tim,
  795.               t-z->tim); /* ??? */
  796. #endif
  797.     }
  798.  
  799.   /* Remove entries from found list that do not exist or are too old */
  800.   diag("stating new entries");
  801.   for (f = found; f != NULL;)
  802.     if (action == DELETE || action == FRESHEN ||
  803.         (t = filetime(f->name, (ulg *)NULL, (long *)NULL)) == 0 ||
  804.         t < before || (namecmp(f->name, zipfile) == 0 && strcmp(zipfile, "-")))
  805.       f = fexpel(f);
  806.     else
  807.       f = f->nxt;
  808.  
  809.   /* Make sure there's something left to do */
  810.   if (k == 0 && found == NULL && !(zfiles != NULL && (latest || zipedit))) {
  811.     if (test && (zfiles != NULL || zipbeg != 0)) {
  812.       check_zipfile(zipfile);
  813.       leave(ZE_OK);
  814.     }
  815.     if (action == UPDATE || action == FRESHEN)
  816.       leave(ZE_OK);
  817.     else if (zfiles == NULL && latest)
  818.       err(ZE_NAME, zipfile);
  819.     else
  820.       err(ZE_NONE, zipfile);
  821.   }
  822.   d = (d && k == 0 && (zipbeg || zfiles != NULL)); /* d true if appending */
  823.  
  824.  
  825.   /* Before we get carried away, make sure zip file is writeable. This
  826.    * has the undesired side effect of leaving one empty junk file on a WORM,
  827.    * so when the zipfile does not exist already and when -b is specified,
  828.    * the writability check is made in replace().
  829.    */
  830.   if (strcmp(zipfile, "-"))
  831.   {
  832.     if (tempdir && zfiles == NULL && zipbeg == 0) {
  833.       a = 0;
  834.     } else {
  835.        x = zfiles == NULL && zipbeg == 0 ? fopen(zipfile, FOPW) : 
  836.                                            fopen(zipfile, FOPM);
  837.       /* Note: FOPW and FOPM expand to several parameters for VMS */
  838.       if (x == NULL)
  839.         err(ZE_CREAT, zipfile);
  840.       fclose(x);
  841.       a = getfileattr(zipfile);
  842.       if (zfiles == NULL && zipbeg == 0)
  843.         destroy(zipfile);
  844.     }
  845.   }
  846.   else
  847.     a = 0;
  848.  
  849.   /* Throw away the garbage in front of the zip file for -F */
  850.   if (fix) zipbeg = 0;
  851.  
  852.   /* Open zip file and temporary output file */
  853.   diag("opening zip file and creating temporary zip file");
  854.   x = NULL;
  855.   tempzn = 0;
  856.   if (strcmp(zipfile, "-") == 0)
  857.   {
  858. #if defined(MSDOS) || defined(__human68k__)
  859.     /* Set stdout mode to binary for MSDOS systems */
  860.     setmode(fileno(stdout), O_BINARY);
  861.     tempzf = y = fdopen(fileno(stdout), FOPW);
  862. #else
  863.     tempzf = y = stdout;
  864. #endif
  865.     /* tempzip must be malloced so a later free won't barf */
  866.     tempzip = malloc(4);
  867.     if (tempzip == NULL)
  868.       err(ZE_MEM, "allocating temp filename");
  869.     strcpy(tempzip, "-");
  870.   }
  871.   else if (d) /* d true if just appending (-g) */
  872.   {
  873.     if ((y = fopen(zipfile, FOPM)) == NULL)
  874.       err(ZE_NAME, zipfile);
  875.     tempzip = zipfile;
  876.     tempzf = y;
  877.     if (fseek(y, cenbeg, SEEK_SET))
  878.       err(ferror(y) ? ZE_READ : ZE_EOF, zipfile);
  879.     tempzn = cenbeg;
  880.   }
  881.   else
  882.   {
  883.     if ((zfiles != NULL || zipbeg) && (x = fopen(zipfile, FOPR_EX)) == NULL)
  884.       err(ZE_NAME, zipfile);
  885.     if ((tempzip = tempname(zipfile)) == NULL)
  886.       err(ZE_MEM, "allocating temp filename");
  887.     if ((tempzf = y = fopen(tempzip, FOPW)) == NULL)
  888.       err(ZE_TEMP, tempzip);
  889.     if (zipbeg && (r = fcopy(x, y, zipbeg)) != ZE_OK)
  890.       err(r, r == ZE_TEMP ? tempzip : zipfile);
  891.     tempzn = zipbeg;
  892.   }
  893. #ifndef VMS
  894.   /* Use large buffer to speed up stdio: */
  895.   zipbuf = (char *)malloc(ZBSZ);
  896.   if (zipbuf == NULL)
  897.     err(ZE_MEM, tempzip);
  898. # ifdef _IOFBF
  899.   setvbuf(y, zipbuf, _IOFBF, ZBSZ);
  900. # else
  901.   setbuf(y, zipbuf);
  902. # endif /* _IOBUF */
  903. #endif /* VMS */
  904.   o = 0;                                /* no ZE_OPEN errors yet */
  905.  
  906.  
  907.   /* Process zip file, updating marked files */
  908.   if (zfiles != NULL)
  909.     diag("going through old zip file");
  910.   w = &zfiles;
  911.   while ((z = *w) != NULL)
  912.     if (z->mark)
  913.     {
  914.       /* if not deleting, zip it up */
  915.       if (action != DELETE)
  916.       {
  917.         if (noisy)
  918.         {
  919.           fprintf(mesg, "updating: %s", z->zname);
  920.           fflush(mesg);
  921.         }
  922.         if ((r = zipup(z, y)) != ZE_OK && r != ZE_OPEN)
  923.         {
  924.           if (noisy)
  925.           {
  926.             putc('\n', mesg);
  927.             fflush(mesg);
  928.           }
  929.           sprintf(errbuf, "was zipping %s", z->name);
  930.           err(r, errbuf);
  931.         }
  932.         if (r == ZE_OPEN)
  933.         {
  934.           o = 1;
  935.           if (noisy)
  936.           {
  937.             putc('\n', mesg);
  938.             fflush(mesg);
  939.           }
  940.           perror("zip warning");
  941.           warn("could not open for reading: ", z->name);
  942.           warn("will just copy entry over: ", z->zname);
  943.           if ((r = zipcopy(z, x, y)) != ZE_OK)
  944.           {
  945.             sprintf(errbuf, "was copying %s", z->zname);
  946.             err(r, errbuf);
  947.           }
  948.           z->mark = 0;
  949.         }
  950.         w = &z->nxt;
  951.       }
  952.       else
  953.       {
  954.         if (noisy)
  955.         {
  956.           fprintf(mesg, "deleting: %s\n", z->zname);
  957.           fflush(mesg);
  958.         }
  959.         v = z->nxt;                     /* delete entry from list */
  960.         free((voidp *)(z->name));
  961.         free((voidp *)(z->zname));
  962.         if (z->ext)
  963.           free((voidp *)(z->extra));
  964.         if (z->cext && z->cextra != z->extra)
  965.           free((voidp *)(z->cextra));
  966.         if (z->com)
  967.           free((voidp *)(z->comment));
  968.         farfree((voidp far *)z);
  969.         *w = v;
  970.         zcount--;
  971.       }
  972.     }
  973.     else
  974.     {
  975.       /* copy the original entry verbatim */
  976.       if (!d && (r = zipcopy(z, x, y)) != ZE_OK)
  977.       {
  978.         sprintf(errbuf, "was copying %s", z->zname);
  979.         err(r, errbuf);
  980.       }
  981.       w = &z->nxt;
  982.     }
  983.  
  984.  
  985.   /* Process the edited found list, adding them to the zip file */
  986.   diag("zipping up new entries, if any");
  987.   for (f = found; f != NULL; f = fexpel(f))
  988.   {
  989.     /* add a new zfiles entry and set the name */
  990.     if ((z = (struct zlist far *)farmalloc(sizeof(struct zlist))) == NULL)
  991.       err(ZE_MEM, "was adding files to zip file");
  992.     z->nxt = NULL;
  993.     z->name = f->name;
  994.     f->name = NULL;
  995.     z->zname = f->zname;
  996.     f->zname = NULL;
  997.     z->ext = z->cext = z->com = 0;
  998.     z->mark = 1;
  999.     z->dosflag = f->dosflag;
  1000.     /* zip it up */
  1001.     if (noisy)
  1002.     {
  1003.       fprintf(mesg, "  adding: %s", z->zname);
  1004.       fflush(mesg);
  1005.     }
  1006.     if ((r = zipup(z, y)) != ZE_OK  && r != ZE_OPEN)
  1007.     {
  1008.       if (noisy)
  1009.       {
  1010.         putc('\n', mesg);
  1011.         fflush(mesg);
  1012.       }
  1013.       sprintf(errbuf, "was zipping %s", z->name);
  1014.       err(r, errbuf);
  1015.     }
  1016.     if (r == ZE_OPEN)
  1017.     {
  1018.       o = 1;
  1019.       if (noisy)
  1020.       {
  1021.         putc('\n', mesg);
  1022.         fflush(mesg);
  1023.       }
  1024.       perror("zip warning");
  1025.       warn("could not open for reading: ", z->name);
  1026.       free((voidp *)(z->name));
  1027.       free((voidp *)(z->zname));
  1028.       farfree((voidp far *)z);
  1029.     }
  1030.     else
  1031.     {
  1032.       *w = z;
  1033.       w = &z->nxt;
  1034.       zcount++;
  1035.     }
  1036.   }
  1037.   if (key != NULL)
  1038.   {
  1039.     free((voidp *)key);
  1040.     key = NULL;
  1041.   }
  1042.  
  1043.  
  1044.   /* Get one line comment for each new entry */
  1045.   if (comadd)
  1046.   {
  1047.     if (comment_stream == NULL) {
  1048.       comment_stream = fdopen(fileno(stderr), "r");
  1049.     }
  1050.     if ((e = malloc(MAXCOM + 1)) == NULL)
  1051.       err(ZE_MEM, "was reading comment lines");
  1052.     for (z = zfiles; z != NULL; z = z->nxt)
  1053.       if (z->mark)
  1054.       {
  1055.         if (noisy)
  1056.           fprintf(mesg, "Enter comment for %s:\n", z->name);
  1057.         if (fgets(e, MAXCOM+1, comment_stream) != NULL)
  1058.         {
  1059.           if ((p = malloc((k = strlen(e))+1)) == NULL)
  1060.           {
  1061.             free((voidp *)e);
  1062.             err(ZE_MEM, "was reading comment lines");
  1063.           }
  1064.           strcpy(p, e);
  1065.           if (p[k-1] == '\n')
  1066.             p[--k] = 0;
  1067.           z->comment = p;
  1068.           z->com = k;
  1069.         }
  1070.       }
  1071.     free((voidp *)e);
  1072.   }
  1073.  
  1074.   /* Get multi-line comment for the zip file */
  1075.   if (zipedit)
  1076.   {
  1077.     if (comment_stream == NULL) {
  1078.       comment_stream = fdopen(fileno(stderr), "r");
  1079.     }
  1080.     if ((e = malloc(MAXCOM + 1)) == NULL)
  1081.       err(ZE_MEM, "was reading comment lines");
  1082.     if (noisy && zcomlen)
  1083.     {
  1084.       fputs("current zip file comment is:\n", mesg);
  1085.       fwrite(zcomment, 1, zcomlen, mesg);
  1086.       if (zcomment[zcomlen-1] != '\n')
  1087.         putc('\n', mesg);
  1088.       free((voidp *)zcomment);
  1089.     }
  1090.     zcomment = malloc(1);
  1091.     *zcomment = 0;
  1092.     if (noisy)
  1093.       fputs("enter new zip file comment (end with .):\n", mesg);
  1094. #if (defined(AMIGA) && (defined(LATTICE)||defined(__SASC)))
  1095.       flushall();  /* tty input/output is out of sync here */
  1096. #endif
  1097.     while (fgets(e, MAXCOM+1, comment_stream) != NULL && strcmp(e, ".\n"))
  1098.     {
  1099.       if (e[(r = strlen(e)) - 1] == '\n')
  1100.         e[--r] = 0;
  1101.       if ((p = malloc((*zcomment ? strlen(zcomment) + 3 : 1) + r)) == NULL)
  1102.       {
  1103.         free((voidp *)e);
  1104.         err(ZE_MEM, "was reading comment lines");
  1105.       }
  1106.       if (*zcomment)
  1107.         strcat(strcat(strcpy(p, zcomment), "\r\n"), e);
  1108.       else
  1109.         strcpy(p, *e ? e : "\r\n");
  1110.       free((voidp *)zcomment);
  1111.       zcomment = p;
  1112.     }
  1113.     zcomlen = strlen(zcomment);
  1114.     free((voidp *)e);
  1115.   }
  1116.  
  1117.  
  1118.   /* Write central directory and end header to temporary zip */
  1119.   diag("writing central directory");
  1120.   k = 0;                        /* keep count for end header */
  1121.   c = tempzn;                   /* get start of central */
  1122.   n = t = 0;
  1123.   for (z = zfiles; z != NULL; z = z->nxt)
  1124.   {
  1125.     if ((r = putcentral(z, y)) != ZE_OK)
  1126.       err(r, tempzip);
  1127.     tempzn += 4 + CENHEAD + z->nam + z->cext + z->com;
  1128.     n += z->len;
  1129.     t += z->siz;
  1130.     k++;
  1131.   }
  1132.   if (k == 0)
  1133.     warn("zip file empty", "");
  1134.   if (verbose)
  1135.     fprintf(mesg, "total bytes=%lu, compressed=%lu -> %d%% savings\n",
  1136.            n, t, percent(n, t));
  1137.   t = tempzn - c;               /* compute length of central */
  1138.   diag("writing end of central directory");
  1139.   if ((r = putend(k, t, c, zcomlen, zcomment, y)) != ZE_OK)
  1140.     err(r, tempzip);
  1141.   tempzf = NULL;
  1142.   if (fclose(y))
  1143.     err(d ? ZE_WRITE : ZE_TEMP, tempzip);
  1144.   if (x != NULL)
  1145.     fclose(x);
  1146.  
  1147.   /* Free some memory before spawning unzip */
  1148.   lm_free();
  1149.  
  1150.   /* Test new zip file before overwriting old one or removing input files */
  1151.   if (test) {
  1152.     check_zipfile(tempzip);
  1153.   }
  1154.   /* Replace old zip file with new zip file, leaving only the new one */
  1155.   if (strcmp(zipfile, "-") && !d)
  1156.   {
  1157.     diag("replacing old zip file with new zip file");
  1158.     if ((r = replace(zipfile, tempzip)) != ZE_OK)
  1159.     {
  1160.       warn("new zip file left as: ", tempzip);
  1161.       free((voidp *)tempzip);
  1162.       tempzip = NULL;
  1163.       err(r, "was replacing the original zip file");
  1164.     }
  1165.     free((voidp *)tempzip);
  1166.   }
  1167.   tempzip = NULL;
  1168.   if (a && strcmp(zipfile, "-")) {
  1169.     setfileattr(zipfile, a);
  1170. #ifdef VMS
  1171.     /* If the zip file existed previously, restore its record format: */
  1172.     if (x != NULL)
  1173.       VMSmunch(zipfile, RESTORE_RTYPE, NULL);
  1174. #endif
  1175.   }
  1176.  
  1177.   /* Finish up (process -o, -m, clean up).  Exit code depends on o. */
  1178.   leave(o ? ZE_OPEN : ZE_OK);
  1179.   return 0; /* just to avoid compiler warning */
  1180. }
  1181.  
  1182. /*****************************************************************
  1183.  | envargs - add default options from environment to command line
  1184.  |----------------------------------------------------------------
  1185.  | Author: Bill Davidsen, original 10/13/91, revised 23 Oct 1991.
  1186.  | This program is in the public domain.
  1187.  |----------------------------------------------------------------
  1188.  | Minor program notes:
  1189.  |  1. Yes, the indirection is a tad complex
  1190.  |  2. Parenthesis were added where not needed in some cases
  1191.  |     to make the action of the code less obscure.
  1192.  ****************************************************************/
  1193.  
  1194. local void
  1195. envargs(Pargc, Pargv, envstr)
  1196. int *Pargc;
  1197. char ***Pargv;
  1198. char *envstr;
  1199. {
  1200.     char *getenv();
  1201.     char *envptr;                               /* value returned by getenv */
  1202.     char *bufptr;                               /* copy of env info */
  1203.     int argc = 0;                               /* internal arg count */
  1204.     int ch;                                             /* spare temp value */
  1205.     char **argv;                                /* internal arg vector */
  1206.     char **argvect;                             /* copy of vector address */
  1207.  
  1208.     /* see if anything in the environment */
  1209.     envptr = getenv(envstr);
  1210.     if (envptr == NULL || *envptr == 0) return;
  1211.  
  1212.     /* count the args so we can allocate room for them */
  1213.     argc = count_args(envptr);
  1214.     bufptr = malloc(1+strlen(envptr));
  1215.     if (bufptr == NULL)
  1216.         err(ZE_MEM, "Can't get memory for arguments");
  1217.  
  1218.     strcpy(bufptr, envptr);
  1219.  
  1220.     /* allocate a vector large enough for all args */
  1221.     argv = (char **)malloc((argc+*Pargc+1)*sizeof(char *));
  1222.     if (argv == NULL)
  1223.         err(ZE_MEM, "Can't get memory for arguments");
  1224.     argvect = argv;
  1225.  
  1226.     /* copy the program name first, that's always true */
  1227.     *(argv++) = *((*Pargv)++);
  1228.  
  1229.     /* copy the environment args first, may be changed */
  1230.     do {
  1231.         *(argv++) = bufptr;
  1232.         /* skip the arg and any trailing blanks */
  1233.         while ((ch = *bufptr) != '\0' && ch != ' ') ++bufptr;
  1234.         if (ch == ' ') *(bufptr++) = '\0';
  1235.         while ((ch = *bufptr) != '\0' && ch == ' ') ++bufptr;
  1236.     } while (ch);
  1237.  
  1238.     /* now save old argc and copy in the old args */
  1239.     argc += *Pargc;
  1240.     while (--(*Pargc)) *(argv++) = *((*Pargv)++);
  1241.  
  1242.     /* finally, add a NULL after the last arg, like UNIX */
  1243.     *argv = NULL;
  1244.  
  1245.     /* save the values and return */
  1246.     *Pargv = argvect;
  1247.     *Pargc = argc;
  1248. }
  1249.  
  1250. static int
  1251. count_args(s)
  1252. char *s;
  1253. {
  1254.     int count = 0;
  1255.     int ch;
  1256.  
  1257.     do {
  1258.         /* count and skip args */
  1259.         ++count;
  1260.         while ((ch = *s) != '\0' && ch != ' ') ++s;
  1261.         while ((ch = *s) != '\0' && ch == ' ') ++s;
  1262.     } while (ch);
  1263.  
  1264.     return count;
  1265. }
  1266.